1、List接口 2、Set接口 3、判斷集合唯一性原理

gnehc 發(fā)布于2019-08-14 18:41 / 2300人閱讀

摘要：接口的特點接口的特點它是一個元素存取有序的集合。導(dǎo)致迭代器并不知道集合中的變化，容易引發(fā)數(shù)據(jù)的不確定性。枚舉已被迭代器替代。集合取出元素的方式可以采用迭代器增強。

01List接口的特點

A:List接口的特點:
?a:它是一個元素存取有序的集合。

    例如，存元素的順序是11、22、33。那么集合中，元素的存儲就是按照11、22、33的順序完成的）。

?b:它是一個帶有索引的集合，通過索引就可以精確的操作集合中的元素（與數(shù)組的索引是一個道理）。
?

 c:集合中可以有重復(fù)的元素，通過元素的equals方法，來比較是否為重復(fù)的元素。

 d:List接口的常用子類有：

? ArrayList集合
? LinkedList集合

02List接口的特有方法

A:List接口的特有方法(帶索引的方法)

a:增加元素方法
? add(Object e)：向集合末尾處，添加指定的元素
? add(int index, Object e) 向集合指定索引處，添加指定的元素，原有元素依次后移

 
 /*
   *  add(int index, E)
   *  將元素插入到列表的指定索引上
   *  帶有索引的操作,防止越界問題
   *  java.lang.IndexOutOfBoundsException
   *     ArrayIndexOutOfBoundsException
   *     StringIndexOutOfBoundsException
   */
  public static void function(){
    List list = new ArrayList();
    list.add("abc1");
    list.add("abc2");
    list.add("abc3");
    list.add("abc4");
    System.out.println(list);
    
    list.add(1, "itcast");
    System.out.println(list);
  }

b:刪除元素刪除
? remove(Object e)：將指定元素對象，從集合中刪除，返回值為被刪除的元素
? remove(int index)：將指定索引處的元素，從集合中刪除，返回值為被刪除的元素

 /*
   *  E remove(int index)
   *  移除指定索引上的元素
   *  返回被刪除之前的元素
   */
  public static void function_1(){
    List list = new ArrayList();
    list.add(1.1);
    list.add(1.2);
    list.add(1.3);
    list.add(1.4);
    
    Double d = list.remove(0);
    System.out.println(d);
    System.out.println(list);
  }

c:替換元素方法
? set(int index, Object e)：將指定索引處的元素，替換成指定的元素，返回值為替換前的元素

  /*
   *  E set(int index, E)
   *  修改指定索引上的元素
   *  返回被修改之前的元素
   */
  public static void function_2(){
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    
    Integer i = list.set(0, 5);
    System.out.println(i);
    System.out.println(list);
  }
d:查詢元素方法

? get(int index)：獲取指定索引處的元素，并返回該元素

03迭代器的并發(fā)修改異常

A:迭代器的并發(fā)修改異常
 
 /*
  *  迭代器的并發(fā)修改異常 java.util.ConcurrentModificationException
  *  就是在遍歷的過程中,使用了集合方法修改了集合的長度,不允許的
  */
 public class ListDemo1 {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add("abc1");
    list.add("abc2");
    list.add("abc3");
    list.add("abc4");
    
    //對集合使用迭代器進行獲取,獲取時候判斷集合中是否存在 "abc3"對象
    //如果有,添加一個元素 "ABC3"
    Iterator it = list.iterator();
    while(it.hasNext()){
      String s = it.next();
      //對獲取出的元素s,進行判斷,是不是有"abc3"
      if(s.equals("abc3")){
        list.add("ABC3");
      }
      System.out.println(s);
    }
  }
 }

 運行上述代碼發(fā)生了錯誤 java.util.ConcurrentModificationException這是什么原因呢？
   在迭代過程中，使用了集合的方法對元素進行操作。
   導(dǎo)致迭代器并不知道集合中的變化，容易引發(fā)數(shù)據(jù)的不確定性。
   
 并發(fā)修改異常解決辦法：
    在迭代時，不要使用集合的方法操作元素。
    或者通過ListIterator迭代器操作元素是可以的，ListIterator的出現(xiàn)，解決了使用Iterator迭代過程中可能會發(fā)生的錯誤情況。

04數(shù)據(jù)的存儲結(jié)構(gòu)

A:數(shù)據(jù)的存儲結(jié)構(gòu)
 a:棧結(jié)構(gòu):后進先出/先進后出(手槍彈夾) FILO (first in last out)
 b:隊列結(jié)構(gòu):先進先出/后進后出(銀行排隊) FIFO(first in first out)
 c:數(shù)組結(jié)構(gòu):
           查詢快:通過索引快速找到元素
           增刪慢:每次增刪都需要開辟新的數(shù)組,將老數(shù)組中的元素拷貝到新數(shù)組中
                  開辟新數(shù)組耗費資源
 d:鏈表結(jié)構(gòu)
           查詢慢:每次都需要從鏈頭或者鏈尾找起
           增刪快:只需要修改元素記錄的下個元素的地址值即可不需要移動大量元素

=======================第二節(jié)課開始=============================================

05ArrayList集合的自身特點

A:ArrayList集合的自身特點

 底層采用的是數(shù)組結(jié)構(gòu)
 ArrayList al=new ArrayList();//創(chuàng)建了一個長度為0的Object類型數(shù)組
 al.add("abc");//底層會創(chuàng)建一個長度為10的Object數(shù)組 Object[] obj=new Object[10]
               //obj[0]="abc"
              //如果添加的元素的超過10個,底層會開辟一個1.5*10的長度的新數(shù)組
              //把原數(shù)組中的元素拷貝到新數(shù)組,再把最后一個元素添加到新數(shù)組中

原數(shù)組:

 a b c d e f g h k l

添加m:

 a b c d e f g h k l m null null null null

06LinkedList集合的自身特點

A:LinkedList集合的自身特點

 底層采用鏈表結(jié)構(gòu),每次查詢都要從鏈頭或鏈尾找起,查詢相對數(shù)組較慢
 但是刪除直接修改元素記錄的地址值即可,不要大量移動元素
 
 LinkedList的索引決定是從鏈頭開始找還是從鏈尾開始找
 如果該元素小于元素長度一半,從鏈頭開始找起,如果大于元素長度的一半,則從鏈尾找起

07LinkedList特有方法

*A:LinkedList特有方法:獲取,添加,刪除

   /*
 *  LinkedList 鏈表集合的特有功能
 *    自身特點: 鏈表底層實現(xiàn),查詢慢,增刪快
 *  
 *  子類的特有功能,不能多態(tài)調(diào)用
 */
public class LinkedListDemo {
  public static void main(String[] args) {
    function_3();
  }

  /*
   *  E removeFirst() 移除并返回鏈表的開頭
   *  E removeLast() 移除并返回鏈表的結(jié)尾
   */
  public static void function_3(){
    LinkedList link = new LinkedList();
    link.add("1");
    link.add("2");
    link.add("3");
    link.add("4");
    
    String first = link.removeFirst();
    String last = link.removeLast();
    System.out.println(first);
    System.out.println(last);
  
    System.out.println(link);
  }
  
  /*
   * E getFirst() 獲取鏈表的開頭
   * E getLast() 獲取鏈表的結(jié)尾
   */
  public static void function_2(){
    LinkedList link = new LinkedList();
    link.add("1");
    link.add("2");
    link.add("3");
    link.add("4");
  
    if(!link.isEmpty()){
      String first = link.getFirst();
      String last = link.getLast();
      System.out.println(first);
      System.out.println(last);
    }
  }
  
  public static void function_1(){
    LinkedList link = new LinkedList();
    link.addLast("a");
    link.addLast("b");
    link.addLast("c");
    link.addLast("d");
    
    link.addFirst("1");
    link.addFirst("2");
    link.addFirst("3");
    System.out.println(link);
  }
  
  /*
   *  addFirst(E) 添加到鏈表的開頭
   *  addLast(E) 添加到鏈表的結(jié)尾
   */
  public static void function(){
    LinkedList link = new LinkedList();
    
    link.addLast("heima");
    
    link.add("abc");
    link.add("bcd");
    
    link.addFirst("itcast");
    System.out.println(link);
    
    
  }
}

08Vector類的特點

*A:Vector類的特點

   Vector集合數(shù)據(jù)存儲的結(jié)構(gòu)是數(shù)組結(jié)構(gòu)，為JDK中最早提供的集合,它是線程同步的
   Vector中提供了一個獨特的取出方式，就是枚舉Enumeration，它其實就是早期的迭代器。
   此接口Enumeration的功能與 Iterator 接口的功能是類似的。
   Vector集合已被ArrayList替代。枚舉Enumeration已被迭代器Iterator替代。

=======================第三節(jié)課開始=============================================

09Set接口的特點

A:Set接口的特點

 a:它是個不包含重復(fù)元素的集合。
 b:Set集合取出元素的方式可以采用：迭代器、增強for。
 c:Set集合有多個子類，這里我們介紹其中的HashSet、LinkedHashSet這兩個集合。

10Set集合存儲和迭代

A:Set集合存儲和迭代

  /*
   *  Set接口,特點不重復(fù)元素,沒索引
   *  
   *  Set接口的實現(xiàn)類,HashSet (哈希表)
   *  特點: 無序集合,存儲和取出的順序不同,沒有索引,不存儲重復(fù)元素
   *  代碼的編寫上,和ArrayList完全一致
   */
  public class HashSetDemo {
    public static void main(String[] args) {
      Set set = new HashSet();
      set.add("cn");
      set.add("heima");
      set.add("java");
      set.add("java");
      set.add("itcast");
      
      Iterator it = set.iterator();
      while(it.hasNext()){
        System.out.println(it.next());
      }
      System.out.println("==============");
      
      for(String s : set){
        System.out.println(s);
      }
    }
  }

11哈希表的數(shù)據(jù)結(jié)構(gòu)

A:哈希表的數(shù)據(jù)結(jié)構(gòu):(參見圖解)
   
    加載因子:表中填入的記錄數(shù)/哈希表的長度
    例如:
    加載因子是0.75 代表:
      數(shù)組中的16個位置,其中存入16*0.75=12個元素

    如果在存入第十三個(>12)元素,導(dǎo)致存儲鏈子過長,會降低哈希表的性能,那么此時會擴充哈希表(在哈希),底層會開辟一個長度為原長度2倍的數(shù)組,把老元素拷貝到新數(shù)組中,再把新元素添加數(shù)組中
      
    當存入元素數(shù)量>哈希表長度*加載因子,就要擴容,因此加載因子決定擴容時機

12字符串對象的哈希值

  A:字符串對象的哈希值
  /*
   *  對象的哈希值,普通的十進制整數(shù)
   *  父類Object,方法 public int hashCode() 計算結(jié)果int整數(shù)
   */
  public class HashDemo {
    public static void main(String[] args) {
      Person p = new Person();
      int i = p.hashCode();
      System.out.println(i);
    
      String s1 = new String("abc");
      String s2 = new String("abc");
      System.out.println(s1.hashCode());
      System.out.println(s2.hashCode());
      
      /*System.out.println("重地".hashCode());
      System.out.println("通話".hashCode());*/
    }
  }
 
  //String類重寫hashCode()方法
  //字符串都會存儲在底層的value數(shù)組中{"a","b","c"}
  public int hashCode() {
          int h = hash;//hash初值為0
          if (h == 0 && value.length > 0) {
              char val[] = value;

              for (int i = 0; i < value.length; i++) {
                  h = 31 * h + val[i];
              }
              hash = h;
          }
          return h;
      }

13哈希表的存儲過程

A:哈希表的存儲過程

 public static void main(String[] args) {
    HashSet set = new HashSet();
    set.add(new String("abc"));
    set.add(new String("abc"));
    set.add(new String("bbc"));
    set.add(new String("bbc"));
    System.out.println(set); 
}

存取原理:

每存入一個新的元素都要走以下三步:

1.首先調(diào)用本類的hashCode()方法算出哈希值

2.在容器中找是否與新元素哈希值相同的老元素,
  如果沒有直接存入
  如果有轉(zhuǎn)到第三步

3.新元素會與該索引位置下的老元素利用equals方法一一對比
  一旦新元素.equals(老元素)返回true,停止對比,說明重復(fù),不再存入
  如果與該索引位置下的老元素都通過equals方法對比返回false,說明沒有重復(fù),存入

=======================第四節(jié)課開始=============================================

14哈希表的存儲自定義對象

A:哈希表的存儲自定義對象

 /*
  *  HashSet集合的自身特點:
  *    底層數(shù)據(jù)結(jié)構(gòu),哈希表
  *    存儲,取出都比較快
  *    線程不安全,運行速度快
  */
 public class HashSetDemo1 {
  public static void main(String[] args) {
    
    //將Person對象中的姓名,年齡,相同數(shù)據(jù),看作同一個對象
    //判斷對象是否重復(fù),依賴對象自己的方法 hashCode,equals
    HashSet setPerson = new HashSet();
    setPerson.add(new Person("a",11));
    setPerson.add(new Person("b",10));
    setPerson.add(new Person("b",10));
    setPerson.add(new Person("c",25));
    setPerson.add(new Person("d",19));
    setPerson.add(new Person("e",17));//每個對象的地址值都不同,調(diào)用Obejct類的hashCode方法返回不同哈希值,直接存入
    System.out.println(setPerson);
  }
 }

public class Person {
  private String name;
  private int 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;
  }
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public Person(){}
  
  public String toString(){
    return name+".."+age;
  }

15自定義對象重寫hashCode和equals

 A:自定義對象重寫hashCode和equals
  /*
      *  HashSet集合的自身特點:
      *    底層數(shù)據(jù)結(jié)構(gòu),哈希表
      *    存儲,取出都比較快
      *    線程不安全,運行速度快
      */
     public class HashSetDemo1 {
      public static void main(String[] args) {
        
        //將Person對象中的姓名,年齡,相同數(shù)據(jù),看作同一個對象
        //判斷對象是否重復(fù),依賴對象自己的方法 hashCode,equals
        HashSet setPerson = new HashSet();
        setPerson.add(new Person("a",11));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("c",25));
        setPerson.add(new Person("d",19));
        setPerson.add(new Person("e",17));
        System.out.println(setPerson);
      }
     }
    
    public class Person {
      private String name;
      private int age;

      /*
       *  沒有做重寫父類,每次運行結(jié)果都是不同整數(shù)
       *  如果子類重寫父類的方法,哈希值,自定義的
       *  存儲到HashSet集合的依據(jù)
       *   
       *  盡可能讓不同的屬性值產(chǎn)生不同的哈希值,這樣就不用再調(diào)用equals方法去比較屬性
       *
       */
      public int hashCode(){
        return name.hashCode()+age*55;
      }
      //方法equals重寫父類,保證和父類相同
      //public boolean equals(Object obj){}
      public boolean equals(Object obj){
        if(this == obj)
          return true;
        if(obj == null)
          return false;
        if(obj instanceof Person){
          Person p = (Person)obj;
          return name.equals(p.name) && age==p.age;
        }
        return false;
      }
      
      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;
      }
      public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
      }
      public Person(){}
      
      public String toString(){
        return name+".."+age;
      }

16LinkedHashSet集合

A:LinkedHashSet集合

/*
 *   LinkedHashSet 基于鏈表的哈希表實現(xiàn)
 *   繼承自HashSet
 *   
 *   LinkedHashSet 自身特性,具有順序,存儲和取出的順序相同的
 *   線程不安全的集合,運行速度塊
 */
public class LinkedHashSetDemo {
  
  public static void main(String[] args) {
    LinkedHashSet link = new LinkedHashSet();
    link.add(123);
    link.add(44);
    link.add(33);
    link.add(33);
    link.add(66);
    link.add(11);
    System.out.println(link);
  }
}

17ArrayList,HashSet判斷對象是否重復(fù)的原因

A:ArrayList,HashSet判斷對象是否重復(fù)的原因

 a:ArrayList的contains方法原理:底層依賴于equals方法
   ArrayList的contains方法會使用調(diào)用方法時，
     傳入的元素的equals方法依次與集合中的舊元素所比較，
     從而根據(jù)返回的布爾值判斷是否有重復(fù)元素。
     此時，當ArrayList存放自定義類型時，由于自定義類型在未重寫equals方法前，
     判斷是否重復(fù)的依據(jù)是地址值，所以如果想根據(jù)內(nèi)容判斷是否為重復(fù)元素，需要重寫元素的equals方法。

 b:HashSet的add()方法和contains方法()底層都依賴 hashCode()方法與equals方法()

  Set集合不能存放重復(fù)元素，其添加方法在添加時會判斷是否有重復(fù)元素，有重復(fù)不添加，沒重復(fù)則添加。
  HashSet集合由于是無序的，其判斷唯一的依據(jù)是元素類型的hashCode與equals方法的返回結(jié)果。規(guī)則如下：
  先判斷新元素與集合內(nèi)已經(jīng)有的舊元素的HashCode值
  ? 如果不同，說明是不同元素，添加到集合。
  ? 如果相同，再判斷equals比較結(jié)果。返回true則相同元素；返回false則不同元素，添加到集合。
  所以，使用HashSet存儲自定義類型，如果沒有重寫該類的hashCode與equals方法，則判斷重復(fù)時，使用的是地址值，如果想通過內(nèi)容比較元素是否相同，需要重寫該元素類的hashcode與equals方法。

18hashCode和equals方法的面試題

A:hashCode和equals的面試題
/*

兩個對象 Person p1 p2

問題: 如果兩個對象的哈希值相同 p1.hashCode()==p2.hashCode()

兩個對象的equals一定返回true嗎 p1.equals(p2) 一定是true嗎

正確答案:不一定

如果兩個對象的equals方法返回true,p1.equals(p2)==true

兩個對象的哈希值一定相同嗎

正確答案: 一定
*/

在 Java 應(yīng)用程序執(zhí)行期間，
1.如果根據(jù) equals(Object) 方法，兩個對象是相等的，那么對這兩個對象中的每個對象調(diào)用 hashCode 方法都必須生成相同的整數(shù)結(jié)果。
2.如果根據(jù) equals(java.lang.Object) 方法，兩個對象不相等，那么對這兩個對象中的任一對象上調(diào)用 hashCode 方法不要求一定生成不同的整數(shù)結(jié)果。

兩個對象不同(對象屬性值不同) equals返回false=====>兩個對象調(diào)用hashCode()方法哈希值相同

兩個對象調(diào)用hashCode()方法哈希值不同=====>equals返回true

兩個對象不同(對象屬性值不同) equals返回false=====>兩個對象調(diào)用hashCode()方法哈希值不同

兩個對象調(diào)用hashCode()方法哈希值相同=====>equals返回true

所以說兩個對象哈希值無論相同還是不同,equals都可能返回true

并發(fā)修改異常(重點)

描述的是：集合和迭代器同時持有同一個對象，當集合在添加，和刪除集合元素時（修改呢），迭代器并不知道，所以會發(fā)生并發(fā)修改異常   
注意：增強for也會產(chǎn)生并發(fā)修改異常
如何解決： 第一： 使用普通for循環(huán)
          第二(重點):使用listIterator -->是List 特有的，其他集合不能使用  
代碼：

常用方法：

  a、 E set(int index, E) 修改指定索引上的元素，返回被修改之前的元素
  b、 E remove(int index) 移除指定索引上的元素，返回被刪除之前的元素
  c、 add(int index, E)將元素插入到列表的指定索引上，其他元素順移
  d、remove(int index) 刪除并返回元素

數(shù)據(jù)類型：

 棧   ： 手槍的彈夾 : 手槍的壓棧     ---> 喝酒   --->先進后出，后進先出
 隊列 :  超市的購物，先排隊，先處理   ---> 喝酒   --->先進去，先出來，后進去，后出來
 數(shù)組 :  查找快:因為底層有索引，并且是連續(xù)
        增刪慢: 數(shù)組的長度的是固定的，當我們在進行增刪時，會創(chuàng)建一個新的數(shù)組，并且將老數(shù)組中的值拷貝到新數(shù)組中
 鏈表：  查找慢（底層是鏈表，兩兩相連，依次往下找，直到找到為止） --->linkedList 采用二分法查找 
        增刪快 :原因在于他僅僅只需要改變相鄰元素的地址值

arrayList的特點

  底層是可變數(shù)組查找快:因為底層有索引，并且是連續(xù)

　linkedList 的特點：

   查找慢（底層是鏈表，兩兩相連，依次往下找，直到找到為止）
 Vector ： 已經(jīng)被淘汰，是線程安全的，效率低，其他和arrayList 一致

需求：

 我想自己實現(xiàn)一個棧結(jié)構(gòu)：-->先進后出，后進先出

GPU云服務(wù)器云服務(wù)器 3.2.1.多云管理 add(1)(2)(3) 短信接口實現(xiàn)原理微機原理與接口技術(shù)

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/67165.html

發(fā)表評論

登陸后可評論

0條評論

gnehc

男|高級講師

我要關(guān)注我要私信

TA的文章

106短信平臺如何申請？申請周期是多久？

閱讀 1253·2021-11-22 13:54
C語言學(xué)習(xí)筆記—P17（函數(shù)棧幀的創(chuàng)建與銷毀＜超詳解版＞+圖解+題例）

閱讀 1440·2021-11-22 09:34
身價過億的溫柔蘿莉?qū)π〈a農(nóng)說ADC會采集嗎

閱讀 2717·2021-11-22 09:34
軟件測試肖sir__005測試用例設(shè)計方法（1）

閱讀 4031·2021-10-13 09:39
【題目】【5天】canvas元素

閱讀 3352·2019-08-26 11:52
package.json 中的 Module 字段是干嘛的

閱讀 3373·2019-08-26 11:50
TypeScript 初識 - 接口

閱讀 1541·2019-08-26 10:56
干貨:HTML5獲取頁面元素及類名操作和自定義屬性

閱讀 1923·2019-08-26 10:44

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

1、List接口 2、Set接口 3、判斷集合唯一性原理

相關(guān)文章

Java013-集合

**Java編程基礎(chǔ)18——集合（Set集合）**

java學(xué)習(xí)(七) —— API集合類

Java集合框架——Map接口

Collection集合知識點總結(jié)

發(fā)表評論

0條評論

gnehc

男|高級講師

TA的文章

106短信平臺如何申請？申請周期是多久？

C語言學(xué)習(xí)筆記—P17（函數(shù)棧幀的創(chuàng)建與銷毀＜超詳解版＞+圖解+題例）

身價過億的溫柔蘿莉?qū)π〈a農(nóng)說ADC會采集嗎

軟件測試肖sir__005測試用例設(shè)計方法（1）

【題目】【5天】canvas元素

package.json 中的 Module 字段是干嘛的

TypeScript 初識 - 接口

干貨:HTML5獲取頁面元素及類名操作和自定義屬性

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

1、List接口 2、Set接口 3、判斷集合唯一性原理

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

1、List接口 2、Set接口 3、判斷集合唯一性原理