Java中的Collection集合以及Collection集合實現類例項
文章目錄
最重要的是迭代器
一 、Collection：
集合的頂層介面，不能被例項化
a) 根介面Collection
i. 常用子介面
1. List
實現類：ArrayList、Vector、LinkedList
2. Set
實現類：HashSet、TreeSet
b) 新增功能
i. boolean add(object obj)新增一個元素
ii. boolean addAll(Collection c)將集合c的全部元素新增到原集合元素後返回true
iii. 新增功能永遠返回true
c) 刪除功能
i. void clear();移除所有元素
ii. boolean remove(Object o)移除一個元素
iii. boolean removeAll（Collection c）移除一個集合的元素，只要有一個被移除就返回true，改變原集合，刪除原集合中和c中相同的元素
iv. 刪除功能只有刪除成功後才返回true
d) 判斷功能
i. boolean contain(object o)判斷集合中是否包含指定的元素。
ii. boolean containsAll(Collection c)判斷原集合中是否包含指定集合c的所有元素，有則true，
iii. boolean isEmpty()判斷集合是否為空
e) 獲取功能
i. Iterator iterator()迭代器，集合的專用方式，實現遍歷的功能
ii. Object next()獲取當前元素，並移動到下一個位置
iii. boolean hasNext()判斷此位置是否有元素
iv. 迭代器遍歷例項在下面
f) 長度功能
i. int size()元素的個數
ii. 陣列和字串中都是length()方法獲取元素個數，集合中是size()方法
因為object包括集合、字串、陣列，所以其不能直接用length方法。
g) 交集功能boolean retainAll(Collection c)
兩個集合交集的元素給原集合，並判斷原集合是否改變，改變則true，不變則false
h) 把集合轉換為陣列
i. Object [] toArray()
1、List集合
Collection集合的子類
特點：
a) 有序（儲存和取出的元素順序一致），可重複
b) 特有功能
i. 新增功能
void add(int index,Object element)在指定位置新增元素（原索引處的元素後延）
ii. 獲取功能
Object get(int index)獲取指定位置的元素
iii. 列表迭代器
1. ListIterator listIterator() List集合特有的迭代器
2. Iterator迭代器的子類，所以其可以用Iterator中的boolean hasNext()、Object next()方法
3. 特有的方法：
a) Object previous ()返回此處位置的前一個的元素，並移動到前一個位置。
b) boolean hasPrevious()判斷此處的前一個位置是否有元素
c) 逆向遍歷必須先正向遍歷使指標指到後面位置才能使用（使用意義不大）
4. 迭代器遍歷元素時不能直接通過集合修改元素，怎麼辦？
a) 迭代器修改元素
i. List迭代器有修改方法，Collection中的迭代器沒有
ii. 通過迭代器中add(object obj)方法新增，跟在剛才迭代元素後面
b) 通過集合遍歷元素，並用集合修改元素（for迴圈遍歷）
i. 通過集合中add(object obj)方法新增，跟在集合最後面
5. 迭代器遍歷例項例項在下面給出
iv. 刪除功能
Object remove(int index)根據索引刪除指定的元素，並返回刪除的元素
v. 修改功能、
Object set(int index,Object element)根據索引修改元素，返回被修改的元素
vi. 陣列轉成集合
1. public static List asList(T… a)，返回型別為List型別
2. a為集合，此處的… 代表可變引數，也就是a的陣列元素個數可變
3. 此方法是Arrays類中的靜態方法
4. 陣列轉變為集合，實質還是陣列需要保證長度不變，所以不支援增刪集合元素，可以修改元素
c) List子類的特點：
i. ArrayList:
1. 底層資料結構是陣列，查詢快、增刪慢
2. 執行緒不安全，效率高
ii. Vector：
1. 底層資料結構是陣列，查詢快，增刪慢
2. 執行緒安全，效率底
iii. LinkedList：
1. 底層資料結構是連結串列，查詢慢，增刪快
2. 執行緒不安全，效率高
1.1、 Vector集合特有的特點
a) 新增功能
i. public void addElement(Object obj)
b) 獲取功能
i. public Object elementAt(int index)
ii. public Enumeration elements ()
1. 也是用來遍歷集合
2. boolean hasMoreElements()
3. Object nextElement()
4. 基本不用這個，都是直接用上面的迭代器實現遍歷
1.2、LinkedList集合的特有功能
a) 新增功能
i. public void addFirst(Object e)
ii. public void addLast(Object e)
b) 獲取功能
i. public Object getFirst()
ii. public Object getLast()
c) 刪除功能
i. public Object removeFirst()
ii. public Object removeLast()
2、 Set集合
a) 無序（儲存和取出順序不一致，有可能會一致），但是元素唯一，不能重複
b) b) 實現類
i. HashSet
1. 底層資料是雜湊表
2. 通過兩個方法hashCode()和equals()保證元素的唯一性，方法自動生成
3. 子類LinkedHashSet底層資料結構是連結串列和雜湊表，由連結串列保證元素有序，
由雜湊表保證元素唯一。
ii. TreeSet
1. 底層資料是紅黑二叉樹
2. 排序方式：自然排序、比較器排序
3. 通過比較返回值是否為0來保證元素的唯一性。
2.1、 HashSet類：
a) 不保證set的迭代順序，
b) 當儲存物件時需要重寫equals（）和hashCode（）方法（可以用Eclipse自動生成此方法）
2.1.1、 LinkedHashSet類
a) HashSet的子類
b) 可預知的迭代順序，底層資料結構由雜湊表和連結串列組成
i. 雜湊表：保證元素的唯一性
ii. 連結串列：保證元素有序（儲存和取出順序一致）
2.2、 TreeSet類
a) 能夠保證元素唯一性（根據返回值是否是0來決定的），並且按照某種規則排序
i. 自然排序，無參構造方法（元素具備比較性）
按照compareTo()方法排序，讓需要比較的元素所屬的類實現自然排序介面Comparable，
並重寫compareTo()方法
ii. 1. 讓集合的構造方法接收一個比較器介面的子類物件（compareator）
（此處的Comparator為介面，需要寫一個介面實現類，在實現類中重寫compare()方法，
並在這裡建立介面實現類的物件，可以用匿名內部類來建立實現類物件）
b) 底層是自平衡二叉樹結構
i. 二叉樹有前序遍歷、後序遍歷、中序遍歷
ii. TreeSet類是按照從根節點開始，按照從左、中、右的原則依此取出元素
c) 當使用無參構造方法，也就是自然排序，需要根據要求重寫compareTo()方法，這個不能自動生成
3、 針對Collection集合我們應該怎麼使用
a) 是否元素唯一
i. 是：Set
1. 是否排序
a) 是：TreeSet
b) 否：HashSet
如果不知道用哪個Set就用HashSet
ii. 否：List
1. 是否對安全性有要求
a) 是：Vector
b) 否：
查詢多：ArrayList
增刪多：LinkedList
如果不知道用哪個List用ArrayList
如果知道是用集合但不知道用哪個用ArrayList
二 、Collection集合和List集合迭代器遍歷例項
package test10_collecton;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//Collection集合中的方法，子集合都可以用
// Iterator<E> iterator()迭代器，集合的專用方式子集合都可以用
// Object next()獲取當前元素，並移動到下一個位置
// boolean hasNext()判斷此位置是否有元素
//List集合中的方法
// void add(int index,Object element)在指定位置新增元素（原索引處的元素後延）
// Object get(int index)獲取指定位置的元素
//list迭代器中的特有方法
// Object previous ()返回此處位置的前一個的元素，並移動到前一個位置。
// boolean hasPrevious()判斷此處的前一個位置是否有元素
public class InteratoeDemo {
public static void main(String[] args) {
//Collection集合的遍歷
Collection c=new ArrayList();
c.add("zfliu");
c.add("18");
c.add("java");
Iterator i=c.iterator();
while(i.hasNext()) {
//向下轉型
String s=(String) i.next();
System.out.println(s);
}
System.out.println("-----------------");
//List集合的遍歷
List l=new ArrayList();
l.add(0,"zfliu");
l.add(1,"18");
l.add(1,"java");
ListIterator li=l.listIterator();
//後向遍歷
while(li.hasNext()) {
String s=(String)li.next();
System.out.println(s);
}
System.out.println("-----------------");
//前向遍歷
while(li.hasPrevious()) {
String s=(String)li.previous();
System.out.println(s);
}
System.out.println("-----------------");
//get方法遍歷
for(int x=0;x<l.size();x++) {
String s=(String)l.get(x);
System.out.println(s);
}
}
}
輸出結果
三、使用使用HashSet類隨機產生10個不重複的1到20的不重複隨機數例項
package test_11_hashset;
import java.util.HashSet;
import java.util.Random;
//使用HashSet類隨機產生10個不重複的1到20的不重複隨機數
public class HashSetDemo {
public static void main(String[] args) {
Random r=new Random();
HashSet <Integer> hs=new HashSet<Integer>();
while(hs.size()<10) {
hs.add((r.nextInt(20)+1));
}
for(Integer i:hs) {
System.out.println(i);
}
}
}
四、TreeSet類中自然排序和比較器排序例項
Student類
package test11_Treeset;
//此處實現的為自然排序介面，如果僅僅使用比較器排序此介面可以不實現
public class Student implements Comparable<Student>{
private int age;
private String name;
public Student() {
super();
}
public Student(String name,int age) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int compareTo(Student s) {
//此處的this和s前後位置改變會影響排序方式
int num1=this.age-s.age;
int num2=num1==0?this.name.compareTo(s.name):num1;
return num2;
}
}
1、自然排序
package test11_Treeset;
import java.util.TreeSet;
//TreeSet類儲存物件，自然排序
//規定:按照年齡進行排序
public class TreeSetDemo1 {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<Student>();
Student s1=new Student("zfliu",18);
Student s2=new Student("zfliu",20);
Student s3=new Student("zfliu",18);
Student s4=new Student("ZFLIU",18);
Student s5=new Student("Java",18);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
for (Student s:ts) {
System.out.println(s.getName()+s.getAge());
}
}
}
2、比較器排序
package test11_Treeset;
import java.util.Comparator;
import java.util.TreeSet;
//TreeSet類儲存物件，比較器排序
//規定:按照年齡進行排序
public class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>() {
//匿名內部類實現比較器排序介面
public int compare(Student s1, Student s2) {
int num1=s1.getAge()-s2.getAge();
int num2=num1==0? s1.getName().compareTo(s2.getName()):num1;
return num2;
}
});
Student s1=new Student("zfliu",18);
Student s2=new Student("zfliu",20);
Student s3=new Student("zfliu",18);
Student s4=new Student("ZFLIU",18);
Student s5=new Student("Java",18);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
for (Student s:ts) {
System.out.println(s.getName()+s.getAge());
}
}
}