第49節：Java集合框架中底層文件的List與Set

摘要： 標題圖 Java集合框架中的List與Set // 簡書作者：達叔小生 Collection -> Set 無序不重複 -> 無序HashSet，需要排序TreeSet -> List 有序可重複 -> 查，改Arra...

Java集合框架中的List與Set

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

List 為列表，中在列表中的物件是由順序的排序的，並且是有重複的物件。

簡單為：有序，有重複。

Set 為集合，在集合中的物件是不按照順序排列的，並且是沒有重複的物件的。

簡單為：無序，無重複。

Set 為無序集合，無序無重複；

List 為有序集合，有序有重複；

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

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

案例

// 簡書作者：達叔小生
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);
 }
 }
}

// 簡書作者：達叔小生
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));
 }
}

// 簡書作者：達叔小生
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();
 }
}

// 簡書作者：達叔小生
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);
 }
 }
}

// 簡書作者：達叔小生
public class ListIteratorDemo{
 // 建立List物件
 List list = new ArrayList();
 // 新增元素
 List.add("a");
 List.add("b");
 List.add("c");
 // 獲取元素，iterator()方法進行迭代
 Iterator it = list.iterator();
// 獲取元素
 while(it.hasNext()){
System.out.println(it.next());
 }
}

知識點

next() 返回迭代的下一個元素，如果丟擲異常為： NoSuchElementException ，為沒有元素可以迭代。

迭代器

在迭代過程中，使用了集合的方法對元素進行操作，導致迭代器不知道集合中的變化，容易產生資料的不確定性，所以不要使用集合的方法進行操作元素，可以使用迭代器的方法進行操作。

迭代器的方法：

// 簡書作者：達叔小生
hasNext()
next()
remove()

迭代器 java.util 介面 Iterator<E>
知道的介面： ListIterator<E>，XMLEventReader
知道的實現類： BeanContextSupport.BCSIterator，EventReaderDelegate，Scanner。

// 簡書作者：達叔小生
public interface Iterator<E>

迭代器的三個方法：

方法	說明
hasNext()	返回的是 boolean 型別，如果集合中還有元素存在，就可以進行迭代，然後返回 true ，代表為還有元素存在，反之，返回的是 false
next()	返回的是 E ，返回的是迭代出來的下一個元素
remove()	返回的型別為 void ，從迭代器中移除迭代器中的最後一個元素

列表迭代器

介面 Iterator<E> 下的子介面有個：

ListIterator<E> 為列表迭代器

// 簡書作者：達叔小生
java.util
介面ListIterator<E>
超級介面：Iterator<E>

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

// 簡書作者：達叔小生
while(it.hasNext()){
 Object obj = it.next();
 if("a".equals(obj)){
list.add("aaaaa");
 }
}

列表迭代器的特性可以在迭代期間進行修改列表，然後獲取迭代器在列表中的當前位置。

方法	說明
add(E e)	方法返回的是 void 型別，可以將指定的元素進行插入到列表中
hasNext()	方法返回的是 boolean 型別，該方法表示如果 next 返回一個元素後，不是丟擲異常，則代表有下一個元素，則返回 ture ，否則返回 false
hasPrevious()	返回的是 boolean 型別，該方法的作用是如果逆向遍歷列表，列表迭代器中有多個元素，則返回為 true ，即簡單說就是有沒有前一個
next()	返回的是 E ，該方法表示返回列表中的下一個元素
nextIndex()	返回的是 Int 型別，該方法對next的後續呼叫所返回元素的索引
previous()	返回的是列表中的前一個元素，取出前一個
previousIndex()	返回的型別為 int 型別，返回對 previous 的後續呼叫所返回元素的索引
remove()	返回的型別為 void ，從列表中移除一個元素
set(E e)	返回的型別為 Void ，用指定的元素取替代 next 或 previous 返回的最後一個元素

使用ListIterator

// 簡書作者：達叔小生
 // 建立List物件
 List list = new ArrayList();
 // 新增元素
 List.add("a");
 List.add("b");
 List.add("c");
// 列表迭代器
ListIterator it = list.listIterator();
while(it.hasNext()){
 Object obj = it.next();
 if("a".equals(obj)){
// 新增 it.add("dashucoding");
// 刪除 it.set("dashucoding");
 }
}

迭代器的 List 介面的子介面 ListIterator ，可以實現增刪改查

List

介面 List<E> ，知道的實現類：

List 是有序的，帶索引的，元素可以重複

List 可以增刪改查，增加 add() ，刪除 remove() ，修改 set() ，查詢 get()

// 簡書作者：達叔小生
實現類：
AbstractList , ArrayList , LinkedList , Vector
AbstractSequentialList , AttributeList , CopyOnWriteArrayList , RoleList , RoleUnresolvedList , Stack

ArrayList （陣列結構，不同步的，為了提高效率）, LinkedList （連結列表結構，就像鏈子一樣，不同步的） , Vector （可以實現可增長的物件陣列，可變化，同步的）

ArrayList

// 簡書作者：達叔小生
ArrayList為陣列結構，長度可以改變
java.util
類 ArrayList<E>
java.lang.Object
 -> java.util.AbstractCollection<E>
-> java.util.AbstractList<E>
-> java.util.ArrayList<E>

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

LinkedList 可以用於實現堆疊，佇列（棧記憶體先進後出，佇列先進先出）

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

public class LinkedList<E>
extends AbstractSequentiaList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

知道的介面： Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

LinkedList 佇列

// 簡書作者：達叔小生
public class LinkedListDemo{
 public static void main(String[] args){
// 建立一個佇列物件
Queue queue = new Queue();
// 佇列新增元素
queue.add("a");
queue.add("b");
queue.add("c");
while(!queue.isNull){
System.out.println(queue.myGet());
}
 }
}

佇列

class Queue{
 // 封裝了一個連結串列的資料結構
 private LinkedList link;
 Queue(){
link = new LinkedList();
 }
 // 功能
 public void add(Object obj){
// 內部，使用連結串列方法
link.addFirst(obj);
 }
// 先進先出
 public Object myGet(){
return link.removeList();
 }
 // 判斷佇列中的元素是否為空
 public boolean isNull(){
return link.isEmpty();
 }
}

堆疊，手槍彈夾，佇列，排隊買票

// 去除重複元素
public static void getSingleElement(List list){
 // 臨時容器
 List temp = new ArrayList();
 // 原容器
 for(Iterator it = list.iterator(); it.hasNext(); ){
// 遍歷原物件元素
Object obj = it.next();
if(temp.contains(obj)){
// 判斷是否存在
temp.add(obj);
}
 }
 list.clear();
 list.addAll(temp);
}

// 簡書作者：達叔小生
public class ArrayListDemo{
 public static void main(String[] args){
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
System.out.println(list);
 }
}

// 簡書作者：達叔小生
public boolean equals(Object obj){
 if(this == obj){
 return true;
 }
 if(!(obj instanceof Student)){
throw new ClassCastException();
 }
 Student stu = (Student) obj;
 return this.name.equals(stu.name) && this.age == stu.age;
}

// 簡書作者：達叔小生
public boolean contains(Object o){
 return indexOf(o) >= 0;
}

// 簡書作者：達叔小生
public int indexOf(Object o){
 if(o == null){
for(int i = 0; i<size; i++){
if(elementData[i] == null){
return i;
}
}
 }else{
for( int i = 0; i<size; i++){
if(o.equals(elementData[i])){
return i;
}
}
 }
 return -1;
}

// 簡書作者：達叔小生
List 
 -> Vector
 -> ArrayList
 -> LinkedList

介面集合框架-Set介面

API-set

java.util
介面 Set<E>
引數E：此set所維護元素的型別

超級介面
Collection<E>，Iterable<E>
知道的子介面
NavigableSet<E>，SortedSet<E>
知道實現類
AbstractSet，ConcurrentSkipListSet，CopyOnWriteArraySet，EnumSet，HashSet，
JobStateReasons，LinkedHashSet，TreeSet

HashSet 查詢效率很高，它的子類（兒子） LinkedHashSet ，可以迭代順序的 set 介面的雜湊表和連結列表的實現。

public class LinkedHashSetDemo{
 public static void main(String[] args){
Setset = new LinkedHashSet();
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator(); it.hesNext();){
System.out.println(it.next());
}
 }
}

public interface Set<E>
extends Collection<E>

Set 為一個不包含重複的集合，

Set 的一些方法：

方法	說明
add(E e)	返回型別為 boolean ，該方法用來新增元素
addAll(Collection<? extends g> c)	返回的是 boolean 型別，該方法是用來新增所有元素到 set 中的
clear()	返回 void 型別，是用來移除 set 中的所有元素
contains(Object o)	返回 boolean 型別，該方法是指定 set 中是否包含該元素，如果有則返回 true ，否則就為 false
containsAll(Collection<?> c)	返回 boolean 型別，如果在 set 中有包含所有指定的 collection 元素，就返回 true ，否則返回 false
equals(Object o)	返回型別為 boolean ，用來比較指定物件與此 set 的相等性
hashCode()	返回的型別為 Int ，返回 set 的雜湊碼值
isEmpty()	返回的是 int 型別，返回 set 不包含元素，則返回 true
iterator()	返回的是 Iterator<E> 型別，返回在此 set 中的元素上進行迭代的迭代器。
remove(Object o)	返回 boolean 型別，如果 set 中存在指定的元素，就將其移除
removeAll(Collection<?> c)	返回 boolean 型別，移除 set 中那些包含在指定collection中的元素
retainAll(Collection<?> c)	返回 boolean 型別，僅保留 set 中那些包含在指定collection中的元素
size()	返回 Int 型別，返回 set 中的元素數
toArray()	返回一個包含 set 中所有元素的陣列
toArray([] a)	返回一個包含 set 中所有元素的陣列，返回陣列的執行時型別是指定陣列的型別。

public class SetDemo{
 public static void main(String[] args){
Set set = new HashSet();
set.add("a");
set.add("b");
set.add("c");
// set.add(new Student("a",12));
// set.add(new Student("b",13));
// set.add(new Student("c",14));

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

Set 
 -> HashSet
 -> TreeSet

HashSet<E>

java.lang.Object
 -> java.util.AbstractCollection<E>
-> java.util.AbstractSet<E>
-> java.util.HashSet<E>

類HashSet<E>
知道已實現的介面：
Serializable,Cloneable,Iterable<E>,Collection<E>,Set<E>
知道的子類：
JobStateReasons,LinkedHashSet

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>,Cloneable,Serializable

HashSet 該類實現了 Set 的介面，陣列中儲存的是元素，雜湊值對應關係，所以叫雜湊表或叫雜湊，查詢速度快。有重複元素，用不了雜湊表，即不可以包含重複的元素，不保證順序，方法有 hasCode() 和 equals() 方法。

方法	說明
hashCode()	返回的是 Ine 型別，返回該物件的雜湊值

// 簡書作者：達叔小生
public int hashCode(){
 return 1;
}

public boolean equals(Object obj){
 if(this == obj)
return true;
 if(obj == null)
return false;
 if(getClass() != obj.getClass())
return false;
 if(age != other.age)
return false;
 if(name == null){
if(other.name != null)
return false;
 }else if(!name.equals(other.name))
return false;
 return true;
 }
}

TreeSet<E> ，可以進行排序 set 集合中的元素，比較結果為 0 ，視為相同元素不存。

案例

// 簡書作者：達叔小生
public class TreeSetDemo{
 public static void main(String[] args){
Set set = new TreeSet(new ComparatorLength() );
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator();it.hasNext(); ){
System.out.println(it.next());
}
 }
}

// 簡書作者：達叔小生
public class ComparatorLength implements Comparator{
 public int compare(Object o1,Object o2){
// 比較字串，強轉
String s1=(String)o1;
String s2=(String)o2;
int temp = s1.length() - s2.length();
return temp == 0? s1.compareTo(s2) : temp;
 }
}

// 簡書作者：達叔小生
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>,Cloneable,Serialirable

// 簡書作者：達叔小生
java.lang
介面 Comparable<T>
引數為可以與物件進行比較

// 定義一個類實現Comparator
public class ComparatorName implements Comparator{
 public int compare(Object o1,Object o2){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int temp = s1.getName().compareTo(s2.getName());
return temp==0? s1.getAge()-s2.getAge() : temp;
 }
}

已知的那些子介面：

Delayed,Name,RunnableScheduledFuture<V>,ScheduleFuture<V>

方法：實現 comparable 介面，可以排序的功能

方法	說明
compreTo(T o)	返回型別為 Int ，是用來比較物件與指定物件的順序

// 簡書作者：達叔小生
public int compareTo(Object o){
 if(!(o instanceof Student)){
throw new ClassCastException();
 }
 Student stu = (Student) o;
 if(this.age>stu.age)
return 1;
 if(this.age<stu.age)
return -1;
return 0;
}

// 簡書作者：達叔小生
public class TreeSetDemo{
 public static void main(String[] args){
// Set set = new TreeSet();
TreeSet set = new TreeSet();
set.add("a");
set.add("b");
set.add("c");
for(Iterator it = set.iterator(); it.hasNext(); ){
System.out.println(it.next());
}
 }
}

// 原始碼
public boolean add(E e){
 return m.put(e, PRESENT)==null;
}

構造方法：

方法	說明
TreeSet()	無參構造方法，該 set 根據其元素的自然順序進行排序
TreeSet(Collection<? extend E> e)	構造一個包含指定 collection 元素的新TreeSet，它按照其元素的自然順序進行排序
TreeSet(Comparator<? super E> comparator)	構造一個新的空 TreeSet ，它根據指定比較器進行順序
TreeSet(SortedSet<E> s)	構造一個與指定有序 set 具有相同對映關係和相同排序的新 TreeSet

二叉樹結構

二叉樹結構把小的放在左邊，大的放在右邊。

for each 迴圈

// 簡書作者：達叔小生
public class ForeachDemo{
 public static void main(String[] args){
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
for(Object str : list){
System.out.println(obj);
}
 }
}

列舉，一枚一枚的舉出了來

方法	說明
hasMoreElements()	返回的是 booleam 型別，測試列舉是否包含更多的元素
nextElement()	如果該列舉物件至少還有一個可提供的元素，就返回此列舉，取出下一個元素

// 簡書作者：達叔小生
public class EnumerationDemo{
 public static void main(String[] args)}
Vector v = new Vector(); 
v.addElement("a"); 
v.addElement("b");
v.addElement("c");
for(Enumeration e = v.elements(); e.hasMoreElements();){
System.out.println(e.nextElement());
}
// 不考慮，先考慮Iterator
for(Object obj : v){
System.out.println(obj);
}
 }
}

集合：

List -> ArrayList （陣列，查詢快）， LinkedList （連結串列，增刪快）

Set -> HashSet （雜湊表，查詢快，表對應唯一）

TreeSet （二叉樹，就知道排序的，有規則）

往後餘生，唯獨有你

簡書作者：達叔小生

90後帥氣小夥，良好的開發習慣；獨立思考的能力；主動並且善於溝通

簡書部落格： ofollow,noindex">https://www.jianshu.com/u/c785ece603d1

結語

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