List簡易筆記一

1.集合:動態儲存多個引用資料型別變數的容器,它空間可擴充套件(動態陣列，實際上是陣列的複製遷移)。

2.集合中常用概念:

• 有序:按新增的順序來存值就叫有序。
• 可排序:按照一定規則(比如按數字由小到大或大到小,按字典順序)來排序並存值。
• 唯一性:不可重複。

3.集合家族系譜圖:

3.1:Collection:儲存無序,可重複的單一物件

3.1.1:List:儲存有序,可重複的單一物件

1:ArrayList:儲存有序,可重複的單一物件,底層採用Object[]存值；
2:LinkedList:儲存有序,可重複的單一物件,底層採用雙向連結串列結構存值；

3.1.2:Set:儲存無序,唯一的單一物件

1:HashSet:儲存無序,唯一的單一物件,底層採用HashMap的Key存值；
2:TreeSet:儲存無序,但是可排序的,唯一的單一物件,底層採用TreeMap的Key存值

3.2:Map:按Key-Value對方式存值

3.2.1:HashMap:按key-value對的方式存值,Key是無序唯一的單一物件.底層採用陣列+連結串列結構存值。

3.2.2:TreeMap:按key-value對的方式存值,key是無序的可排序的唯一的單一物件.底層採用紅黑二叉樹結構存值。

4.ArrayList:儲存有序,可重複的單一物件.底層採用Object[]存值。一般情況下按原來1.5倍擴容。

優點:遍歷訪問集合中元素和修改集合中元素效率高
缺點:按照指定索引新增和刪除元素效率低
後續補圖

public static void main(String[] args) {
    //建立集合物件
    List alist=new ArrayList();
    //向集合中新增物件
    alist.add(11);//0
    alist.add(22);//1
    //向集合中指定索引處新增集合物件,索引取值範圍[0,集合.size()]
    alist.add(0, 66);//0
    
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
    
    System.out.println("--------------------");
    //修改集合中指定索引處的元素物件,0<=索引的範圍<集合.size()
    alist.set(0, 77);
    
    //遍歷集合
    for (int i = 0; i < alist.size(); i++) {
        System.out.println(alist.get(i));
    }
    
    System.out.println("*******************************");
    //按照索引刪除集合中元素物件,0<=索引的範圍<集合.size()
    alist.remove(1);
    //按照元素物件刪除
    alist.remove((Object)22);
    
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
    
    System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
    //清空集合
    alist.clear();
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
}

5.過濾器(filter):將不需要的資料過濾出去,將需要的資料留下

/**
 * 過濾器類
 */
public class MyFilter implements Predicate{
	/**
	 * 重寫過濾器中過濾方法
	 * @param t 代表集合中每個元素物件
	 * @return
	 */
	@Override
	public boolean test(Object t) {
        //集合中以1開頭的元素刪除
        if (t.toString().startsWith("1")) {
            return true;//刪除
        }
        return false;//不刪除
	}
}

public static void main(String[] args) {
    //建立集合物件
    List alist=new ArrayList();
    //向集合中新增物件
    alist.add(11);//0
    alist.add(22);//1
    alist.add(33);
    alist.add(14);
    
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
    
    
    //建立過濾器物件
    MyFilter mf=new MyFilter();
    //根據過濾器物件刪除元素物件
    alist.removeIf(mf);
    
    System.out.println("--------------------");
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
}

6.LinkedList:儲存有序,可重複的單一物件.底層採用雙向連結串列結構存值

優點:新增和刪除元素效率高
缺點:遍歷訪問元素和修改元素效率低
後續補圖

public static void main(String[] args) {
    //建立集合物件
    LinkedList alist=new LinkedList();
    //向集合中新增物件
    alist.add(11);//0
    alist.add(22);//1
    //向集合中指定索引處新增集合物件,0<=索引取值範圍<=集合.size()
    alist.add(0, 66);//0
    //向集合中第一個和最後一個位置新增元素
    //alist.addFirst(77);
    //alist.addLast(88);
    
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
    
    System.out.println("--------------------");
    //修改集合中指定索引處的元素物件,0<=索引的範圍<集合.size()
    alist.set(1, 77);
    
    //遍歷集合
    for (int i = 0; i < alist.size(); i++) {
        //得到集合中索引為i處的物件
        System.out.println(alist.get(i));
    }
    
    System.out.println("*******************************");
    //按照索引刪除集合中元素物件,0<=索引的範圍<集合.size()
    alist.remove(1);
    //按照元素物件刪除
    //alist.remove((Object)22);
    //刪除最後一個元素物件
    //alist.removeLast();
    
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
    
    System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
    //清空集合
    alist.clear();
    //遍歷集合
    for (Object ob : alist) {
        System.out.println(ob);
    }
}

7.跌代器(Iterator):遍歷訪問collection集合中每個元素

集合名.iterator();獲得當前集合跌代器物件
跌代器物件.hasNext();判斷跌代器物件後面是否有元素可跌代
跌代器物件.next();跌代元素(訪問當前元素),
注意:集合中每個元素只能呼叫一次next()

public static void main(String[] args) {
    //建立集合物件
    List alist2=new ArrayList();
    //向集合中新增元素物件
    //建立一個學生物件
    Student stu1=new Student("aa", 11);
    alist2.add(stu1);
    
    alist2.add(new Student("bb", 41));
    alist2.add(new Student("cc", 31));
    alist2.add(new Student("dd", 21));
    
    //獲得集合的跌代器
    Iterator it2=alist2.iterator();
    //判斷跌代器後面是否有元素可跌代
    while (it2.hasNext()) {
        //獲得當前的跌代元素
        Student s=(Student) it2.next();
        System.out.println(s.sname+","+s.sage);
    }
}

8.Collections:collection集合家族工具類

9.泛型:將引用資料型別引數化.(將引用資料型別作為引數來傳遞).語法:<資料型別>

9.1:泛型集合:將資料型別作為集合的引數，集合中每個元素必須都是這個泛型的資料型別。

1:為什麼要用泛型集合:因為普通集合,存資料時要頻繁的裝箱(什麼型別的資料存到集合中都要封裝成Object型別),取出資料時要頻繁的拆箱(將元素轉換原來的型別),使用不方法.所以想到用泛型集合可以減少頻繁的裝箱和拆箱。
2:泛型集合:一個集合中只能存同一種資料型別。
3:語法: 集合型別<資料型別> 集合名=new 集合型別<資料型別>;

public static void main(String[] args) {
    //建立集合物件
    List<Student> alist3=new ArrayList();
    //向集合中新增元素
    alist3.add(new Student("aa", 11));
    alist3.add(new Student("bb", 31));
    alist3.add(new Student("cc", 21));
    
    //獲得集合的跌代器物件
    Iterator<Student> it1=alist3.iterator();
    //判斷跌代器
    while (it1.hasNext()) {
        Student s=it1.next();
        System.out.println(s.sname+","+s.sage);
    }
}

9.2:泛型跌代器:將資料型別作為迭代器的引數，迭代出來的每個元素是泛型的資料型別

1：泛型迭代器的作用：減少頻繁的型別轉換的問題。
2:語法:Iterator<資料型別> 跌代器物件名=集合名.iterator();
3:泛型跌代器與泛型集合是黃金搭擋,集合用什麼資料型別作為泛型,泛型跌代器就用相同的資料型別作為泛型的資料型別。

public static void main(String[] args) {
    //建立集合物件
    List<Student> alist3=new ArrayList();
    //向集合中新增元素
    alist3.add(new Student("aa", 11));
    alist3.add(new Student("bb", 31));
    alist3.add(new Student("cc", 21));
    
    //獲得集合的跌代器物件
    Iterator<Student> it1=alist3.iterator();
    //判斷跌代器
    while (it1.hasNext()) {
        Student s=it1.next();
        System.out.println(s.sname+","+s.sage);
    }
}

9.3:泛型類:將引用資料型別作為類的引數,傳到類中

/**
 * 泛型類,<T>代表任意資料型別的泛型
 */
public class Teacher<T>{
	public String sname;
	public Integer sage;
	//用泛型作為變數資料型別
	public T num;
}

public static void main(String[] args) {
    //建立老師物件
    Teacher<String> teacher1=new Teacher<>();
    //用物件呼叫屬性
    teacher1.sname="張三";
    teacher1.num="你好";
    
    //建立老師物件
    Teacher<Integer> teacher2=new Teacher<>();
    //用物件呼叫屬性
    teacher2.sname="ls";
    teacher2.num=11;
}

9.4:泛型方法:將資料型別作為引數傳到方法中用

/**
 * 普通類
 */
public class Fun {
	/**
	 * 泛型方法
	 * @param count
	 */
	public <T> void show(T count) {
		System.out.println("方法引數為:"+count);
	}
}	

public static void main(String[] args) {
    //建立物件
    Fun f1=new Fun();
    //用物件呼叫泛型方法
    f1.show("張三");
    f1.show(11);
    f1.show(true);
}

9.5:泛型屬性不能與static或final一起使用

泛型類,泛型方法可以與static,final,abstract一起使用

9.6:受限泛型:

(1)<?>：表示任意型別
(2)<? extends T>：表示T類或者T類的子類
(3)<? super T>：表示T類或者T類的父類

10.ArrayList VS Vector

1:推出時間不同:Vector在jdk1.0時就推出;ArrayList在jdk1.2時推出的
2:記憶體使用效率不同:Vector每次擴容按原來2倍擴容;ArrayList每次擴容按原來1.5倍擴容
3:執行緒安全性和效率不同:Vector是執行緒安全的類,但是效率低；ArrayList是執行緒不安全的類,但是效率高
4:ArrayList所擁有的所有方法Vector都有,Vector還有自己獨有的方法(獨有的方法比較複雜)

11.Stack繼承自Vector類,是按壓棧的方法存值,取值是按後進先出的方式取值