Java當中的集合框架

01

在我們班裏有50位同學，就有50位對象。

// 簡書作者：達叔小生
Student[] stus = new Student[20];

結果來了一位插班生，該同學因為覺得學IT行業好，才要求老師轉專業的。可以結果沒有多余的空位了，數組裏的長度都是安排好的，沒有空間了。

為了解決新同學的問題，老師們重新創建一個空間（重復創建一個新的數組），為了能夠更好的解決問題，老師提供了可以不斷擴大空間（Java提供了集合，當數據多了，個數不穩定時，可以用集合）。

在Java中，數組的長度是不可以改變的，在數組中存儲的是同種類型的元素，可以存儲基本數據類型值；但是集合的長度是可以改變的，存儲的是對象，對象的類型可以不一樣，集合是存儲對象的，當數據多，即對象多的時候，可以用集合來存儲。

雖然數組和集合類都是容器
為什麽用集合來解決問題，數組難道就不可以嗎？

數組也可以存儲對象的，但是因為長度的固定，限制了數組，而集合的長度是可以改變的，在數組中可以用來存儲基本數據類型，而在集合中只能用來存儲對象，但是可以存的對象可以是不同類型的對象哦~

數組可以存放基本數據類型和對象
集合只能存放對象

在Java語言這種面向對象語言中，對一切事物的體現都可以用對象的形式來表現，為了對對象進行方便的操作，Java就提供了集合這個名詞，用來存儲對象一種方式。

02

類集合框架主體

集合框架的構成及分類

// 簡書作者：達叔小生
java.util
類 Vector<E>
java.lang.Object
 -> java.util.AbstractCollection<E>
  -> java.util.AbstractList<E>
   -> java.util.Vector<E>
 

// 簡書作者：達叔小生
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess,Cloneable,Serializable

類集框架，那麽什麽是類集框架，集合的種類有哪些，類集框架的基礎結構。

類集框架是一組類和接口的集合，位於java.util包當中，是用來用戶存儲和管理對象的，在這個類集合框架中，我們主要學習的為三大類，分別是集合，列表和映射。

集合，列表，映射

類集合框架是jdk提供的一類類和接口，主要掌握集合，列表，映射，集合是無序的，集合中的元素不允許是重復的，列表是有序的，列表中的元素是允許重復的，映射是以鍵值對的方式來存儲數據，鍵是不可重復的，值是可以重復的。

其實在jdk最早的時候jdk1.0版的時候，提供的集合是很少的，但是隨著發展，到jdk1.2的時候就變多了，為了營造更多的需求，就有了集合框架。

所以的根接口為Collection.

// 簡書作者：達叔小生
// 集合框架體系
Iterator
 ->Collection
 -> Map

// 簡書作者：達叔小生
Collection
 -> Set 無序不重復 -> 無序HashSet，需要排序TreeSet
 -> List 有序可重復 -> 查，改ArrayList，增刪LinkedList

Map
 -> 無序 HashMap
 -> 排序 TreeMap

03

頂級Iterator和Collection

Collection的相關方法，可以去官方下載文檔來看哦：

Collection接口：它定義了集合體系中最共性的功能

// 簡書作者：達叔小生
java.util
接口 Collection<E>
所有超級接口：
Iterable<E>

// 簡書作者：達叔小生
public interface Collection<E>
extends Iterable<E>

Collection接口為層次結構中的根接口，由上方提供的圖片得知，Collection表示為一組對象，這些對象稱為Collection的元素，在這個類集合框架中，我們主要學習的為三大類，分別是集合，列表和映射。

註意一些collection允許有重復的元素，有的不允許，有的是有序的，有的是無序的。

這些都跟三大類有關。

在java中，jdk不提供Collection接口的實現，都是由它的子接口進行實現的。

Collection是List和Set的父類

List和Set也都是由再次向下，由它們的子類接口實現的。

// 簡書作者：達叔小生
Set 和 HashSet 為Set的實現類 使用
Iterator -> Collection -> Set -> HashSet
Iterator -> Collection -> List -> ArrayList

來解釋：一些collection允許有重復的元素，有的不允許，有的是有序的，有的是無序的。是因為數據結構的不同。為 -> 三大類集合，列表，映射

出現了集合框架，有了很多種容器可以完成很多需求，我們區分容器是靠著每個容器的數據結構不同，去命名了解的。

04

三大類集合，列表，映射

Set為集合，在集合中的對象是不按照順序排列的，並且是沒有重復的對象的。
簡單為：無序，無重復。

List為列表，中在列表中的對象是由順序的排序的，並且是有重復的對象。
簡單為：有序，有重復。

Map為映射，在集合中的每個元素都有一個鍵對象和一個值對象，在Map中鍵是不可以重復的，值是可以重復的。
鍵不可重復，值可以重復；

Set為無序集合，無序無重復；
List為有序集合，有序有重復；
Map為映射，存儲鍵值對，鍵不可重復，值可以重復；

05

Collection是所有集合類的根接口，有人問那麽這個呢？
Collections，其實這個是集合操作的工具類。

// 簡書作者：達叔小生
Collection
 -> Set
  -> HashSet
  -> LinkedHashSet
  -> TreeSet

 -> List
  -> ArrayList
  -> Vector
  -> LinkedList

 -> Queue
  -> LinkedList
  -> PriorityQueue

 -> Map
  -> Hashtable
  -> HashMap
  -> TreeMap
  -> LinkedHashMap

// 簡書作者：達叔小生
import java.util.List;
import java.util.ArrayList;

public class Demo{
 public static void main(String args[]){
 // 創建列表的實現類對象
  ArrayList<String> arrayList = new ArrayList<String>();
 // 添加數據
 arrayList.add("a");
 arrayList.add("b");
 arrayList.add("c");
// 移除
 arrayList.remove(1);
 // 獲取數據
 String s = arrayList.get(1);
 System.out.println(s);
 // 獲取長度
 int a = arrayList.size();
 // 打印所有元素
 for(int i=0; i<arrayList.size(); i++){
  String s = arrayList.get(i);
  System.out.println(s);
 }
 }
}

Set 和 HashSet 為Set的實現類 使用

// 簡書作者：達叔小生
import java.util.Set;
import java.util.HashSet;
public class Demo{
 public static void main(String args[]){
  HashSet<String> hashSet = new HashSet<String>();
 Set<String> set = hashSet;
 // 實現類向上轉型為接口
 // 同理 Set<String> set = new HashSet<String>();
 // 添加元素
 set.add("a"); 
 set.add("b");
 set.add("c");
 set.add("d");
 // 獲取集合中的元素長度
 int a = set.size();
 }
}

Iterator 接口 叠代器對象

叠代是Java中的用來表示取元素的名稱而已，Iterator 接口 叠代器對象用來取元素，無論是什麽數據結構，最終共性的取出方式，取值是一個一個取的，在之前先要判斷是否有值，如果有就取一個，如果沒有就over，不取。

// 簡書作者：達叔小生
Iterator - > Collection -> Set - > HashSet
hasNext() next()
it.hasNext() 是否還有元素
it.next() 取出元素

Iterator -> Collection -> List -> ArrayList

Set 和 HashSet 為Set的實現類 使用

// 簡書作者：達叔小生
hasNext() 判斷是否還有下一個元素
next() 取出這個元素，然後把遊標移動到下一位

Iterator -> Collection -> Set -> HashSet

// 簡書作者：達叔小生
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Demo{
 public static void main(String args[]){
  HashSet<String> hashSet = new HashSet<String>();
 Set<String> set = hashSet;
 // 實現類向上轉型為接口
 // 同理 Set<String> set = new HashSet<String>();
 // 添加元素
 set.add("a"); 
 set.add("b");
 set.add("c");
 set.add("d");
 // 叠代器 iterator() 遍歷整個set
// 通過叠代器取出集合中的對象
 Iterator<String> it = set.iterator<String>();
 while(it.hasNext){
  String s = it.next();
  System.out.println(s);
 }
 }
}

Iterator叠代器 iterator()

// 簡書作者：達叔小生
Iterator<E> iterator()
// 返回在此collection的元素上的叠代效果。

接口Iterable<E>中的iterator
在此collection的元素上進行叠代
iterator()可以獲取具體容器中的叠代器對象
叠代器返回的是Iterator接口

叠代器的方法

java.util.NoSuchElementException 沒有這個元素異常
it.next()

// 簡書作者：達叔小生
public class IteratorDemo{
 public static void mian(String[] args){
  // 創建集合對象
  Collection collection  = new ArrayList();
 // 存儲的是對象的引用
 // 集合存儲不了基本數據類型
 // collection.add(12); == 內部效果 collection.add(Integer.valueOf(12); // 自動裝箱
 // 即在jdk1.5後，存儲的是基本數據類型包裝類的對象
  collection.add("ab");
  collection.add("bbb");
  collection.add("cbbb");
  collection.add("dbbbb");
  // 獲取叠代器 iterator()方法
  Iterator it = collection.iterator();
  while(it.hasNext(){
   System.out.println(it.next());
  }
  // 
   //可以轉變為
   // for(Iterator it = collection.iterator(); it.hasNext(); ) {}
  //
  // 每個存儲對象的長度
  for(Iterator it = collection.iterator(); it.hasNext(); ){
   // 取出對象
   Object object = it.next();
   // 向下轉型，才能使用元素的特殊方法
   String str = (String)object;
   // 打印對象長度
   System.out.println(str.length());
  } 
 }
}

// 簡書作者：達叔小生
// 可以使用這個，節省內存
for(java.util.Iterator iterator = collection.iterator(){
 Object object = (Object) iterator.next();
}

06

// 簡書作者：達叔小生
// 創建一個Student類
public class Student{
 // 定義私有的String變量 name
 private String name;
 // 定義私有的int變量 age
 private int age;
 // 創建構造函數
 public Student(){
  super();
 }
 public Student(String name, int age){
  super();
  this.name = name;
  this.age = age;
 }
 // 創建toString()方法
 @Override
 public String toString(){
  return "Student [name=" + name + ", age=" + age + "]";
 }
 // 創建getXxx()，setXXX()方法
 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;
 }
 // equals();
 @Override
 public boolean equals(Object obj){
  if(this == obj){
   return; 
  }
  if(! (obj instanceof Student) ){
   throw new ClassCastException("類型錯誤");
  }
   Student stu = (Student)obj;
   return this.name.equals(stu.name) && this.age == stu.age;
 }
}

equals()方法

// 簡書作者：達叔小生
public class CollectionDemo {
 public static void main(String[] args){
  // 創建集合對象
 Collection collection = new ArrayList();
 // 添加元素 添加一個地址兩次為重復
 Student stu = new Student( "a",12 );
 collection.add( stu );
 collection.add( new Student("b",13) );
 collection.add( new Student("c",14) );
 collection.add( new Student("d",15) );
 for(Iterator it = collection.iterator(); it.hasNext(); ){
  Student student = (Student) it.next();
  System.out.println(student.getName());
 }
 }
}

Map 與 HashMap(Map的實現類) 的使用

Map 為映射，映射中的每個元素都有一個鍵對象和一個值對象，在Map中鍵是不可以重復的，值是可以重復的。從jdk1.2有了這個類。

// 簡書作者：達叔小生
java.util
Interface Map<K,V>
K - the type of keys maintained by this map
V - the type of mapped values

Map是一種對象，將keys鍵和values值建立起一種映射關系，一個map不能有重復的keys，每個key只能唯一映射到一個值。

// 簡書作者：達叔小生
import java.util.Map;
import java.util.HahMap;
public class Demo{
 public static void main(String args[]){
  HashMap<String,String> hasMap = new  HashMap<String,String>();
  Map<String,String> map = hasMap;
 // 向上轉型
 // 同理 Map<Stirng,String> map = new HashMap<String,String>();
 // put() 用來存放鍵值對
 map.put("1","a");
 map.put("2","b");
 map.put("3","c");
// 獲取長度
 int i = map.size();
// 獲取鍵為2的值
 String s = map.get("2");
 }
}

在Map中鍵是不可以重復的，值是可以重復的。如果map中添加一樣的鍵，那麽新的值會覆蓋老的值。

Collection

// 簡書作者：達叔小生
public interface List<E>
extends Collection<E>

// 簡書作者：達叔小生
java.util
接口 List<E>
所有超級接口：Collection<E>，Iterable<E>
所有已知實現類：AbstractList，AbstractSequentialList，ArrayList，AttributeList，CopyOnWriteArrayList，LinkedList，RoleList，Vector，Stack。
可以用 ArrayList

public interface List<E> extends Collection<E>

// 簡書作者：達叔小生
public class ListDemo{
 public static void main(String[] args){
  // List
  List list = new ArrayList();
 // 添加元素
 list.add( new Student("a",12) );
 list.add( new Student("b",13) );
 list.add( new Student("c",14) );
 // 插入元素
 // list.add( 1, new Student("d",15) );
 // list.remove(44); 
 // 角標越界IndexOutOfBoundsException)
 // list.set( 2, new Student("dashucoding", 16) );
 // 循環出對象
 for(Iterator it = List.iterator(); it.hasNext(); ){
  Student stu = (Student) it.next();
  System.out.println(stu);
 }
 // 獲取對象
 Object obj = list.get(1);
 System.out.println(obj);
 // 獲取對象
 for(int i = 0; i<list.size(); i++){
  System.out.println(list.get(i));
 }
}

往後余生，唯獨有你
簡書作者：達叔小生
90後帥氣小夥，良好的開發習慣；獨立思考的能力；主動並且善於溝通
簡書博客： https://www.jianshu.com/u/c785ece603d1

結語

• 下面我將繼續對 其他知識 深入講解 ，有興趣可以繼續關註
• 小禮物走一走 or 點贊

第48節：Java當中的集合框架