Java基礎—集合框架（一）

集合框架（一）

一、概述

1.集合出現的原因

Java中，數據被封裝成對象；對象完成了對數據的存儲。而集合的出現，完成了對對象的存儲，方便對對象進行操作。

2.集合與數組的區別

1）數組雖然可以存儲對象，但是長度固定，不利於後期擴展；只能存儲同一類型對象；
2）集合的長度是可變的；並且能存儲不同類型對象

3.集合的特點

1）長度可變；
2）可以存儲不同類型的對象；
3）集合只用於存儲對象，不能存儲基本數據類型

二、Collection

1.定義

Collection是集合框架層次結構中的根接口。Collection提供了具體的自接口（如Set和List）實現。這個根接口用來傳遞collection，並提供共性方法，操作這些collection。

2.共性方法

1）添加操作

-boolean add(E e)：添加指定元素到集合中
-boolean addAll(Collection<？ extends E> c)：添加指定集合中的所有元素到當前集合中

2）判斷操作

-boolean contains(Object o)：判斷當前集合中是否包含指定元素
-booean isEmpty()：判斷當前集合是否爲空

3）刪除操作

-void clear()：清空當前集合
-boolean remove(Object o)：移除指定元素
-boolean removeAll(Collection<？> c)：指定一個集合，將該集合中的元素從當前集合中移除

4）獲取操作

-int size()：獲取當前集合長度
-booean retianAll(Collection<？> c)：取當前集合與指定集合的交集
-Iterator iterator()：迭代器，用於取出集合中元素

3.共性方法演示

演示Collection中的共性方法。

示例代碼：

package com.heisejiuhuche.Collection;

import java.util.ArrayList;

public class CollectionDemo {
    public static void main(String[] args) {
        method1();
        method2();
    }

    private static void  method2() {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        ArrayList a2 = new ArrayList();
        a2.add("java03");
        a2.add("java04");
        a2.add("java05");
        a2.add("java06");
        //取交集
        al.retainAll(a2);
        print(al);
    }

    private static void method1() {
        ArrayList al = new ArrayList();
        //添加操作
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        //打印集合，結果爲[java01, java02, java03, java04]
        print(al);
        //刪除
        al.remove("java03");
        print(al);
        //是否包含指定對象
        print(al.contains("java-2"));
        //是否爲空
        print(al.isEmpty());
        //清楚所有對象
        al.clear();
        print(al);
        print(al.size());
    }

    private static void print(Object obj) {
        System.out.println(obj);
    }
}

注意：
-add()方法的參數類型是Object，以便於接受任意類型對象；
-集合中存放的不是對象實體，存儲的是對象內存地址

三、迭代器

1.定義

迭代器是對Iterator接口的實現，用於取出集合中的對象，以便於對對象進行操作。

容器的取出操作，不足以用一個方法描述。每個容器的取出操作過程，都有所不同。因此，容器將取出操作封裝成一個對象，對象中提供了多個功能以實現容器對象的取出操作。 每個容器類的內部，都定義了做取出操作的內部類（便於直接訪問容器內部的元素），用於取出各容器不同數據結構中的對象。這個取出操作被稱爲迭代器。無論是什麼容器，其迭代器的操作都會有判斷和取出的操作，將這些操作提取之後形成了Iterator接口。每個容器通過調用iterator()方法，獲得自身的迭代器。

2.迭代器的使用

iterator()方法返回的是一個Iterator接口的子類對象
1）獲取iterator迭代器：Iterator it = arraylist.iterator();
2）調用next()方法獲取第一個元素並打印：System.out.println(it.next());
3）調用hasNext()方法，循環取出所有元素

for(Iterator it = arraylist.iterator();it.hasNext();) {
    System.out.println(it.next());
}

四、List

1.List集合的特點

List集合中的元素是有序的，並可以重複。該集合體繫有索引。

2.List集合特有方法

凡是操作索引的方法都是該體系特有的方法。
1）添加操作

-void add(int index, E element)：添加指定元素
-boolean addAll(int index, Collection<？ extends E> c)：在指定位置插入指定collection中的元素

2）獲取操作

-get(int index)：返回集合中指定位置元素
-int indexOf(Object o)：獲取元素的索引，不存在返回-1
-int lastIndexOf(Object o)：反向索引
-ListIterator listIterator()：List集合特有迭代器
-List subList(int fromIndex, int toIndex)：返回子集合

3）刪除操作

-remove(int index)：按索引移除元素

4）修改操作

-set(int index, E element)：用指定元素替換指定位置的元素

3.特有方法演示

示例代碼：

package com.heisejiuhuche.Collection;

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

public class ListDemo {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();

        arr.add("java01");
        arr.add("java02");
        arr.add("java03");
        arr.add(1, "java04");

    ArrayList arr2 = new ArrayList();

        arr2.add("java05");
        arr2.add("java06");
        arr2.add("java07");

        arr.addAll(3, arr2);

        arr.remove(0);
        arr.set(1, "java10");
        System.out.println(arr.get(0));
        System.out.println(arr.indexOf("java07"));
        System.out.println(arr.lastIndexOf("java01"));

        for(Iterator it = arr.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }

        List list = arr.subList(1, 5);

        for(Iterator it = list.iterator(); it.hasNext();) {
            System.out.println("---" + it.next());
        }
    }
}

3.ListIterator列表迭代器

1）定義

List集合特有迭代器，ListIterator，是Iterator的子接口。迭代器和集合不能對同一組元素進行兩種不同的操作（取和增），會發生ConcurrentModificationException異常；因此，在迭代時，只能用迭代器的方法操作元素。但是Iterator的方法是有限的，只有判斷，取出和刪除操作。如果需要添加或者修改的操作，就需要使用ListIterator。該接口只能通過List集合的listIterator()方法獲取。

2）列表迭代器特有方法

-void add(E e)：添加指定元素
-set(E e)：修改指定元素
-boolean hasPrevious()：指針位之前有沒有元素

五、List子類對象

1.List子類對象組成

• List
  
  • ArrayList
  • LinkedList
  • Vector

List子類對象包括ArrayList，LinkedList和Vector。

2.List子類對象的特點

1）ArrayList
ArrayList底層數據結構使用的是數組結構；特點在於查詢速度塊，但是增加刪除操作速度較慢

2）LinkedList
LinkedList底層數據結構使用的是鏈表結構；特點在於增加刪除操作較快，查詢速度較慢

3）Vector
Vector底層數據結構使用的是數組結構；Vector是最早的容器，其特點在與，Vector是線程同步的

3.Vector中的枚舉

枚舉（Enumeration）是Vector的迭代器，是其特有的取出元素方式。枚舉和迭代是一樣的，選用迭代的原因是，枚舉的代碼過長。

示例代碼：

package com.heisejiuhuche.Collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        //創建Vector對象
        Vector v = new Vector();
        //添加元素
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        //使用枚舉遍歷元素
        for(Enumeration e = v.elements();e.hasMoreElements();) {
            System.out.println(e.nextElement());
        }
    }
}

程度輸出結果：

java01
java02
java03
java04

4.LinkedList

1）LinkedList中的特有方法

JDK6.0之前方法：

-void addFirst(E e)：將指定元素插入鏈表開頭
-void addLast(E e)：將指定元素插入鏈表結尾
-getFirst()：獲取第一個元素
-getLast()：獲取最後一個元素
-removeFirst()：移除第一個元素，並獲取該元素，如果元素不存在，拋出NoSuchElementException
-removeLast()：移除最後一個元素，並獲取該元素，如果元素不存在，拋出NoSuchElementException

JDK6.0之後新方法：

-E pollFirst():移除第一個元素，並獲取該元素，如果元素不存在，返回null
-E pollLast():移除最後一個元素，並獲取該元素，如果元素不存在，返回null
-offerFirst():將指定元素插入鏈表開頭
-offerLast():將指定元素插入鏈表結尾

2）LinkedList練習

使用LinkedList模擬堆棧或隊列數據結構
堆棧數據結構：先進後出；如同一個桶
隊列數據結構：先進先出（FIFO）如果水管

隊列數據結構示例代碼：

package com.heisejiuhuche.Collection;

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        MyList ml = new MyList();
        ml.myAdd("java01");
        ml.myAdd("java02");
        ml.myAdd("java03");
        ml.myAdd("java04");

        for(;!ml.myEmpty();) {
            System.out.println(ml.myGet());
        }
    }
}

class MyList {
    private LinkedList list;

    /*
     * 初始化MyList
     */
    MyList() {
        list = new LinkedList();
    }

    /*
     * 聲明MyList添加方法，添加到MyList頭部
     */
    public void myAdd(Object obj) {
        list.offerFirst(obj);
    }

    /*
     * 聲明MyList獲取方法，獲取MyList尾部元素
     */
    public Object myGet() {
        return list.pollLast();
    }

    /*
     * 聲明判斷MyList是否爲空的方法
     */
    public boolean myEmpty() {
        return list.isEmpty();
    }
}

程序輸出結果：

java01
java02
java03
java04

堆棧數據結構，只需修改如下代碼：

/*
 * 聲明MyList獲取方法，獲取MyList頭部元素
 */
public Object myGet() {
    return list.pollFirst();
}

程序運行結果：

java04
java03
java02
java01

5.ArrayList練習

1）練習1

去除ArrayList中的重複元素

示例代碼：

package com.heisejiuhuche.Collection;

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

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList arrList = new ArrayList();

        arrList.add("java01");
        arrList.add("java01");
        arrList.add("java02");
        arrList.add("java02");
        arrList.add("java03");
        arrList.add("java01");
        arrList.add("java03");
        arrList.add("java04");

        System.out.println("原列表： " + arrList);
        arrList = singleElement(arrList);
        System.out.println("新列表： " + arrList);
    }

    private static ArrayList singleElement(ArrayList list) {
        ArrayList arrList = new ArrayList();

        /* 遍歷ArrayList，如果新的容器中沒有舊容器中的元素，就將這個元素添加到新容器 */
        for(Iterator it = list.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if(!arrList.contains(obj)) {
                arrList.add(obj);
            }
        }
        /* 返回新容器 */
        return arrList;
    }
}

程序輸出結果：

原列表： [java01, java01, java02, java02, java03, java01, java03, java04]
新列表： [java01, java02, java03, java04]

2）練習2

將自定義元素添加到ArrayList集合中，並去除重複元素。例如，存人對象；同姓名同年齡，視爲重複元素。

示例代碼：

package com.heisejiuhuche.Collection;

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

public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();

        arrayList.add(new Person("lisi01", 30));
        arrayList.add(new Person("lisi02", 31));
        arrayList.add(new Person("lisi01", 30));
        arrayList.add(new Person("lisi03", 36));
        arrayList.add(new Person("lisi03", 36));
        arrayList.add(new Person("lisi02", 31));
        arrayList.add(new Person("lisi04", 31));

        arrayList = singleElement(arrayList);

        for(Iterator it = arrayList.iterator(); it.hasNext(); ) {
            /*
             * 將obj向下轉型成Person類型
             */
            Person p = (Person)it.next();
            System.out.println(p.getName() + "..." + p.getAge());
        }
    }

    private static ArrayList singleElement(ArrayList list) {
        ArrayList arrList = new ArrayList();

        for(Iterator it = list.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if(!arrList.contains(obj)) {
                arrList.add(obj);
            }
        }
        return arrList;
    }
}

/*
 * 聲明Person類，以加入ArrayList
 */
class Person {
    private String name;
    private int age;

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

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    /* 複寫Object類中的equals方法，判斷年齡和姓名相等，就是同一對象 */
    /* 列表的contains方法會調用equals()方法進行比較 */
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person)obj;
        return (this.name.equals(p.name)) && (this.age == p.age);
    }
}

程序輸出結果：

lisi01...30
lisi02...31
lisi03...36
lisi04...31

結論：
-List集合判斷元素是否相同，依據的是元素的equals()方法；
-List集合刪除元素的時候，依據的是原色的equals()方法判斷List中是否有該元素

六、HashSet

1.Set集合的特點

Set集合的元素是無序的，指的是存入和取出的順序不一定以致，並且元素不可以重複。

2.Set集合常見子類對象特點

• Set
  
  • HashSet
  • TreeSet

1）HashSet

HashSet底層數據結構是哈希表

2）TreeSet

TreeSet底層數據結構是二叉樹

3.HashSet使用

示例代碼：

package com.heisejiuhuche.Collection;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {
    public static void main(String[] args) {
        /*
         * 創建HashSet對象
         */
        HashSet hs = new HashSet();
        /*
         * 添加元素
         */
        hs.add("java01");
        hs.add("java02");
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");
        hs.add("java04");
        hs.add("java05");

        /*
         * 打印所有元素
         */
        for(Iterator it = hs.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
    }
}

程序運行結果：

java05
java04
java03
java02
java01

高能：
-HashSet集合在存儲對象的時候，爲保證元素的唯一性，是以對象的哈希值爲標準進行判斷；如果哈希值不同，則直接進行存儲；如果哈希值相同，HashSet集合則啓動第二套比較機制，用兩個對象equals()方法，對兩個對象的屬性進行比較，如果此時比較結果不同，則進行存儲，相同，則不存儲；
-開發時，如果要講對象存入HashSet，一定要複寫hashCode()和equals()方法，以確保對象唯一性

以存儲Person類爲例，要確保存儲的Person對象的唯一性，要複寫hashCode()和equals()方法；Person類代碼如下：

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    /*
     * 複寫hashCode()方法，以姓名和年齡爲依據，計算Person對象的哈希值，並確保唯一
     */
    public int hashCode() {
        return name.hashCode() + age * 37;
    }

    /* 複寫Object類中的equals方法，判斷年齡和姓名相等，就是同一對象 */
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person)obj;
        return (this.name.equals(p.name)) && (this.age == p.age);
    }
}

程序輸出結果：

lisi01....20
lisi03....21
lisi02....22

注意：
HashSet在進行判斷元素是否存在和刪除元素操作的時候，同樣依據的是hashCode()方法和equals()方法來保證元素的唯一性