集合

集合和數組的區別

• 元素類型：

  • 集合：引用類型（存儲基本類型時自動裝箱）

  • 數組：基本類型、引用類型

• 元素個數：

  • 集合：不固定，可以任意擴容

  • 數組：固定，不能改變容量

• 集合的好處：不受容器大小限制，可以隨時添加、刪除元素，提供了大量操作元素的方法（判斷、獲取等）

Java的集合體系

• 單列集合（Collection）

  List:

  ArraryList

  Set:

  HashSet

• 雙列集合（Map: Key，value）

Map:

HashMap

List集合

特點：可重復、有序（元素的存取順序一致）

注意：List是接口，所以可以通過創建其子類ArrayList對象來完成該接口的實例化 List list = new ArrayList();

List接口中的成員方法：

• public boolean add(E e);//將數據添加到集合的末尾，這里的E是泛型的意思，可以先理解為Object類型

• public E get(int index);//根據索引，索取其對應的元素

• public int size();//獲取集合長度

使用集合的步驟：

1. 創建集合對象

   //需求：往 List 集合中添加3個學生對象，然后遍歷
           // 1. 創建集合對象
           List list =new ArrayList();

2. 創建元素對象

   // 2. 創建元素對象
           Student s1=new Student("s1",11);
           Student s2=new Student("s1",11);
           Student s3=new Student("s3",13);
           Student s4=new Student("s4",14);

3. 將元素對象添加到集合對象中

    // 3. 將元素對象添加到集合對象中
           /*
           boolean b1=list.add(s1);
            System.out.println(b1);
            */
           list.add(s1);
           list.add(s2);
           list.add(s3);
           list.add(s4);

4. 遍歷集合

   //直接打印集合
           System.out.println(list);
           //獲取索引為 2 的元素
           Object obj=list.get(2);
           System.out.println(obj);
           //獲取集合中的元素個數
           System.out.println(list.size());
           // 4. 遍歷集合
           for(int i=0;i<list.size();i++){
               // i表示的是集合中每個元素的索引
               //獲取元素
               Object obj2=list.get(i);
               System.out.println("索引為"+i+"的元素為"+obj2);
           }

    

增強for循環和迭代器

增強for格式

for(元素的數據類型 變量名：要遍歷的數組或者集合對象){
    //循環體，變量也就是元素
}
?
快捷鍵：iter  回車

注意：增強for的底層依賴的是迭代器（Iterator）(增強for就是迭代器的簡寫形式)

對過程的重復，稱為迭代。

迭代器是遍歷Collection集合的通用方式。

迭代器（Iterator）的常用方法

• E next()：返回迭代的下一個元素對象

• boolean hasNext():如果仍有元素可以迭代，則返回true

//迭代器的使用方法
//1.根據集合對象獲取其對象的迭代器對象
//2.判斷迭代器中是否有元素
//3.如果有就獲取元素
使用迭代器遍歷 List 集合
      //通過迭代器遍歷 List集合
        //1.創建集合對象
        List list =new ArrayList();
        //2.創建元素對象
        //3.將元素對象添加到集合對象中
        list.add("a");
        list.add("b");
        list.add("c");
        //遍歷集合
        //迭代器的使用方法
        //1.根據集合對象獲取其對象的迭代器對象
        Iterator it=list.iterator();
        //2.判斷迭代器中是否有元素
        while(it.hasNext()){
            //3.如果有就獲取元素
            String s=(String)it.next();
            System.out.println(s);
        }
?
    }
    

注意：列表迭代器是List體系獨有的遍歷方式，可以在對集合遍歷的同時進行添加、刪除等操作，但是必須通過調用列表迭代器的方法來實現

//需求：判斷集合中如果有字符串"b",就在其后邊添加一個新的字符串：java
 List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        //1.根據集合對象獲取列表迭代器對象
        ListIterator lit = list.listIterator();
        //2.判斷迭代器中是否有元素
        while (lit.hasNext()) {
            //3.有就獲取元素
            String str = (String) lit.next();
            if ("b".equals(str)) { //這樣寫可以規避 空指針異常
                //能走到這兒，說明集合中有元素 b
                lit.add("java");
            }
            System.out.println(str);
        }
        System.out.println(list);
    }

總結：

1. 普通的迭代器在遍歷集合的同時不能添加或者刪除元素，否則會報：并發修改異常

2.列表迭代器在遍歷集合的同時可以修改集合中的元素（添加、刪除等），必須使用列表迭代器中的方法

泛型

定義：即泛指任意類型，又叫參數化類型(ParameterizedType），對具體類型的使用起到輔助作用，類似于方法的參數

集合類泛型的解釋：表示該集合中存放指定類型的元素

    //給 List 集合加上泛型String
    List<String> list = new ArrayList<>();//表示該集合中只能添加字符串類型的數據

泛型的好處：類型安全、避免了類型的轉換。泛型一般只和集合類相結合使用。

 //演示泛型（JDK5開始）
        List<String> list2 = new ArrayList<String>();//從JDK7開始，后面尖括號里的數據類型可以不寫
        list2.add("adv");
        list2.add("kkk");
        list2.add("honghong");
        for (String s : list2) {
            System.out.println(s);
        }
    }

Collections工具類

（針對集合進行操作的工具類）

成員方法：

• sort(List<T>)：根據元素的自然順序，將指定列表按升序排列

  //對集合進行升序排列
          Collections.sort(list);
          System.out.println("對集合進行升序排列后的結果為："+list);

• max(Collection<T>)：返回集合的最大元素

  //創建集合對象
          List<Integer> list=new ArrayList<>();
          //往集合中添加數據
           list.add(1);
           list.add(3);
           list.add(3);
           list.add(5);
           list.add(2);
           list.add(2);
           list.add(4);
          //打印集合
          System.out.println("沒有操作以前，集合中的數據是："+list);
          System.out.println("-------------------------------");
          //獲取集合中的最大值
          Integer max= Collections.max(list);
          System.out.println("集合中的最大元素是："+max);

• reverse(List<T>)：反轉List集合元素

  //對集合中的數據進行反轉
          Collections.reverse(list);
          System.out.println("集合反轉后的結果為："+list);

• shuffle(List<T>)：使用默認的隨機源隨機置換指定的列表

  //對集合進行隨機置換
          Collections.shuffle(list);
          System.out.println("隨機置換的結果為："+list);

   

  Set集合的特點和英語

  Set集合的特點：不可重復、無序

  應用：Set<T> set = new HashSet<>();

  案例：向Set集合中添加五個元素，并遍歷打印
      分析：A. 向集合中添加元素的方法為：add();
           B. 遍歷集合的方式：迭代器
      步驟：1. 創建集合對象：Set<Student> set = new HashSet<>();
           2. 分別創建五個Student對象
           3. 使用add方法將Student對象添加到集合中
           4. 使用迭代器遍歷集合并打印，注意添加順序和打印順序是否相同

  注意：因為Set集合保證元素的唯一性 依賴equals()和hashCode()兩個方法。如果沒有在自定義類中重寫這兩個方法，則默認調用的是Object類中的這兩個方法，而Object類中的equals()方法默認比較的是地址值是否相同。

//1.創建集合對象
        Set<Student> set=new HashSet<>();
        //2.創建元素對象
        Student s1=new Student("熊大",10);
        Student s2=new Student("熊二",9);
        Student s3=new Student("光頭強",28);
        Student s4=new Student("熊大",10);
        Student s5=new Student("熊二",9);
        //3.將元素對象添加到集合對象中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        //4.遍歷集合對象
        //通過迭代器遍歷 Set 集合
        //A.通過集合對象獲取其對應的迭代器對象
        Iterator<Student> it = set.iterator();
        //B.判斷迭代器中是否有元素
        while(it.hasNext()){
            //C.如果有，就獲取元素
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------");
        //通過增強 for 遍歷 Set 集合
        for (Student student : set) {
            System.out.println(student);
        }
    }

Map集合的特點和應用

Map集合的特點

• 雙列集合，元素由鍵值對（Entry）構成

  key -- value

• key不可以重復，value可以重復

應用：Map<T1,T2> map = new HashMap<>();

• T1表示鍵的數據類型

• T2表示值的數據類型

成員方法

• V put(K key, V value): 添加元素（鍵值對的形式），元素第一次添加，返回null，重復添加，會用新值覆蓋舊值，并返回舊值

• V get(Object key): 根據鍵獲取其對應的值

• Set<K> keySet(): 獲取所有鍵的集合

案例：向Map集合中添加三個元素，并遍歷打印
    分析：A.向map集合中添加元素的方法為：put()
         B.遍歷集合的方式：
             獲取所有的key：keySet()
             遍歷keySet，通過key獲取value：get()
         C.遍歷keySet的方法：iterator()
    
    步驟：
       1.創建集合對象：Map<Integer,Student> map = new HashMap<>();
       2.分別創建三個Student對象
       3.使用put方法將Student對象添加到集合中
       4.獲取所有的key，并使用迭代器遍歷
       5.通過key分別獲取對應的value并打印
          
        //向Map集合中添加三個元素，并遍歷打印
        //1.創建集合對象
        //鍵：學生的編號  值：具體的學生對象
        Map<Integer,Student> map = new HashMap<>();
        //2.創建元素對象
        Student s1=new Student("王大",21);
        Student s2=new Student("張三",22);
        Student s3=new Student("李四",23);
        //3.將元素對象添加到集合中
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);
        //4.遍歷集合
        //一、通過迭代器遍歷集合
        //4.1 獲取所有鍵的集合
        Set<Integer> keys =map.keySet();
        //4.2 遍歷所有的鍵，獲取到每一個鍵（迭代器 或者 增強for）
        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()){
            //如果迭代器中有數據就獲取
            Integer key=it.next();
            //4.3 根據鍵獲取指定的值，get()
            Student value=map.get(key);
            System.out.println(value);
        }
?
       /* //二、通過增強 for 遍歷集合
        //獲取所有鍵的集合
        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            // key就是雙列集合中的每一個鍵
            Student value = map.get(key);
            System.out.println(value);
        }
    }*/