二、Collection集合

集合：集合是java中提供的一種容器，可以用來存儲多個數(shù)據(jù)。
集合和數(shù)組既然都是容器，它們有啥區(qū)別呢？

• 數(shù)組的長度是固定的。
• 集合的長度是可變的。
• 數(shù)組中存儲的是同一類型的元素，可以存儲基本數(shù)據(jù)類型值。
• 集合存儲的都是對象。而且對象的類型可以不一致。
  在開發(fā)中一般當(dāng)對象多的時候，使用集合進(jìn)行存儲。
  集合按照其存儲結(jié)構(gòu)可以分為兩大類，分別是單列集合 java.util.Collection 和雙列集合 java.util.Map ，我們從 Collection 集合開始
  Collection：單列集合類的根接口，用于存儲一系列符合某種規(guī)則的元素，它有兩個重要的子接口，分別是 java.util.List 和 java.util.Set 。
• List 的特點是元素有序、元素可重復(fù)。
• Set 的特點是元素?zé)o 序，而且不可重復(fù)。
• List 接口的主要實現(xiàn)類有 java.util.ArrayList 和 java.util.LinkedList 。
• Set 接口 的主要實現(xiàn)類有 java.util.HashSet 和 java.util.TreeSet 。

Collection 常用功能

Collection是所有單列集合的父接口，因此在Collection中定義了單列集合(List和Set)通用的一些方法，這些方法可 用于操作所有的單列集合。方法如下：

- public boolean add(E e) ： 把給定的對象添加到當(dāng)前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e) : 把給定的對象在當(dāng)前集合中刪除。
- public boolean contains(E e) : 判斷當(dāng)前集合中是否包含給定的對象。
- public boolean isEmpty() : 判斷當(dāng)前集合是否為空。
- public int size() : 返回集合中元素的個數(shù)。
- public Object[] toArray() : 把集合中的元素，存儲到數(shù)組中。

示例:

public class Demo1Collection {
 public static void main(String[] args) {
  // 創(chuàng)建集合對象 
// 使用多態(tài)形式
 Collection<String> coll = new ArrayList<String>();
 // 使用方法
 // 添加功能boolean add(String s) 
coll.add("小李廣");
coll.add("掃地僧");
 coll.add("石破天");
 System.out.println(coll);
 // boolean contains(E e) 判斷o是否在集合中存在
 System.out.println("判斷 掃地僧 是否在集合中"+coll.contains("掃地僧"));
 //boolean remove(E e) 刪除在集合中的o元素
 System.out.println("刪除石破天："+coll.remove("石破天"));
 System.out.println("操作之后集合中元素:"+coll); 
// size() 集合中有幾個元素
 System.out.println("集合中有"+coll.size()+"個元素");
 // Object[] toArray()轉(zhuǎn)換成一個Object數(shù)組
 Object[] objects = coll.toArray();
 // 遍歷數(shù)組
 for (int i = 0; i < objects.length; i++) { 
System.out.println(objects[i]);
 }
// void clear() 清空集合 
coll.clear();
 System.out.println("集合中內(nèi)容為："+coll);
 // boolean isEmpty() 判斷是否為空 System.out.println(coll.isEmpty());
 }
}

泛型

在前面學(xué)習(xí)集合時，我們都知道集合中是可以存放任意對象的，，只要把對象存儲集合后，那么這時他們都會被提升成Object類型。當(dāng)我們在取出每一個對象，并且進(jìn)行相應(yīng)的操作，這時必須采用類型轉(zhuǎn)換。
提示:一般在創(chuàng)建對象時，將未知的類型確定具體的類型。當(dāng)沒有指定泛型時，默認(rèn)類型為Object類型。

泛型的定義與使用

泛型，用來靈活地將數(shù)據(jù)類型應(yīng)用到不同的類、方法、接口當(dāng)中。將數(shù)據(jù)類型作為參數(shù)進(jìn)行傳遞。
定義和使用含有泛型的類
定義格式：

修飾符 class 類名<代表泛型的變量> { }

示例:

class ArrayList<E>{
 public boolean add(E e){ 
}
 public E get(int index){
 } 
....
}

使用泛型： 即什么時候確定泛型。
在創(chuàng)建對象的時候確定泛型
例如:

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

此時，變量E的值就是String類型,那么我們的類型就可以理解為：

class ArrayList<String>{
 public boolean add(String e){ 
  } 
public String get(int index){
 }
 ...
 }

再例如:

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

此時，變量E的值就是Integer類型,那么我們的類型就可以理解為：

class ArrayList<Integer> {
 public boolean add(Integer e) {
 }
 public Integer get(int index) {
 }
 ...
 }

舉例自定義泛型類

public class MyGenericClass<MVP> {
 //沒有MVP類型，在這里代表 未知的一種數(shù)據(jù)類型 未來傳遞什么就是什么類型
 private MVP mvp;
 public void setMVP(MVP mvp) { 
    this.mvp = mvp;
 }
 public MVP getMVP() {
     return mvp;
 }
 }

使用:

public class GenericClassDemo {
 public static void main(String[] args) {
 // 創(chuàng)建一個泛型為String的類
 MyGenericClass<String> my = new MyGenericClass<String>(); // 調(diào)用setMVP
 my.setMVP("大胡子登登");
 // 調(diào)用getMVP
 String mvp = my.getMVP();
 System.out.println(mvp); 
//創(chuàng)建一個泛型為Integer的類
 MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
 my2.setMVP(123);
 Integer mvp2 = my2.getMVP();
 }
 }

含有泛型的方法

定義格式：

修飾符 <代表泛型的變量> 返回值類型 方法名(參數(shù)){ }

例如

public class MyGenericMethod {
 public <MVP> void show(MVP mvp) {
 System.out.println(mvp.getClass());
 }
public <MVP> MVP show2(MVP mvp) {
 return mvp;
 } 
}

使用格式：調(diào)用方法時，確定泛型的類型

public class GenericMethodDemo {
 public static void main(String[] args) {
 // 創(chuàng)建對象
 MyGenericMethod mm = new MyGenericMethod();
 // 演示看方法提示
 mm.show("aaa");
 mm.show(123);
 mm.show(12.45);
 }
 }

含有泛型的接口

定義格式：

修飾符 interface接口名<代表泛型的變量> { }

例如

public interface MyGenericInterface<E>{
 public abstract void add(E e);
 public abstract E getE();
 }

使用格式：
1.定義類時確定泛型的類型

public class MyImp1 implements MyGenericInterface<String> {
 @Override
 public void add(String e) {
 // 省略... 
}
@Override
 public String getE() {
 return null;
 } 
}

此時，泛型E的值就是String類型。
2.始終不確定泛型的類型，直到創(chuàng)建對象時，確定泛型的類型
例如:

public class MyImp2<E> implements MyGenericInterface<E> {
 @Override
 public void add(E e) {
 // 省略...
 }
@Override
 public E getE() {
 return null; 
} 
}

確定泛型：

/** 使用 */ 
public class GenericInterface {
 public static void main(String[] args) {
 MyImp2<String> my = new MyImp2<String>();
 my.add("aa"); 
  }
}

List集合

List接口特點：

1. 它是一個元素存取有序的集合。例如，存元素的順序是11、22、33。那么集合中，元素的存儲就是按照11、 22、33的順序完成的）。
2. 它是一個帶有索引的集合，通過索引就可以精確的操作集合中的元素（與數(shù)組的索引是一個道理）。
3. 集合中可以有重復(fù)的元素，通過元素的equals方法，來比較是否為重復(fù)的元素。 tips:我們在基礎(chǔ)班的時候已經(jīng)學(xué)習(xí)過List接口的子類
   java.util.ArrayList類，該類中的方法都是來自List中定義。

• public void add(int index, E element) : 將指定的元素，添加到該集合中的指定位置上。
• public E get(int index) :返回集合中指定位置的元素。
• public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element) :用指定元素替換集合中指定位置的元素,返回值的更新前的元素。

ArrayList集合:

java.util.ArrayList 集合數(shù)據(jù)存儲的結(jié)構(gòu)是數(shù)組結(jié)構(gòu)。
元素增刪慢，查找快，由于日常開發(fā)中使用最多的功能為 查詢數(shù)據(jù)、遍歷數(shù)據(jù)，所以 ArrayList 是最常用的集合。 許多程序員開發(fā)時非常隨意地使用ArrayList完成任何需求，并不嚴(yán)謹(jǐn)，這種用法是不提倡的。

LinkedList集合

java.util.LinkedList 集合數(shù)據(jù)存儲的結(jié)構(gòu)是鏈表結(jié)構(gòu)。方便元素添加、刪除的集合。

• public void addFirst(E e) :將指定元素插入此列表的開頭。
• public void addLast(E e) :將指定元素添加到此列表的結(jié)尾。
• public E getFirst() :返回此列表的第一個元素。
• public E getLast() :返回此列表的最后一個元素。
• public E removeFirst() :移除并返回此列表的第一個元素。
• public E removeLast() :移除并返回此列表的最后一個元素。
• public E pop() :從此列表所表示的堆棧處彈出一個元素。
• public void push(E e) :將元素推入此列表所表示的堆棧。
• public boolean isEmpty() ：如果列表不包含元素，則返回true。

public class LinkedListDemo {
 public static void main(String[] args) {
 LinkedList<String> link = new LinkedList<String>(); 
//添加元素
 link.addFirst("abc1");
 link.addFirst("abc2");
 link.addFirst("abc3"); 
System.out.println(link);
 // 獲取元素
 System.out.println(link.getFirst()); 
System.out.println(link.getLast());
 // 刪除元素
 System.out.println(link.removeFirst()); 
System.out.println(link.removeLast());
 while (!link.isEmpty()) {
 //判斷集合是否為空
 System.out.println(link.pop());
 //彈出集合中的棧頂元素
 }
System.out.println(link);
  }
}
例子1:

Set接口

java.util.Set 接口和 java.util.List 接口一樣，同樣繼承自 Collection 接口，它與 Collection 接口中的方 法基本一致，并沒有對 Collection 接口進(jìn)行功能上的擴(kuò)充，只是比 Collection 接口更加嚴(yán)格了。與 List 接口不 同的是， Set 接口中元素?zé)o序，并且都會以某種規(guī)則保證存入的元素不出現(xiàn)重復(fù)。
1.HashSet集合介紹
java.util.HashSet 是 Set 接口的一個實現(xiàn)類，它所存儲的元素是不可重復(fù)的，并且元素都是無序的(即存取順序 不一致)。
HashSet 是根據(jù)對象的哈希值來確定元素在集合中的存儲位置，因此具有良好的存取和查找性能。保證元素唯一性 的方式依賴于： hashCode 與 equals 方法。

public class HashSetDemo {
 public static void main(String[] args) {
 //創(chuàng)建 Set集合
HashSet<String> set = new HashSet<String>(); //添加元素
 set.add(new String("cba"));
 set.add("abc");
 set.add("bac");
 set.add("cba");
 //遍歷
 for (String name : set) { 
 System.out.println(name);
 } 
} 
}
結(jié)果:
cba
 abc
 bac

根據(jù)結(jié)果我們發(fā)現(xiàn)字符串"cba"只存儲了一個，也就是說重復(fù)的元素set集合不存儲。

HashSet存儲自定義類型元素

給HashSet中存放自定義類型元素時，需要重寫對象中的hashCode和equals方法，建立自己的比較方式，才能保 證HashSet集合中的對象唯一
例子2:

public class Student {
 private String name;
 private int age;
 public Student() {
}
public Student(String name, int age) {
 this.name = name;
 this.age = age;
 }
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;
 }
@Override
 public boolean equals(Object o) {
 if (this == o) 
return true;
 if (o == null || getClass() != o.getClass())
 return false;
 Student student = (Student) o;
 return age == student.age && Objects.equals(name, student.name);
 }
@Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
 }

public class HashSetDemo2 {
 public static void main(String[] args) {
 //創(chuàng)建集合對象 該集合中存儲 Student類型對象
 HashSet<Student> stuSet = new HashSet<Student>();
 //存儲
 Student stu = new Student("于謙", 43);
 stuSet.add(stu);
 stuSet.add(new Student("郭德綱", 44));
 stuSet.add(new Student("于謙", 43));
 stuSet.add(new Student("郭麒麟", 23));
 stuSet.add(stu);
 for (Student stu2 : stuSet) {
System.out.println(stu2);
 } 
}
 }
執(zhí)行結(jié)果：
Student [name=郭德綱, age=44] 
Student [name=于謙, age=43] 
Student [name=郭麒麟, age=23]

LinkedHashSet

我們知道HashSet保證元素唯一，可是元素存放進(jìn)去是沒有順序的，那么我們要保證有序，怎么辦呢？ 在HashSet下面有一個子類 java.util.LinkedHashSet ，它是鏈表和哈希表組合的一個數(shù)據(jù)存儲結(jié)構(gòu)。

public class LinkedHashSetDemo {
 public static void main(String[] args) {
 Set<String> set = new LinkedHashSet<String>();
 set.add("bbb");
 set.add("aaa");
 set.add("abc");
 set.add("bbc");
 Iterator<String> it = set.iterator();
 while (it.hasNext()) {
 System.out.println(it.next());
 }
 }
 }
結(jié)果：
 bbb
 aaa
 abc
 bbc