Java集合框架中底层文档的List与Set

水深无声 2021-09-16 10:55 195阅读 0赞

![标题图][1240]

## Java集合框架中的List与Set ##

// 简书作者：达叔小生
    Collection
     -> Set 无序不重复 -> 无序HashSet，需要排序TreeSet
     -> List 有序可重复 -> 查，改ArrayList，增删LinkedList

`List`为列表，中在列表中的对象是由顺序的排序的，并且是有重复的对象。  
**简单为：有序，有重复。**

`Set`为集合，在集合中的对象是不按照顺序排列的，并且是没有重复的对象的。  
**简单为：无序，无重复。**

> `Set`为无序集合，无序无重复；  
> `List`为有序集合，有序有重复；

// 简书作者：达叔小生
    Collection
     -> Set
      -> HashSet
      -> LinkedHashSet
      -> TreeSet
    
     -> List
      -> ArrayList
      -> Vector
      -> LinkedList

![Collection接口][Collection]

## 案例 ##

// 简书作者：达叔小生
    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>

**迭代器的三个方法：**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hasNext()</td> 
   <td>返回的是<code>boolean</code>类型，如果集合中还有元素存在，就可以进行迭代，然后返回<code>true</code>，代表为还有元素存在，反之，返回的是<code>false</code></td> 
  </tr> 
  <tr> 
   <td>next()</td> 
   <td>返回的是<code>E</code>，返回的是迭代出来的下一个元素</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>返回的类型为<code>void</code>，从迭代器中移除迭代器中的最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

## 列表迭代器 ##

> 接口 `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");
     }
    }

> 列表迭代器的特性可以在迭代期间进行修改列表，然后获取迭代器在列表中的当前位置。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>add(E e)</td> 
   <td>方法返回的是<code>void</code>类型，可以将指定的元素进行插入到列表中</td> 
  </tr> 
  <tr> 
   <td>hasNext()</td> 
   <td>方法返回的是<code>boolean</code>类型，该方法表示如果<code>next</code>返回一个元素后，不是抛出异常，则代表有下一个元素，则返回<code>ture</code>，否则返回<code>false</code></td> 
  </tr> 
  <tr> 
   <td>hasPrevious()</td> 
   <td>返回的是<code>boolean</code>类型，该方法的作用是如果逆向遍历列表，列表迭代器中有多个元素，则返回为<code>true</code>，即简单说就是有没有前一个</td> 
  </tr> 
  <tr> 
   <td>next()</td> 
   <td>返回的是<code>E</code>，该方法表示返回列表中的下一个元素</td> 
  </tr> 
  <tr> 
   <td>nextIndex()</td> 
   <td>返回的是<code>Int</code>类型，该方法对next的后续调用所返回元素的索引</td> 
  </tr> 
  <tr> 
   <td>previous()</td> 
   <td>返回的是列表中的前一个元素，取出前一个</td> 
  </tr> 
  <tr> 
   <td>previousIndex()</td> 
   <td>返回的类型为<code>int</code>类型，返回对<code>previous</code>的后续调用所返回元素的索引</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>返回的类型为<code>void</code>，从列表中移除一个元素</td> 
  </tr> 
  <tr> 
   <td>set(E e)</td> 
   <td>返回的类型为<code>Void</code>，用指定的元素取替代<code>next</code>或<code>previous</code> 返回的最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

## 使用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>

> 知道的实现接口：  
> `Serializable,Cloneable,Iterable<E>,Collection<E>,List<E>,RandomAccess`  
> 知道的子类：  
> `AttributeList, RoleList, RoleUnresolvedList`

// 简书作者：达叔小生
    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){
      Set  set = 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`的一些方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>add(E e)</td> 
   <td>返回类型为<code>boolean</code>，该方法用来添加元素</td> 
  </tr> 
  <tr> 
   <td>addAll(Collection&lt;? extends g&gt; c)</td> 
   <td>返回的是<code>boolean</code>类型，该方法是用来添加所有元素到<code>set</code>中的</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>返回<code>void</code>类型，是用来移除<code>set</code>中的所有元素</td> 
  </tr> 
  <tr> 
   <td>contains(Object o)</td> 
   <td>返回<code>boolean</code>类型，该方法是指定<code>set</code>中是否包含该元素，如果有则返回<code>true</code>，否则就为<code>false</code></td> 
  </tr> 
  <tr> 
   <td>containsAll(Collection&lt;?&gt; c)</td> 
   <td>返回<code>boolean</code>类型，如果在<code>set</code>中有包含所有指定的<code>collection</code>元素，就返回<code>true</code>，否则返回<code>false</code></td> 
  </tr> 
  <tr> 
   <td>equals(Object o)</td> 
   <td>返回类型为<code>boolean</code>，用来比较指定对象与此<code>set</code>的相等性</td> 
  </tr> 
  <tr> 
   <td>hashCode()</td> 
   <td>返回的类型为<code>Int</code>，返回<code>set</code>的哈希码值</td> 
  </tr> 
  <tr> 
   <td>isEmpty()</td> 
   <td>返回的是<code>int</code>类型，返回<code>set</code>不包含元素，则返回<code>true</code></td> 
  </tr> 
  <tr> 
   <td>iterator()</td> 
   <td>返回的是<code>Iterator&lt;E&gt;</code>类型，返回在此<code>set</code>中的元素上进行迭代的迭代器。</td> 
  </tr> 
  <tr> 
   <td>remove(Object o)</td> 
   <td>返回<code>boolean</code>类型，如果<code>set</code>中存在指定的元素，就将其移除</td> 
  </tr> 
  <tr> 
   <td>removeAll(Collection&lt;?&gt; c)</td> 
   <td>返回<code>boolean</code>类型，移除<code>set</code>中那些包含在指定collection中的元素</td> 
  </tr> 
  <tr> 
   <td>retainAll(Collection&lt;?&gt; c)</td> 
   <td>返回<code>boolean</code>类型，仅保留<code>set</code>中那些包含在指定collection中的元素</td> 
  </tr> 
  <tr> 
   <td>size()</td> 
   <td>返回<code>Int</code>类型，返回<code>set</code>中的元素数</td> 
  </tr> 
  <tr> 
   <td>toArray()</td> 
   <td>返回一个包含<code>set</code>中所有元素的数组</td> 
  </tr> 
  <tr> 
   <td>toArray([] a)</td> 
   <td>返回一个包含<code>set</code>中所有元素的数组，返回数组的运行时类型是指定数组的类型。</td> 
  </tr> 
 </tbody> 
</table>

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()`方法。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hashCode()</td> 
   <td>返回的是<code>Ine</code>类型，返回该对象的哈希值</td> 
  </tr> 
 </tbody> 
</table>

// 简书作者：达叔小生
    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`接口，可以排序的功能

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>compreTo(T o)</td> 
   <td>返回类型为<code>Int</code>，是用来比较对象与指定对象的顺序</td> 
  </tr> 
 </tbody> 
</table>

// 简书作者：达叔小生
    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;
    }

**构造方法：**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>TreeSet()</td> 
   <td>无参构造方法，该<code>set</code>根据其元素的自然顺序进行排序</td> 
  </tr> 
  <tr> 
   <td>TreeSet(Collection&lt;? extend E&gt; e)</td> 
   <td>构造一个包含指定<code>collection</code>元素的新TreeSet，它按照其元素的自然顺序进行排序</td> 
  </tr> 
  <tr> 
   <td>TreeSet(Comparator&lt;? super E&gt; comparator)</td> 
   <td>构造一个新的空<code>TreeSet</code>，它根据指定比较器进行顺序</td> 
  </tr> 
  <tr> 
   <td>TreeSet(SortedSet s)</td> 
   <td>构造一个与指定有序<code>set</code>具有相同映射关系和相同排序的新<code>TreeSet</code></td> 
  </tr> 
 </tbody> 
</table>

## 二叉树结构 ##

二叉树结构把小的放在左边，大的放在右边。

![二叉树结构][1240 1]

## 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);
      }
     }
    }

> 枚举，一枚一枚的举出了来

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hasMoreElements()</td> 
   <td>返回的是<code>booleam</code>类型，测试枚举是否包含更多的元素</td> 
  </tr> 
  <tr> 
   <td>nextElement()</td> 
   <td>如果该枚举对象至少还有一个可提供的元素，就返回此枚举，取出下一个元素</td> 
  </tr> 
 </tbody> 
</table>

// 简书作者：达叔小生
    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后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通  
> 简书博客： [https://www.jianshu.com/u/c785ece603d1][https_www.jianshu.com_u_c785ece603d1]

## 结语 ##

*  下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/9a51725764364ee59554922746835c20.png
[Collection]: /images/20210724/850f67a259124dbea91534e3cf002598.png
[1240 1]: /images/20210724/8e9cfae0316e49a7bbe761f9cb42f9ff.png
[https_www.jianshu.com_u_c785ece603d1]: https://www.jianshu.com/u/c785ece603d1