Collection集合-有解無憂

集合框架

Collection介面：所有單列集合最頂層介面
- List介面：單列集合中的一種
  
  是有序的集合，允許儲存重復的元素，有索引，可以使用普通for回圈遍歷
  - ArrayList集合：底層是陣列實作的，查詢快，增刪慢
  - LinkedList集合：底層是鏈表實作的，查詢慢，增刪快
  - Vector集合
- Set介面：單列集合中的一種
  
  不允許儲存重復元素，沒有索引，不能使用普通for回圈遍歷
  - HashSet集合：底層是哈希表（+紅黑樹）實作的，無序集合
  - LinkedHashSet集合：底層是哈希表+鏈表實作的，有序集合
  - TreeSet集合：底層是二叉樹實作，一般用于排序，無序集合

Collection單列集合共性方法：

boolean add(E) //增加元素
boolean contains(E) //判斷是否存在某個元素
boolean remove(E) //洗掉元素
boolean isEmpty() //判斷集合是否為空
int size() //獲取大小
Object[] toArray() //集合轉換為陣列
void clear() //清空

集合遍歷

迭代器

迭代：集合元素通用獲取方式，取出元素前先判斷集合中有沒有元素，如果有就把該元素取出來，再繼續，直到取出所有元素
使用Iterator介面對集合進行遍歷
- Iterator迭代器是一個介面，無法直接使用，需要使用Iterator介面的實作類物件
- Collection介面中有一個方法是Iterator()，回傳的是Iterator介面的實作類物件

使用步驟：

使用集合中Iterator()方法獲取迭代器實作類物件，使用Iterator介面接收（多型）
使用Iterator介面中的hasNext方法判斷有沒有下一個元素

使用Iterator介面中的Next方法取出集合中的下一個元素

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

//Iterator迭代器
public class IteratorDemo01 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("java");
        collection.add("100");

        //獲取迭代器
        Iterator<String> iterator = collection.iterator();
        //使用Iterator介面中的hasNext方法判斷有沒有下一個元素，回傳boolean值
        while (iterator.hasNext()){
            //使用Iterator介面中的Next方法取出集合中的下一個元素
            System.out.println(iterator.next());
        }
    }
}

增強型for回圈

底層使用的也是迭代器，使用for回圈的格式簡化
所有單列集合都可以使用增強for回圈
增強for回圈可以用來遍歷集合和陣列

for(資料型別變數名 : 集合名){ // }
```
//增強for回圈
for(String s : collection){
    System.out.println(s);
}
```

泛型

泛型是一種未知的資料型別，當不知道使用什么資料型別的時候可以使用泛型，如E
創建集合物件的時候就會確定泛型的資料型別

ArrayList<Student> list = new ArrayList<>();

定義含有泛型的類和方法：

方法格式：修飾符 <泛型> 回傳值型別方法名(引數串列(使用泛型)){ //方法體; }

//定義含有泛型的類
public class GenericClassDemo<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
    
    //定義含有泛型的普通方法
    public <E> void method1 (E e){
        System.out.println(e);
    }

    //定義含有泛型的靜態方法
    public static <E> void method2(E e){
        System.out.println("靜態方法，輸入資料："+e);
    }
    
    public static void main(String[] args) {
            //創建一個泛型為Integer的物件
            GenericClassDemo<Integer> list1 = new GenericClassDemo<>();
            list1.setName(200);
            Integer name1 = list1.getName();
            System.out.println(name1);
        	list1.method1(100);//呼叫方法時確定泛型

            //創建一個泛型為String的物件
            GenericClassDemo<String> list2 = new GenericClassDemo<>();
            list2.setName("小明");
            System.out.println(list2.getName());
        
        	//呼叫靜態方法
       	    GenericClassDemo.method2("200");
        }
}

含有泛型的介面：

//定義含有泛型的介面
public interface GenericInterface<E> {
    public abstract void method(E e);
}

////////////////////////////////////////

/*
方法一：實作類實作介面，并指定介面泛型，此時覆寫重寫和呼叫方法時默認泛型為指定型別
 */
public class GenericInterfaceImpl01 implements GenericInterface<Double>{
    @Override
    public void method(Double d) {
        System.out.println("方法一覆寫重寫，輸入資料："+d);
    }
}

/*
方法二：介面用什么泛型，實作類就用什么泛型，創建物件的時候確定泛型型別
 */
public class GenericInterfaceImpl02<E> implements GenericInterface<E>{
    @Override
    public void method(E e) {
        System.out.println("方法二覆寫重寫，輸入資料："+e);
    }
}

////////////////////////////////////////

public class GenericClassMain {
    public static void main(String[] args) {
        GenericInterfaceImpl01 list3 = new GenericInterfaceImpl01();
        list3.method(8.8);//泛型已經默認為Double
        GenericInterfaceImpl02<String> list4 = new GenericInterfaceImpl02<>();
        list4.method("garen");//創建物件的時候確定泛型型別
    }
}

泛型通配符：<?> 表示，代表了任意資料型別

不能創建物件使用

只能作為方法引數使用

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

public class GenericWildcard {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("garen");
        list1.add("temmo");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(100);
        list2.add(200);

        arrayPrint(list1);
        arrayPrint(list2);
    }

    //定義一個方法能遍歷所有型別的ArrayList集合
    //此時不知道泛型型別，用泛型通配符
    public static void arrayPrint(ArrayList<?> list){
        Iterator<?> iterator = list.iterator();//獲取迭代器
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
//        for(Object o: list){
//            System.out.println(o);
//        }
    }
}

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

標籤：Java

上一篇：演算法的時間復雜度和空間復雜度

下一篇：Java | 頂層類 Top-Level Class