一、集合的概述

當需要在java程式中記錄多個型別不同的物件資料時，則準備一個集合，

集合的頂層框架是：java.util.Collection集合和java.util.Map集合

Collection存取元素單位是單個元素，Map是單對元素，

二、Collection集合

（一）Collection分類

Collection包括List介面，Queue介面和Set介面，

List介面包括：ArrayList類,LinkedList類,Stack類,Vector類

Set介面包括: HashSet類,TreeSet類

（二）Collection的常用方法

boolean add();							添加單個元素

boolean addAll();						添加全部元素

boolean contains();					判斷是否包含指定物件

boolean containsAll();				判斷是否包含全部物件

boolean retainAll();					保留當前集合中存在且引數集合中存在的所有物件

boolean remove();						移除某個元素

boolean removeAll();					移除指定的所有元素

void clear();									清空集合

int size();										回傳包含物件的個數

boolean isEmpty();						判斷是否為空

boolean equals();							判斷是否相等

int hashCode();								獲取當前集合的哈希碼值

Object[] toArray();							將集合轉為陣列

Iterator iterator();							獲取當前集合的迭代器

（三）Collection集合中添加元素

public class Test1 {
    public static void main(String[] args) {
        // 創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        // 輸出結果為 [] // 因為還沒有往里面添加元素
        System.out.println(a1);
        // 輸出一行線方便與下面的輸出分隔開，方便觀察
        System.out.println("--------------------------------------");
        // 添加單個元素
        a1.add("wang");
        System.out.println(a1);
        a1.add(123);
        System.out.println(a1);
        a1.add("pikaqiu");
        System.out.println(a1);
        System.out.println("--------------------------------------");
        // 創建一個ArrayList集合指向Collection父型別
        Collection a2 = new ArrayList();
        // 將a1中的所有元素添加到a2里
        a2.addAll(a1);
        System.out.println(a2);
    }
}

（四）判斷是否包含某些元素

public class Test2 {
    public static void main(String[] args) {
        // 創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        //往集合a1中添加一系列元素
        a1.add(1);
        a1.add(2);
        a1.add("pikaqiu");
        //判斷a1中是否包含1,包含輸出true，不包含輸出false
        System.out.println("a1包含元素1："+a1.contains(1));
        //判斷a1中是否包含5,包含輸出true，不包含輸出false
        System.out.println("a1包含元素5："+a1.contains(5));
        System.out.println("----------------------------------------");
        // 創建一個ArrayList集合指向Collection父型別
        Collection a2 = new ArrayList();
        //往集合a2中添加一系列元素
        a2.add(1);
        a2.add(2);
        // 判斷集合a1是否包含集合a2
        System.out.println("a1包含集合a2："+a1.containsAll(a2));
        // 判斷集合a2是否包含集合a1
        System.out.println("a2包含集合a1："+a2.containsAll(a1));
        System.out.println("----------------------------------------");
        System.out.println("一開始的a1："+a1);
        // 判斷a1和a2都含有的物件并保留在a1中
        System.out.println(a1.retainAll(a2));
        System.out.println("后來的a1："+a1);
    }
}

(五) 移除集合中某些元素

public class Test3 {
    public static void main(String[] args) {
        // 創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        //往集合a1中添加一系列元素
        a1.add(1);
        a1.add(2);
        a1.add("pikaqiu");
        System.out.println("一開始的a1:"+a1);
        //移除a1中的元素1，移除成功輸出移除元素成功，失敗了輸出移除元素失敗
        System.out.println(a1.remove(1)?"移除元素成功":"移除元素失敗");
        System.out.println("移除元素后的a1："+a1);
        System.out.println("-------------------------------------------------");

        // 創建一個ArrayList集合指向Collection父型別
        Collection a2 = new ArrayList();
        //往集合a1中添加一系列元素
        a2.add(1);
        a2.add(2);
        a2.add(3);
        a2.add(4);
        a2.add(5);
        a2.add("pikaqiu");
        a2.add("pikaqiu1");
        a2.add("wangwenxiao");
        System.out.println("一開始的a2"+a2);
        // 在a2中移除掉所有a1元素，移除成功輸出移除元素成功，失敗了輸出移除元素失敗
        System.out.println(a2.removeAll(a1)?"移除元素成功":"移除元素失敗");
        System.out.println("移除元素后的a1："+a1);
        System.out.println("-------------------------------------------------");
        // 往a1里添加一些元素進行此處的判斷
        a1.add(1);
        a1.add(2);
        a1.add("pikaqiu");
        // 輸出未清空集合前的a1
        System.out.println("一開始的a1"+a1);
        //清空集合a1
        a1.clear();
        // 輸出清空集合后的a1
        System.out.println("清空集合后的a1："+a1);
        // 判斷集合a1是否為空
        System.out.println("集合a1是否為空："+a1.isEmpty());
        // 判斷集合a2是否為空
        System.out.println("集合a2是否為空："+a2.isEmpty());
        System.out.println("-------------------------------------------------");


    }
}

（六）集合與陣列間的相互轉換

public class Test4 {
    public static void main(String[] args) {
        // 創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        //往集合a1中添加一系列元素
        a1.add(1);
        a1.add(2);
        a1.add(3);
        a1.add(4);
        a1.add(5);
        a1.add("pikaqiu");
        a1.add("pikaqiu1");
        a1.add("wangwenxiao");
        //將集合轉為陣列
        Object[] objects=a1.toArray();
        //列印陣列中所有元素
        System.out.println("陣列中元素："+ Arrays.toString(objects));
        System.out.println("-------------------------------------------");
        //將陣列轉為集合
        Collection objects1=Arrays.asList(objects);
        //列印集合中的所有蒜素
        System.out.println("集合中元素："+objects1);
        System.out.println("-------------------------------------------");

    }
}

三、Iterator介面（迭代器）

迭代器是什么：迭代器是用于遍歷集合中的元素的一種方式

常用方法：

boolean hasNext(); 判斷集合中是否有可以訪問的元素

E next(); 用于取出一個元素并且指向下一個元素

void remove(); 用于洗掉訪問到的最后一個元素

通過迭代器遍歷集合

public class Test6 {
    public static void main(String[] args) {
        // 創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        //往集合a1中添加一系列元素
        a1.add(1);
        a1.add(2);
        a1.add(3);
        a1.add("pikaqiu1");
        a1.add("pikaqiu2");
        a1.add("pakaqiu3");
        System.out.println("該集合為："+a1);
        // 創建該集合的一個迭代器
        Iterator iterator = a1.iterator();
        // 利用while回圈依次輸出集合內資料
        // 注意 interator.hasNext() 是用來判斷當前集合是否還有資料可供輸出，該方法回傳一個boolean值型別
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("-----------------------------------");
        System.out.println("利用迭代器遍歷進行字串拼接輸出集合樣式");
        System.out.println("此處需要再創建一個迭代器,上面的迭代器已然結束");
        // 創建一個該集合的迭代器
        Iterator iterator1=a1.iterator();
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        while(iterator1.hasNext()){
            Object o=iterator1.next();
            if(iterator1.hasNext()) {
               sb.append(o).append(",").append(" ");
            }else {
                sb.append(o).append("]");
            }
            System.out.println(sb);
        }

    }
}

四、for……each遍歷集合

public class Test7 {
    public static void main(String[] args) {
        //創建一個ArrayList集合指向Collection父型別
        Collection a1 = new ArrayList();
        //往集合a1中添加一系列元素
        a1.add(1);
        a1.add(2);
        a1.add(3);
        a1.add(4);
        a1.add(5);
        a1.add("pikaqiu");
        a1.add("pikaqiu1");
        a1.add("wangwenxiao");
        
        //for each 遍歷集合并輸出資料
        for(Object o:a1){
            System.out.println(o);
        }
    }
}

五、List集合

（一）List分類

List的實作類主要有ArrayList，LinkedList，Stack ……

ArrayList：底層是采用動態陣列進行資料管理的，支持下標訪問，增刪元素不方便，

LinkedList：底層是采用雙向鏈表進行資料管理的，訪問不方便，但是增刪元素方便

Stack：堆疊，先進后出，后進先出

（二）List常用方法

void add(int index,E element) 向集合中指定位置添加元素

boolean addAll(int index,Collection<?extends E>c) 向集合中添加所有元素

E get(int index) 從集合中獲取指定位置的元素

int indexOf(Object o) 查找引數指定的物件是否存在，存在則回傳物件所在下標，不存在回傳-1

int lastIndexOf(Object o) 反向查找引數指定的物件是否存在，存在則回傳物件所在下標，不存在回傳-1

E set(int index,E element) 修改指定位置的元素

E remove(int index) 洗掉指定位置的元素

List subList(int fromIndex,int toIndex) 用于獲取子List

（三）List集合中增加元素

public class Test1 {
    public static void main(String[] args) {

        // 創建一個list集合物件LinkedList指向父型別List
        // 由于此處要進行List集合的增加操作，而list實作類里LinkedList類方便增刪操作，所以利用LinkedList實作類
        List list1 = new LinkedList();
        // 向集合中添加元素,可以指定下標也可以不指定下標
        // 如果不指定下標則依次增加，如果指定下標則按照下標進行添加
        list1.add(0,1);
        list1.add(1,"wang");
        list1.add(2,666);
        System.out.println("一開始的list1集合："+list1);
        System.out.println("在下標1處添加元素222，那么此處往后的元素會依次后移");
        list1.add(1,222);
        System.out.println("在下標為1處添加元素222后的list1集合："+list1);
        System.out.println("---------------------------------------------------------");
        
        // 創建一個list集合物件LinkedList指向父型別List
        // 由于此處要進行List集合的增加操作，而list實作類里LinkedList類方便增刪操作，所以利用LinkedList實作類
        List list2 = new LinkedList();
        // 向集合中添加元素,可以指定下標也可以不指定下標
        // 如果不指定下標則依次增加，如果指定下標則按照下標進行添加
        list2.add(0,111111);
        list2.add(1,"wang11111111");
        list2.add(2,66611111);
        System.out.println("集合list2："+list2);
        System.out.println("在集合list1下標3處增加list2所有元素，那么此處往后的下標會依次后移");
        list1.addAll(3,list2);
        System.out.println("在集合list1下標3處增加list2所有元素后的list1:"+list1);
        System.out.println("---------------------------------------------------------");

    }
}

（四）List集合中查找元素

public class Test2 {
    public static void main(String[] args) {
        // 創建一個list集合物件ArrayList指向父型別List
        // 由于此處要進行List集合的增加操作，而list實作類里ArrayList類支持下標訪問，所以利用ArrayList實作類
        List list1 = new ArrayList();
        // 向集合中添加元素,可以指定下標也可以不指定下標
        // 如果不指定下標則依次增加，如果指定下標則按照下標進行添加
        // 向集合中添加一系列元素
        list1.add(0,1);
        list1.add(1,"wang");
        list1.add(2,666);
        list1.add(3,1111);
        list1.add(4,"pi");
        list1.add(5,777);
        System.out.println("list1集合為："+list1);
        // 訪問下標為3的元素
        System.out.println("下標為3的元素是："+list1.get(3));
        System.out.println("---------------------------------------");
        System.out.println("查看集合list中是否存在666元素，存在回傳元素所在下標位置");
        System.out.println(list1.indexOf(666));
        System.out.println("查看集合list中是否存在66元素，不存在回傳-1");
        System.out.println(list1.indexOf(66));
    }
}

（五）List集合中修改元素

public class Test3 {
    public static void main(String[] args) {
        //定義一個list集合
        List list1 = new ArrayList();
        // 向集合中添加一系列元素
        list1.add(0,1);
        list1.add(1,"wang");
        list1.add(2,666);
        list1.add(3,1111);
        list1.add(4,"pi");
        list1.add(5,777);
        System.out.println("一開始的list1集合為："+list1);
        System.out.println("---------------------------------------------");
        // 獲取修改資料
        Scanner s=new Scanner(System.in);
        System.out.print("請輸入要修改元素的下標：");
        int index=s.nextInt();
        // 判斷所修改資料是否存在
        if(index<list1.size()) {
            System.out.print("指定元素存在，請輸入修改值：");
            String value=s.next();
            // 對list集合進行修改操作
            list1.set(index,value);
            System.out.println("被修改后的list1集合為："+list1);
        }else {
            System.out.print("指定元素不存在，修改行程結束！");
        }
        System.out.println("---------------------------------------------");
    }
}

（六）List集合中洗掉元素

public class Test4 {
    public static void main(String[] args) {
        //定義一個list集合
        List list1 = new ArrayList();
        // 向集合中添加一系列元素
        list1.add(0,1);
        list1.add(1,"wang");
        list1.add(2,666);
        list1.add(3,1111);
        list1.add(4,"pi");
        list1.add(5,777);
        System.out.println("一開始的list1集合為："+list1);
        System.out.println("-------------------------------------------------------");
        // 獲取洗掉元素資料
        Scanner s=new Scanner(System.in);
        System.out.print("請輸入要洗掉元素的下標：");
        int index=s.nextInt();
        // 對集合進行洗掉操作
        if(index<list1.size()) {
            System.out.println("指定洗掉元素存在，洗掉成功！");
            list1.remove(index);
        }else {
            System.out.println("指定元素不存在，洗掉失敗！");
        }
        System.out.println("洗掉元素后的集合為："+list1);
        System.out.println("-------------------------------------------------------");
        // 獲取洗掉元素資料
        System.out.print("請輸入要洗掉元素的值：");
        String value=s.next();
        // 對集合進行洗掉操作
        list1.remove(value);
        System.out.println("洗掉元素后的集合為："+list1);
        System.out.println("-------------------------------------------------------");

    }
}

(七) Stack

public class Test5 {
    public static void main(String[] args) {
        // new一個stack
        Stack stack = new Stack();
        // 對堆疊元素依次入堆疊并列印
        for(int i=1;i<10;i++){
            stack.push(i*3);
            System.out.println("第"+i+"個入堆疊的資料是："+(i*3));
        }
        System.out.println("stack= "+stack);
        System.out.println("--------------------------------------------");
        // 查看堆疊頂元素并列印
        System.out.println("stack中堆疊頂元素是："+stack.peek());
        System.out.println("--------------------------------------------");
        // 對堆疊中元素依次出堆疊并列印
        int size=stack.size();
        for(int i=1;i<=size;i++){
            // 得到出堆疊元素
            Object o= stack.pop();
            System.out.println("第"+i+"個出堆疊的資料是："+o);
        }
        System.out.println("---------------------------------------------");

    }
}

六、Queue集合

(一) Queue概述

? 先進先出，實作類主要有LinkedList類

(二) Queue集合常用方法

boolean offer(E e);			將一個物件添加至隊尾，若添加成功則回傳true

E poll();			從隊首回傳并洗掉一個元素

E peek();              回傳隊首的元素，但并不洗掉

(三) Queue集合添加，列印，洗掉元素

public class Test1 {
    public static void main(String[] args) {
        // 創建一個物件
        Queue queue1 = new LinkedList();
        // 添加元素
        queue1.offer(1);
        queue1.offer(2);
        queue1.offer(3);
        // 列印出集合
        System.out.println("queue1= "+queue1);
        System.out.println("-----------------------------------------------");
        int size=queue1.size();
        for(int i=1;i<=size;i++){
            System.out.println(queue1.poll()+"洗掉成功");
            System.out.println("洗掉后的queue1："+queue1);
        }
    }
}

七、泛型

<> 里面寫資料型別，表示只能存放該資料型別的資料，

（一）自定義泛型類

public class Person<T> {
    private String name;
    private int age;
    private T high;

    public Person() {
        super();
    }

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

    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;
    }

    public T getHigh() {
        return high;
    }

    public void setHigh(T high) {
        this.high = high;
    }

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

（二）自定義泛型類測驗

public class PersonTest {
    public static void main(String[] args) {
        Person<String> p=new Person<>();
        p.setHigh("111");
        System.out.println(p);
    }
}

 	輸出：Person{name='null', age=0, high=111}
	輸出結果對應的是Person類中的toString方法

（三）自定義泛型類被子類繼承時


//  person類中的泛型在繼承的時候都是沒有保留的 
1.    public class SubPerson extends Person { //丟棄泛型并且沒有指定型別，默認為Object型別 }
2.    public class SubPerson extends Person<String> { //丟棄泛型但是指定了泛型型別 }

（四）自定義泛型方法

語法格式：
    	[訪問權限] <泛型> 回傳值型別  方法名[泛型標識 引數名稱]{  方法體； }

例如：
    public <E> void t[E e]{}

（五）泛型通配符？？？

	<?>      無限制通配符:表示我們可以傳入任意型別的引數
    <? extends E>    型別的上界是E，只能是E或者E的子類
    <? super E>		型別的下界是E，只能是E或者E的父類

八、Set集合

（一）Set集合概述

		Set集合不分進入次序
        Set資料不允許重復，list的資料允許重復
        Set集合的實作類主要有HashSet（底層是哈希表進行資料管理的）
            			和TreeSet（底層是紅黑樹進行資料管理的）
		（HashSet的底層是Map集合
			有序二叉樹（是特殊的二叉樹）：左子節點<根節點<右子節點
			紅黑樹數特殊的有序二叉樹 ）

（二）HashSet集合中添加元素

public class Test1 {
    public static void main(String[] args) {
        HashSet<String> s = new HashSet<>();
        System.out.println(s);
        s.add("wang");
        System.out.println(s);
        s.add("wen");
        System.out.println(s);
        s.add("xiao");
        System.out.println(s);
        System.out.println("--------------------");
        System.out.println("驗證元素不能重復：");
        System.out.println(s.add("wang")?"元素插入成功":"元素重復，插入失敗");
    }
}

（三）TreeSet

實作自然排序
    public int compareTo( ){
    		// return 0;  //呼叫物件和引數物件相等
    		// return -1;  //呼叫物件小于引數物件
            // return 1;   // 呼叫物件大于引數物件
	}
實作比較器排序
    Comparator<型別> c=new Comparator<型別>(){
          public int compare(型別 n1,型別 n2){
              //n1是新增物件，n2是已有物件
              return n1.getAge()-n2.getAge(); // 按照年齡排序
          }
	}

九、Map集合（java.util.Map）

（一）Map集合概述

		Map<K,V>  K:Key,相當于目錄   V：Value，值
        Key是不允許重復的，該列相當于collection
        Key和Value都是String型別的
        Map集合的主要實作類： HashMap類，TreeMap類，Hashtable類

（二)Map集合常用方法

	V put(K Key,V value)     將該對資料存入Map，如果集合中中已經包含Key，那么替換Key
                          所對應的Value，回傳值為該Key來源的Value，若沒有則回傳null
    V get(Object Key)        回傳與引數Key所對應的Value物件，如果不存在則回傳null
    boolean containKey(Object Key)     判斷集合中是否包含指定的Key
    boolean containValue(Object Value)     判斷集合中是否包含指定的KeyValue
    V remove(Object Key)          根據引數指定的key進行洗掉
    Set<k>  KeySet()            回傳此映射中包含的鍵的Set視圖
    Collection<V>  values()           回傳此映射總包含的值的Set視圖
    Set<Map.Entry<K,V>>  entrySet()            回傳此映射中包含的映射的Set視圖

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

標籤：java

上一篇：java 陣列詳解--用最通俗的語言寫出美妙的陣列-

下一篇：趣談ReentrantLock，看完直呼通俗易懂

集合類別庫