国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Java集合框架——List接口

褰辯話 / 2195人閱讀

摘要：第三階段常見對象的學習集合框架接口按照集合框架的繼承體系，我們先從中的接口開始學習一概述及功能演示概述在中充當著一個什么樣的身份呢有序的也稱為序列實現這個接口的用戶以對列表中每個元素的插入位置進行精確地控制。線程不安全，效率高。

第三階段 JAVA常見對象的學習 集合框架——List接口 

按照集合框架的繼承體系，我們先從Collection中的List接口開始學習
(一) 概述及功能（ArrayList演示） (1) 概述

List在Collection中充當著一個什么樣的身份呢？——有序的 collection(也稱為序列)

實現這個接口的用戶以對列表中每個元素的插入位置進行精確地控制。用戶可以根據元素的整數索引（在列表中的位置）訪問元素，并搜索列表中的元素。與 set 不同，列表通常允許重復的元素。

(2)List集合功能
A：基本功能：(繼承而來)
//添加功能
boolean add(E e)向集合中添加一個元素
    
//刪除功能
void clear()：移除集合中的所有元素
boolean remove(Object o)：從集合中移除指定的元素
boolean removeAll(Collection c):從集合中移除一個指定的集合元素(有一個就返回true)

//獲取功能
Iterator iterator():就是用來獲取集合中每一個元素。

//判斷功能
boolean isEmpty()：判斷集合是否為空
boolean contains(Object o)：判斷集合中是否包含指定元素
boolean containsAll(Collection c)：判斷集合中是否包含指定的一個集合中的元素

//長度功能
int size():獲取集合中元素的個數

//集合轉換為數組
Object[] toArray()
B：特有功能：
//添加功能:在指定位置添加元素
void add(int index,Object element)
   
//獲取功能:獲取指定位置的元素
Object get(int index)
   
//列表迭代器：List集合特有的迭代器
ListIterator listIterator()
   
//刪除功能：根據索引刪除元素,返回被刪除的元素
Object remove(int index)
   
//修改功能:根據索引修改元素，返回被修飾的元素。
Object set(int index,Object element)
A：add() 使用方法：

我們還是先寫一個List遍歷字符串的代碼

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        //創建集合對象
        List list = new ArrayList();


        //存儲元素
        list.add("I");
        list.add("love");
        list.add("you");
        list.add("?");
        list.add("?");

        //遍歷集合
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.print(s + " ");
        }
    }
}

//運行結果
I love you ? ?

通過這段代碼我們可以看到，List集合的特點——有序（存儲和去取出的元素一直），可重復

我們再使用List存儲學生對象并遍歷看看

//Student 自行補充

//StudentDemo類
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StudentDemo {
    public static void main(String[] args) {
        List list = new ArrayList();

        Student s1 = new Student("張三", 20);
        Student s2 = new Student("李四", 30);
        Student s3 = new Student("王五", 40);

        list.add(s1);
        list.add(s2);
        list.add(s3);

        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

//運行結果
張三---20
李四---30
王五---40

//Student s = (Student)it.next();       
//it.next()返回的是Object類型。
//(Student)it.next();是將Object類型強制轉換成Student類型。
//這樣才能夠調用getName()方法和getAge()方法。
B：add() 使用方法：
package cn.bwh_02_List.ArrayList;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StudentDemo {
    public static void main(String[] args) {
        List list = new ArrayList();

        Student s1 = new Student("張三", 20);
        Student s2 = new Student("李四", 30);
        Student s3 = new Student("王五", 40);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        //迭代器遍歷
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }

        //利用List的功能遍歷
        for (int x = 0; x < list.size(); x++){
            Student s = (Student) list.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

上面幾個實例中，我們使用了Iterator迭代器遍歷，下面我們介紹一種特別的迭代器

C： 列表迭代器：

ListIterator listIterator()：列表迭代器：List集合特有的迭代器

列表迭代器繼承于Iterator迭代器，可以直接使用hasNext() 和next()方法

基本功能：

//將指定的元素插入列表（可選操作）
void add(E e) 

//返回 true如果遍歷正向列表，列表迭代器有多個元素
boolean hasNext() 

//返回列表中的下一個元素，并且前進光標位置
E next() 

//從列表中刪除由 next()或 previous()返回的最后一個元素（可選操作） 
void remove() 

//用 指定的元素替換由 next()或 previous()返回的最后一個元素（可選操作）
void set(E e)

特有功能：

//獲取上一個元素
Object previous()

//判斷是否有元素
boolean hasPrevious()

列表迭代器的好處是相比Iterator提供了更多的方法，并且可以實現正向遍歷，才能逆向遍歷，所以一般來說意義不大。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo1 {
    public static void main(String[] args) {
        //創建集合對象
        List list = new ArrayList();

        //存儲元素
        list.add("I");
        list.add("love");
        list.add("you");
        list.add("?");
        list.add("?");

        ListIterator lit= list.listIterator();
        //正向遍歷
        while(lit.hasNext()){
            String s = (String)lit.next();
            System.out.print(s + " ");
        }

        System.out.println();
        //逆向遍歷
        while (lit.hasPrevious()) {
            String s = (String) lit.previous();
            System.out.print(s + " ");

        }
    }
}

//運行結果
I love you ? ? 
? ? you love I
(二) 并發修改異常問題

我創建了一個集合，并且遍歷它，使用if語句判斷 是否集合中存在"love"這個字符串，若存在，就增加一個"?"元素,我們先順著這個思路寫一下代碼：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 *  并發修改異常
 */
public class Demo2 {
    public static void main(String[] args) {
        //創建集合對象
        List list = new ArrayList();

        //存儲元素
        list.add("I");
        list.add("love");
        list.add("you");

        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            if ("love".equals(s)) {
                list.add("?");
            }
            System.out.println(s);
        }
    }
}

//運行結果(節選)
Exception in thread "main" java.util.ConcurrentModificationException

我們貼出JDK中對這個異常的解釋：

This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
當不允許這樣的修改時，可以通過檢測到對象的并發修改的方法來拋出此異常。
(1) 原因解釋：

當我們對集合進行遍歷的時候，我們會獲取當前集合的迭代對象

//List為例，獲取集合的迭代對象
Iterator it = list.iterator();

這個迭代對象中，封裝了迭代器的方法與集合本身的一些方法，當我們在迭代中使用集合本身的add方法的時候，就產生了ConcurrentModificationException異常，通俗的說就是，在判斷成功后，集合中元素增加了，但是迭代器不清楚，所以就報錯，如果迭代器中含有這一種方法(假設)，我們是用迭代器添加元素就不會有問題了。

針對這個問題，我們給出兩個解決方案

(2) 解決方案：

##### 方式1：迭代器迭代元素，迭代器修改元素

我們假想如果Iterator迭代器中有添加功能就好了，但很遺憾并沒有，但是它的子接口ListIterator卻擁有這個功能

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo2 {
    public static void main(String[] args) {
        //創建集合對象
        List list = new ArrayList();


        //存儲元素
        list.add("I");
        list.add("love");
        list.add("you");

        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            String s = (String) lit.next();
            if ("love".equals(s)) {
                lit.add("?");
            }
            System.out.print(s + " ");
        }
    }
}

//運行結果
I love you
2：集合遍歷元素，集合修改元素(普通for)
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo2 {
    public static void main(String[] args) {
        //創建集合對象
        List list = new ArrayList();

        //存儲元素
        list.add("I");
        list.add("love");
        list.add("you");

        for (int x = 0; x < list.size(); x++){
            String s = (String)list.get(x);
            if ("love".equals(s)){
                list.add("?");
            }
            System.out.print(s + " ");
        }
    }
}

//運行結果
I love you ?

兩者均可以解決并發修改異常的問題，但是通過運行結果也可以看出，方法一添加后，在本次遍歷中不會輸出添加的結果，而方法二卻可以。

補充：增強for循環實現將集合進行遍歷，也產生了并發修改異常，這是因為增強for在底層也是調用的集合本身的remove

(3) 總結：

在迭代器遍歷時，如果需要對集合進行增刪操作時，要調用迭代器本身的remove方法，或者選擇使用普通for進行遍歷

(三) Vector (過時，不推薦) 
特有功能
    a:添加
        public void addElement(E obj)        --    add()
    b:獲取
        public E elementAt(int index)        --    get()
        public Enumeration elements()    --  iterator()
(四) List案例練習 
下面的案例題目個別來源于網絡，我們來整理，書寫一下。
案例(一)：集合嵌套存儲和遍歷元素的案例

需求：

我們班有學生，每一個學生是不是一個對象。所以我們可以使用一個集合表示我們班級的學生。ArrayList

但是呢，我們旁邊是不是還有班級，每個班級是不是也是一個 ArrayList

而我現在有多個ArrayList。也要用集合存儲，怎么辦呢 ?

按照我們的想法就是這個樣子的：ArrayList>

案例 (二)： 獲取10個1-20之間的隨機數，要求不能重復 
package cn.bwh_02_List.ArrayList.RandomDemo;

import java.util.ArrayList;
import java.util.Random;
/*
 *  分析：
 *      A：創建產生隨機數的對象
 *      B：創建一個存儲隨機數的集合
 *      C：定義一個統計變量，從0開始
 *      D：判斷統計遍歷是否小于10
 *          小于10：
 *              若不存在：就添加，同時統計變量++
 *              若不存在：則不作處理
 *          大于10；
 *              不作處理
 *      E：遍歷集合
 */
public class ArrayDemo {
    public static void main(String[] args) {
        Random r = new Random();
        ArrayList a = new ArrayList();
        int count = 0;
        while (count < 10) {
            int number = r.nextInt(20) + 1;
            if (!a.contains(number)){
                a.add(number);
                count++;
            }
        }

        for (Integer i : a){
            System.out.print(i + " ");
        }

    }
}
案例 (三) 鍵盤錄入多個數據

鍵盤錄入多個數據，以0結束，要求在控制臺輸出這多個數據中的最值

package cn.bwh_02_List.ArrayList.InputMore;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/*
 *  分析：
 *      A：創建鍵盤錄入數據對象
 *      B：鍵盤錄入多個數據,不知道數量，所以用集合存儲
 *      C：以0結束——只要鍵盤錄入的數據是0，就不繼續錄入數據了
 *      D：把集合轉成數組
 *      E：對數組排序
 *      F：獲取該數組中的最大索引的值
 */
public class AeeayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入數據");
        ArrayList a = new ArrayList();
        while (true) {
            int number = sc.nextInt();
            if (number != 0) {
                a.add(number);
            } else {
                break;
            }
        }

        Integer[] i = new Integer[a.size()];
        a.toArray(i);
        Arrays.sort(i);
        System.out.println(i[i.length - 1]);

    }
}
案例 (五) 登錄注冊案例（使用集合） 

package cn.bwh.pojo;

/**
 * 這是用戶基本描述類
 *
 * @author BWH_Steven
 * @version v1.0
 */

public class User {
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

package cn.bwh.dao;

import cn.bwh.pojo.User;

/**
 * 這是針對用戶進行操作的接口
 *
 * @author BWH_Steven
 * @version v1.0
 */
public interface UserDao {
    /**
     * 這是用戶登錄功能
     *
     * @param username 用戶名
     * @param password 密碼
     * @return 返回登錄是否成功
     */
    public abstract boolean isLogin(String username, String password);

    /**
     * 這是用戶注冊功能
     *
     * @param user 要注冊的用戶信息
     */
    public abstract void regist(User user);
}

因為注冊的時候很可能還要填寫
例如地址，性別，愛好等等信息（而登錄功能的時候往往只需要用戶名和密碼），所以這個注冊功能傳進來的參數過多，因此用對象代替過多的參數，也就是說，通過傳遞對象（User user）包含眾多信息避免了直接傳遞String username，password等等變量過多的問題

package cn.bwh.dao.impl;

import cn.bwh.dao.UserDao;
import cn.bwh.pojo.User;

import java.util.ArrayList;

/**
 * 這是用戶操作的具體實現類（集合類）
 *
 * @author BWH_Steven
 * @version v1.0
 */
public class UserDaoImpl implements UserDao {
    //為了多個集合能夠使用同一個集合，就把集合定義為成員變量
    //為了不讓外人看到，用private
    private static ArrayList array = new ArrayList();

    @Override
    public boolean isLogin(String username, String password) {

        //遍歷集合，獲取每一個用戶，并且判斷用戶的用戶名和密碼是否和傳遞過來的匹配
        boolean flag = false;

        for (User u : array) {
            if (u.getUsername().equals(username) && u.getPassword().equals(password)) ;
            flag = true;
            break;
        }

        return flag;
    }

    @Override
    public void regist(User user) {
        //把用戶信息存入集合內
        array.add(user);
    }
}
package cn.bwh.test;

import cn.bwh.dao.UserDao;
import cn.bwh.dao.impl.UserDaoImpl;
import cn.bwh.pojo.User;

import java.util.Scanner;

/**
 * 用戶測試類
 *
 * @author BWH_Steven
 * @version v1.0
 */
public class UserTest {
    public static void main(String[] args) {
        //為了能夠到主界面
        while (true) {
            System.out.println("------------初次見面，請多指教------------");
            System.out.println("1 登錄");
            System.out.println("2 注冊");
            System.out.println("3 退出");
            System.out.println("請輸入你的選擇");

            Scanner sc = new Scanner(System.in);
            //為了后面錄入信息方便，所有的數據錄入均使用字符串接受
            //Switch語句的多個地方要使用，對象就定義到外面
            String choicString = sc.nextLine();

            //調用注冊功能，使用多態
            UserDao ud = new UserDaoImpl();

            switch (choicString) {
                case "1":
                    System.out.println("----------------登錄系統----------------");
                    System.out.println("請輸入用戶名");
                    String username = sc.nextLine();
                    System.out.println("請輸入密碼");
                    String password = sc.nextLine();

                    //調用登錄功能
                    boolean flag = ud.isLogin(username, password);
                    if (flag) {
                        System.out.println("登陸成功");
                        System.exit(0);
                        //break; 這里break結束的是switch
                    } else {
                        System.out.println("用戶名或者密碼錯誤，登錄失敗");
                    }
                    break;
                case "2":
                    System.out.println("--------------新用戶注冊---------------");
                    System.out.println("請輸入用戶名");
                    String newUsername = sc.nextLine();
                    System.out.println("請輸入密碼");
                    String newPassword = sc.nextLine();

                    //把用戶名和密碼封裝到一個類中
                    User user = new User();
                    user.setUsername(newUsername);
                    user.setPassword(newPassword);

                    ud.regist(user);
                    System.out.println("注冊成功");
                    break;
                case "3":
                default:
                    System.out.println("謝謝使用，感謝你曾經來過過");
                    System.exit(0);
                    break;
            }

        }
    }
}
小結：

dao層主要連接數據庫，封裝增刪改查的數據庫語句

daoimpl是實現dao層方法的接口，所以可以把具體實現的方法寫在daoimpl中，dao層只寫方法名就可以。

Pojo代表簡單的Java對象

(五) List子類的特點（總結）

ArrayList:

? 底層數據結構是數組，查詢快，增刪慢。

? 線程不安全，效率高。

Vector:

? 底層數據結構是數組，查詢快，增刪慢。

? 線程安全，效率低。

LinkedList:

? 底層數據結構是鏈表，查詢慢，增刪快。

? 線程不安全，效率高。

使用具體情況：

? 保證安全：Vector

? (即使要安全，也不用這個，后面有替代的)

? 不保證安全：ArrayList或者LinkedList

? 查詢多：ArrayList

? 增刪多：LinkedList

結尾：

如果內容中有什么不足，或者錯誤的地方，歡迎大家給我留言提出意見, 蟹蟹大家 ！^_^

如果能幫到你的話，那就來關注我吧！（系列文章均會在公眾號第一時間更新）

在這里的我們素不相識，卻都在為了自己的夢而努力 ?
一個堅持推送原創Java技術的公眾號：理想二旬不止

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/75014.html

相關文章

  • Java? 教程（集合接口）

    集合接口 核心集合接口封裝了不同類型的集合，如下圖所示，這些接口允許獨立于其表示的細節來操縱集合，核心集合接口是Java集合框架的基礎，如下圖所示，核心集合接口形成層次結構。 showImg(https://segmentfault.com/img/bVbntJW?w=402&h=146); Set是一種特殊的Collection，SortedSet是一種特殊的Set，依此類推，另請注意，層次結構...

    elisa.yang 評論0 收藏0

  • Java集合框架——Map接口

    摘要：第三階段常見對象的學習集合框架集合在實際需求中，我們常常會遇到這樣的問題，在諸多的數據中，通過其編號來尋找某一些信息，從而進行查看或者修改，例如通過學號查詢學生信息。面試題和的區別是單列集合的頂層接口，有子接口和。 第三階段 JAVA常見對象的學習 集合框架——Map集合 showImg(https://segmentfault.com/img/remote/1460000019683...

    princekin 評論0 收藏0

  • Java 集合框架

    摘要：基礎部分集合框架接口接口泛型所有集合類都位于包下。集合框架的知識總結集合框架總結接口的使用集合框架總結類的排序問題聲明常量的兩種方法遍歷的四種方法泛型當我們把一個對象放入集合中后，系統會把所有集合元素都當成類的實例進行處理。 Java 基礎部分——集合框架 Collection 接口 Map 接口 泛型 所有集合類都位于java.util包下。集合中只能保存對象（保存對象的...

    Flink_China 評論0 收藏0

  • 集合框架知識系列01 總體框架

    摘要：集合工具包是在包中，實現了數據結構數組棧鏈表隊列映射和集合。集合主要可以劃分為個部分列表集合映射工具類迭代器枚舉類和。集合的框架圖如下圖片來源集合頂層接口主要有和。和都是集合遍歷相關接口，是特有的遍歷工具接口 Java集合工具包是在java.util.*包中，實現了數據結構：數組、棧、鏈表、隊列、映射和集合。Java集合主要可以劃分為4個部分：List列表、Set集合、Map映射、工具...

    honhon 評論0 收藏0

  • 集合框架源碼學習之ArrayList

    摘要：用戶自己指定容量創建大小的數組創建空數組默認構造函數，其默認初始容量為構造一個包含指定集合的元素的列表，按照它們由集合的迭代器返回的順序。以正確的順序返回該列表中的元素的迭代器。此方法充當基于陣列和基于集合的之間的橋梁。 目錄： 0-0-1. 前言 0-0-2. 集合框架知識回顧 0-0-3. ArrayList簡介 0-0-4. ArrayList核心源碼 0-0-5. Ar...

    BLUE 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<