文章目錄

一、Java集合的整體介紹
二、Collection介面
- 1、Collection介面方法
- 2、Collection子介面一：List
- - ①ArrayList ?
  - ②LinkedList
  - ③Vector
  - 面試題
- 3、Collection子介面二：Set
- - ①HashSet
  - ②SortedSet
三、Iterator迭代器介面
- 1、Iterator遍歷
- 2、foreach：增強for回圈
四、Map介面
- 1、Hashtable
- 2、HashMap?
- 3、SortedMap
五、Collections工具類

一、Java集合的整體介紹

Java 集合類可以用于存盤數量不等的多個物件，還可用于保存具有映射關系的
關聯陣列，很好的應對了陣列array的弊端，
使用的場景：
①Android客戶端 ②服務器 ③端資料庫

二、Collection介面

Collection介面：單列資料，定義了存取一組物件的方法的集合，

Collection 介面是 List、Set 和 Queue 介面的父介面，該介面里定義的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合，
JDK不提供此介面的任何直接實作，而是提供更具體的子介面(如：Set和List) 實作，
Java 集合會丟失容器中所有物件的資料型別，把所有物件都當成 Object 型別處理；但可以增加泛型，來實作Java 集合記住容器中物件的資料型別，

1、Collection介面方法

方法	方法說明
add(Object obj)	添加元素
addAll(Collection coll)	添加整個集合
int size()	獲取有效元素的個數
void clear()	清空集合
boolean isEmpty()	是否是空集合
boolean contains(Object obj)	是否包含某個元素，是通過元素的equals方法來判斷是否是同一個物件
boolean containsAll(Collection c)	是否包含某個元素，也是呼叫元素的equals方法來拿兩個集合的元素挨個比較，
boolean remove(Object obj)	通過元素的equals方法判斷是否是要洗掉的那個元素，只會洗掉找到的第一個元素
boolean removeAll(Collection coll)	洗掉集合中所有的此元素（取當前集合的差集）
boolean retainAll(Collection c)	取兩個集合中的交集（把交集的結果存在當前集合中，不影響c）
boolean equals(Object obj)	判斷集合是否相等
Object[] toArray()	轉成物件陣列
hashCode()	獲取集合物件的哈希值
iterator()	回傳迭代器物件，用于集合遍歷

package Collection介面;

import org.junit.Test;

import java.util.*;

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(true);

        // 1.contains(object obj):判斷當前集合中是否包含obj
        // 在判斷時會呼叫obj物件所在類的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains);    //true
        System.out.println(coll.contains(new String("Jerry")));  //true
        System.out.println(coll.contains(new Person("Tom", 15)));  //false  ---> true 進行重寫equals方法
        System.out.println(coll.contains(p));   //true

        //2.containsAll(Collection coll1) : 判斷形參coll1中的所有元素是否都存在于當前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));  //true
    }

    @Test
    public void test2(){
        //3.remove(Object obj):
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(false);

        coll.remove(1234);
        System.out.println(coll);   //[123, 456, Jerry, Collection介面.For_Iterator.Person{name='Tom', age=15}, false]
        coll.remove(new Person("Tom",15));
        System.out.println(coll);   //[123, 456, Jerry, false]

        //4.removeAll(Collection coll1):從當前的集合中移除從從coll1中的所有元素
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);    //[Jerry, false]
    }

    @Test
    public void test3(){
       Collection coll = new ArrayList();
       coll.add(123);
       coll.add(456);
       coll.add(new String("Jerry"));
       Person p = new Person("Tom",15);
       coll.add(p);
       coll.add(false);

  /*     // 5.retainAll(Collection coll): 交集 ：獲取當前集合和從coll1集合的交集，并回傳給當前集合
        Collection coll1 = Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll);   //[123, 456]*/

        //6.equals(Object obj) :
        Collection coll1 = new ArrayList();   //Array是有序的，如果add的順序不同，依然輸出false
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("Jerry"));
        coll1.add(new Person("Tom",15));
        coll1.add(false);

        System.out.println(coll.equals(coll1));   //true
    }

    @Test
    public void test4(){
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(false);

        // 7.hasCode() : 回傳當前物件的哈希值
        System.out.println(hashCode());

        //8.集合 --> 陣列 ：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //拓展 ：陣列 --> 集合  【注意asList要用包裝類，否則將視為一個元素】
        List<String> strings = Arrays.asList(new String[]{"AA", "BB", "CC", "DD"});
        System.out.println(strings);  //[AA, BB, CC, DD]

        List ints = Arrays.asList(new int[]{12, 34, 56});
        System.out.println(ints.size());  // 1
        List ints1 = Arrays.asList(new Integer[]{12, 34, 56});
        System.out.println(ints1.size()); // 3

        // 9.iterator(): 回傳Iterator()介面的實體，用于遍歷集合元素，放在IteratorTest.java 中測驗
    }
}

class Person{
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public String toString() {
        return "Collection介面.For_Iterator.Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2、Collection子介面一：List

List：元素有序，可重復的集合，

鑒于Java中陣列用來存盤資料的局限性，我們通常使用List替代陣列
List集合類中元素有序、且可重復，集合中的每個元素都有其對應的順序索引，
List容器中的元素都對應一個整數型的序號記載其在容器中的位置，可以根據序號存取容器中的元素，

JDK API中List介面的實作類常用的有：ArrayList、LinkedList和Vector，

List介面的主要方法：
【除了從Collection集合繼承的方法外，List 集合里添加了一些根據索引來操作集合元素的方法】

方法	方法說明
void add(int index, Object ele)	在index位置插入ele元素
boolean addAll(int index, Collection eles)	從index位置開始將eles中的所有元素添加進來
Object get(int index)	獲取指定index位置的元素
int indexOf(Object obj)	回傳obj在集合中首次出現的位置
int lastIndexOf(Object obj)	回傳obj在當前集合中末次出現的位置
Object remove(int index)	移除指定index位置的元素，并回傳此元素
Object set(int index, Object ele)	設定指定index位置的元素為ele
List subList(int fromIndex, int toIndex)	回傳從fromIndex到toIndex位置的子集合

①ArrayList ?

作為List 介面的主要實作類；執行緒不安全，效率高

ArrayList 類是一個可以動態修改的陣列，與普通陣列的區別就是它是沒有固定大小的限制，我們可以添加或洗掉元素，
ArrayList 繼承了 AbstractList ，并實作了 List 介面，

ArrayList 是一個陣列佇列，提供了相關的添加、洗掉、修改、遍歷等功能，

package List介面;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 常用方法總結：
 * 增：add(Object obj)
 * 刪：remove(int index) / remove(Object obj
 * 改：set(int index,Object ele)
 * 查：get(int index,Object ele)
 * 插：add(int index,Object obj)
 * 長度：size()
 */
public class ListTest {

    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(false);

        System.out.println(list);   //[123, 456, AA, For_Iterator.Person{name='Tom', age=12}, false]

        //1. void add (int index, Object ele) : 在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);  //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false]
        List list1 = Arrays.asList(1,2,3);
        //list.addAll(list1);     //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, 1, 2, 3]
        list.add(list1);          //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, [1, 2, 3]]
        System.out.println(list);

        //2.Object get(int index) : 獲取指定index位置的元素
        System.out.println(list.get(2));   // 456
    }

    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(false);

        //3.int index(Object obj) :  回傳obj在集合中首次出現的位置
        int index = list.indexOf(123);
        System.out.println(index);   // 0
        //4.int lastIndexOf(Object obj) : 回傳obj在集合中末次出現的位置
        int lastIndexOf = list.lastIndexOf(456);
        System.out.println(lastIndexOf);  // 1
        //5.Object remove(int index) : 移除指定index位置的元素，并回傳此元素
        Object obj = list.remove(0);
        System.out.println(obj);   // 123
        System.out.println(list);  // [456, AA, For_Iterator.Person{name='Tom', age=12}, false]
        //6.Object set(int index,Object ele) : 設定指定index位置的元素ele
        list.set(0,123);
        System.out.println(list);  //[123, AA, For_Iterator.Person{name='Tom', age=12}, false]
        //7.list subList(int formIndex,int toIndex) : 回傳從fromIndex到toIndex位置的左閉右開區間
        List subList = list.subList(2, 4);
        System.out.println(subList);  //[For_Iterator.Person{name='Tom', age=12}, false]
        System.out.println(list);   //[123, AA, For_Iterator.Person{name='Tom', age=12}, false]
    }
}

②LinkedList

對于頻繁的插入、洗掉操作、使用此類的效率比ArrayList搞；底層使用的是雙向串列存盤

鏈表（Linkedlist）是一種常見的基礎資料結構，是一種線性表，但是并不會按線性的順序存盤資料，而是在每一個節點里存到下一個節點的地址，
鏈表可分為單向鏈表和雙向鏈表，

一個單向鏈表包含兩個值: 當前節點的值和一個指向下一個節點的鏈接，

一個雙向鏈表有三個整數值: 數值、向后的節點鏈接、向前的節點鏈接，

【使用方式于ArrayList基本相同，在此就不進行代碼上的重復】

③Vector

作為List 介面古老實作類；執行緒安全，效率低；

面試題

ArrayList和LinkedList的異同?
二者都執行緒不安全，相對執行緒安全的Vector，執行效率高，
此外，ArrayList是實作了基于動態陣列的資料結構，LinkedList基于鏈表的資料結構，對于隨機訪問get和set，ArrayList優于LinkedList，因為LinkedList要移動指標，對于新增和洗掉操作add(特指插入)和remove，LinkedList比較占優勢，因為ArrayList要移動資料，

ArrayList和Vector的區別?
Vector和ArrayList幾乎是完全相同的,唯一的區別在于Vector是同步類(synchronized)，屬于強同步類，因此開銷就比ArrayList要大，訪問要慢，正常情況下,大多數的Java程式員使用ArrayList而不是Vector,因為同步完全可以由程式員自己來控制，Vector每次擴容請求其大小的2倍空間，而ArrayList是1.5倍，Vector還有一個子類Stack，

3、Collection子介面二：Set

Set：元素無序，不可重復的集合， 儲存無序的 ≠ 隨機性，根據資料的hash值順序進行添加

Set介面是Collection的子介面，set介面沒有提供額外的方法，
Set集合不允許包含相同的元素，如果試把兩個相同的元素加入同一個 Set 集合中，則添加操作失敗，
Set 判斷兩個物件是否相同不是使用 == 運算子，而是根據 equals() 方法，

①HashSet

作為Set介面的主要實作類；執行緒不安全，可以存盤null值

LinkHashSet：作為HashSet的子類；遍歷其內部資料時，可以按照添加的順序遍歷

import org.junit.Test;

import java.util.*;

public class SetTest {
    /*
    Set介面 ：1. 儲存無序的 ≠ 隨機性，根據資料的hash值順序進行添加
             2. 不可重復的資料
     */
    @Test
    public void HashTest(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add(new Person("Tom",12));
        //set.add(new User("Tom",12));
        set.add("cc");
        set.add(false);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() + " ");
            //AA cc Collection介面.For_Iterator.Person{name='Tom', age=12} false 456 123
        }
    }
    

    @Test
    public void LinkedHashTest(){
        /*
        LinkedHashSet作為HashSet的子類，在添加資料的同時，每個資料還維護了兩個參考，記錄此資料前后兩個資料，
                優點 ：對于頻繁的遍歷操作，LinkedHashSet的效率要高于HashSet
         */
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add(new Person("Tom",12));
        set.add("cc");
        set.add(false);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
            //456 123 AA Collection介面.For_Iterator.Person{name='Tom', age=12} cc false
        }
    }
}

②SortedSet

TressSet：可以按照物件的指定屬性，進行排序，

換言之：TreeSet可以按照程式員自己的意愿進行排序；排序方法分為自由排序，定制排序

import org.junit.Test;

import java.util.*;

public class SetTest {

    @Test
    public void treeSetTest2() {
        /*
        定制排序:(比較的標準為：compare（）回傳0)
         */
        Comparator com = new Comparator() {
            //按照年齡從大到小排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User){
                    User user1 = (User)o1;
                    User user2 = (User)o2;
                    return Integer.compare(user1.getAge(), user2.getAge());
                }else {
                    throw new RuntimeException("輸入的資料型別不匹配");
                }
            }

           /* @Override
            public boolean equals(Object obj) {
                return false;
            }*/
        };
        TreeSet treeSet = new TreeSet(com);
        treeSet.add(new User("jerry", 3));
        treeSet.add(new User("Mike", 13));
        treeSet.add(new User("Shar", 15));
        treeSet.add(new User("Tom", 12));
        treeSet.add(new User("Tww", 12));

        Iterator iterator1 = treeSet.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
            //User{name='jerry', age=3}
            //User{name='Tom', age=12}
            //User{name='Mike', age=13}
            //User{name='Shar', age=15}
        }
    }
    

    @Test
    public void test3(){
        /**
         * 【面試題：】
         * 注意：重寫equals和hashCode方法
         */
        HashSet set = new HashSet();
        User u1 = new User("AA",1001);
        User u2 = new User("BB",1002);

        set.add(u1);
        set.add(u2);
        System.out.println(set);  //[User{name='AA', age=1001}, User{name='BB', age=1002}]

        u1.name = "CC";
        set.remove(u1);
        System.out.println(set); //[User{name='CC', age=1001}, User{name='BB', age=1002}]
        set.add(new User("CC",1001));
        System.out.println(set); //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='BB', age=1002}]
        set.add(new User("AA",1001));
        System.out.println(set);  //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='AA', age=1001}, User{name='BB', age=1002}]

    }
    
}

//建立一個實作Comparable的User類，用于上面Set的操作
class User implements Comparable {
    String name;
    int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //按照姓名從小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User) o;
            return this.name.compareTo(user.name);
        }else {
            throw new RuntimeException("輸入的型別不匹配");
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

三、Iterator迭代器介面

1、Iterator遍歷

Java Iterator（迭代器）不是一個集合，它是一種用于訪問集合的方法，可用于迭代 ArrayList 和 HashSet 等集合，
Iterator 是 Java 迭代器最簡單的實作，ListIterator 是 Collection API 中的介面，它擴展了Iterator 介面，
Iterator 僅用于遍歷集合，Iterator 本身并不提供承裝物件的能力，如果需要創建Iterator 物件，則必須有一個被迭代的集合，
集合物件每次呼叫iterator()方法都得到一個全新的迭代器物件，默認游標都在集合的第一個元素之前，

迭代器 iterator 的兩個基本操作是 next 、hasNext 和 remove，

呼叫 iterator.next() 會回傳迭代器的下一個元素，并且更新迭代器的狀態，
呼叫 iterator.hasNext() 用于檢測集合中是否還有元素，
呼叫 iterator.remove() 將迭代器回傳的元素洗掉，

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorTest {
    //迭代器Iterator介面，用于遍歷Collection集合中的元素
    //1.內部方法 hasNext()    next()
    //2.集合物件每次呼叫iterator()方法都得到一個全新的迭代器物件
    //3.內部定義了remove(),可以在遍歷的時候，洗掉集合中的元素，【不同于集合呼叫remove()】
    @Test
    public void tes1(){
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(false);

        Iterator iterator = coll.iterator();

/*        //方式一 :
        System.out.println(iterator.next());  //123
        System.out.println(iterator.next());  //456
        System.out.println(iterator.next());  //Jerry
        System.out.println(iterator.next());  //Collection介面.For_Iterator.Person{name='Tom', age=15}
        System.out.println(iterator.next());  //false
        System.out.println(iterator.next());  //超出集合的范圍，報錯NoSuchElementException*/

/*
        //方式二 :  不推薦
        for (int i=0;i< coll.size();i++){
            System.out.println(iterator.next());
        }
*/
        //方式三 :
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //測驗Iterator中的remove()
    @Test
    public void test2(){
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(false);

        //洗掉集合中的“Jerry"陣列
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if ("Jerry".equals(obj)){
                iterator.remove();
            }
        }
        //遍歷集合
        iterator = coll.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());           //此時輸出沒有了”Jerry“元素
        }
    }





//創建一個Person類，來作為集合的一個元素
class Person {
    private String name;
    private int age;

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
}

遍歷的原理：
hasNext()：判斷是否還有下一個元素
next()：指標下移；將下移以后集合位置上的元素回傳

2、foreach：增強for回圈

Java 5.0 提供了 foreach 回圈迭代訪問 Collection和陣列，

遍歷操作不需獲取Collection或陣列的長度，無需使用索引訪問元素，
遍歷集合的底層呼叫Iterator完成操作，
foreach還可以用來遍歷陣列，

package For_Iterator;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class ForTest {

    //foreach回圈，用于遍歷集合、陣列
    @Test
    public void test1(){
        Collection coll= new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Jerry"));
        Person p = new Person("Tom",15);
        coll.add(p);
        coll.add(false);

        //for(集合元素的型別  區域變數 : 集合物件)
        for (Object obj : coll){
            System.out.println(obj);
        }
    }

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};

        //for(陣列元素的型別  區域變數 : 陣列物件)
        for (int i : arr){
            System.out.println(i);
        }
    }

    //練習
    @Test
    public void test3(){
        String[] arr = new String[]{"qq","wwe","wear"};
        /*
        //方式一 ： 普通for回圈
        for (int i = 0; i < arr.length; i++) {
            arr[i] = "GG";
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");    //   GG GG GG
        }*/

        //方式二 ： 增強for回圈
        for(String i : arr){
            i = "GG";
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] +" ");    //  qq wwe wear 
        }
    }
}

四、Map介面

Map介面：雙列資料，保存具有映射關系“ key - value對 ”的集合，
Map與Collection是并列的存在；一個單列資料，一個雙列資料，

常用方法

方法	方法說明
Object put(Object key,Object value)	增：將指定key-value添加到(或修改)當前map物件中
Object remove(Object key)	刪：移除指定key的key-value對，并回傳value
void putAll(Map m)	改：將m中的所有key-value對存放到當前map中
void clear()	清空：清空當前map中的所有資料
Object get(Object key)	查：獲取指定key對應的value
boolean containsKey(Object key)	查：是否包含指定的key
boolean containsValue(Object value)	查：是否包含指定的Value
boolean isEmpty()	判斷當前map是否為空
boolean equals(Object obj)	判斷當前map和引數物件obj是否相等

原視圖操作的方法

方法	方法說明
Set keySet()	回傳所有key構成的Set集合
Collection values()	回傳所有value構成的Collection集合
Set entrySet()	回傳所有key-value對構成Set的集合

1、Hashtable

作為古老的實作類；執行緒安全，效率低；不能存盤null的key和value
Properties:常用來處理組態檔，key和value都是String型別

2、HashMap?

作為Map的主要實作類；執行緒不安全，效率高；能存盤null的key和value
LinkedHashMap:保證在遍歷map元素時，可以按照添加的順序實作遍歷，效率要高于HashMap，

public class MapTest {

    @Test
    public void test1(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",87);
        //修改
        map.put("AA",87);
        System.out.println(map);  // {AA=87, BB=87, 45=123}

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",234);
        map.putAll(map1);
        System.out.println(map);  // {AA=87, BB=87, CC=123, DD=234, 45=123}
        //洗掉
        Object value = map.remove(45);
        System.out.println(value);   // 123
        System.out.println(map);     // {AA=87, BB=87, CC=123, DD=234}
        //清空
        map.clear();
        System.out.println(map);  // {}
        System.out.println(map.size()); // 0
    }

    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",87);
        map.put("AA",87);

        Map map1 = new HashMap();
        map1.put("aa",123);
        map1.put("bb",345);
        System.out.println(map.get("AA"));  // 87
        System.out.println(map.containsKey("CC")); //false
        System.out.println(map.containsValue(123)); //true
        System.out.println(map.isEmpty());         //false
        System.out.println(map.size());           //3
        System.out.println(map.equals(map1));      //false
    }

    @Test
    public void test3(){
        /**
         * 遍歷
         * 1.Set keySet():回傳所有key構成的Set集合
         * 2.Collection values():回傳所有value構成的Collection集合
         * 3.Set entrySet():回傳所有key-value對構成Set的集合
         */
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",87);
        map.put("AA",87);
        //1.Set keySet():回傳所有key構成的Set集合
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next() + " ");  //AA BB 45
        }
        //2.Collection values():回傳所有value構成的Collection集合
        Collection values = map.values();
        for(Object obj: values){
            System.out.print(obj + " ");      // 87 87 123
        }
        //3.Set entrySet():回傳所有key-value對構成Set的集合
        Set set1 = map.entrySet();
        System.out.println(set1);   //[AA=87, BB=87, 45=123]
    }
}

3、SortedMap

TreeMap保證按照添加的key-value對進行排序，實作排序遍歷，此時考慮key的自然排序或定制排序，
自然排序：TreeMap 的所有的 Key 必須實作 Comparable 介面，而且所有的 Key 應該是同一個類的物件，否則將會拋出 ClasssCastException，
定制排序：創建 TreeMap 時，傳入一個 Comparator 物件，該物件負責對TreeMap 中的所有 key 進行排序，此時不需要 Map 的 Key 實作Comparable 介面，

五、Collections工具類

Collections : 操作Collection、Map的工具類

類名	類名解釋
reverse(List)	反轉List中元素的順序
shuffle(List)	對List集合元素進行隨機排序
sort(List)	根據元素的自然模式對指定List 集合元素按升序排序
sort(list,Comparator)	根據指定比較器Comparator產生的順序對指定串列進行排序，
swap(List,int,int)	將指定List集合中的 i 處元素和 j 處元素進行交換
Object max(Collection)	根據元素的自然順序，回傳給定集合中的最大元素
Object max (Collection,Comparator)	根據 Comparator 指定的順序，回傳給定集合中的最大元素
Object min(Collection)	根據元素的自然順序回傳給定 collection 的最小元素，
Object min (Collection,Comparator)	根據指定比較器Comparator產生的順序，回傳給定 collection 的最小元素，
int frequency(Collection,Object)	回傳指定集合中指定元素的出現次數
void copy(List dest,List src)	將src中的內容復制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal)	使用新值替換List對應舊值

import org.junit.Test;

import java.util.*;

/**
* Collections工具類的使用演示
*/
public class CollectionsTest {

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(-927);
        list.add(0);
        System.out.println(list);   //[123, 43, -927, 0]
        //reverse 反轉
        Collections.reverse(list);
        System.out.println(list);   //[0, -927, 43, 123]
        //shuffle 隨機
        Collections.shuffle(list);
        System.out.println(list);  // [43, 123, 0, -927]
        //sort 排序
        Collections.sort(list);
        System.out.println(list);  //[-927, 0, 43, 123]
        //swap  交換
        Collections.swap(list,1,2);
        System.out.println(list);  // [-927, 43, 0, 123]

        //Object max/min  最大值/最小值
        Object max = Collections.max(list);
        System.out.println(max);   // 123
        Object min = Collections.min(list);
        System.out.println(min);  // -927
        //frequency 頻率
        int frequency = Collections.frequency(list,123);
        int frequency1 = Collections.frequency(list,1);
        System.out.println(frequency);  // 1
        System.out.println(frequency1);  // 0
    }

    @Test
    public void test2(){
        //copy  復制
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(-927);
        list.add(0);
        /*
        錯誤寫法：java.lang.IndexOutOfBoundsException: Source does not fit in dest
        List dest = new ArrayList();
        Collections.copy(dest,list);
        System.out.println(dest);
        */
        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());  // 4
        Collections.copy(dest,list);
        System.out.println(dest);    //[123, 43, -927, 0]
        //replace 替換
        Collections.replaceAll(list,123,321);
        System.out.println(list);     // [321, 43, -927, 0]
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/292935.html

標籤：java

上一篇：2021Java面試題庫大全（內部資源）

下一篇：Java多執行緒（多執行緒基本操作，多執行緒安全問題等）

帶你了解Java高級編程-----集合