JAVA 基礎知識學習16

    public static void main(String[] args) {
               ArrayList<Integer> list = new ArrayList<Integer>();
            list.add(111);
            list.add(222);
            list.add(333);
            list.add(444);
            list.add(555);
            for(int i=0; i<list.size(); i++){
                   System.out.println(list.get(i));
           }
          }

      *b.ArrayList集合存儲5個Person類型元素
         public static void main(String[] args) {
          ArrayList<Person> list = new ArrayList<Person>();
          list.add(new Person(“小強”));
          list.add(new Person(“老王”));
          list.add(new Person(“小虎”));
          list.add(new Person(“小澤”));
          list.add(new Person(“小紅”));
          for(int i=0; i<list.size(); i++){
            Person p = list.get(i);
                  System.out.println(p);
           }
         }

02集合的學習目標

   集合，集合是java中提供的一種容器，可以用來存儲多個數據。
 在前面的學習中，我們知道數據多了，可以使用數組存放或者使用ArrayList集合進行存放數據。那麼，集合和數組既然都是容器，它們有啥區別呢？
   數組的長度是固定的。集合的長度是可變的。
   集合中存儲的元素必須是引用類型數據

03集合繼承關係圖

A:集合繼承關係圖
 a:ArrayList的繼承關係:
 查看ArrayList類發現它繼承了抽象類AbstractList同時實現接口List，而List接口又繼承了Collection接口。Collection接口爲最頂層集合接口了。
 源代碼：

     interface List extends Collection {
      }
      public class ArrayList extends AbstractList implements List{
      }

b:集合繼承體系
 這說明我們在使用ArrayList類時，該類已經把所有抽象方法進行了重寫。那麼，實現Collection接口的所有子類都會進行方法重寫。
   Collecton接口常用的子接口有：List接口、Set接口
   List接口常用的子類有：ArrayList類、LinkedList類
   Set接口常用的子類有：HashSet類、LinkedHashSet類

                          Collection 接口     
                               |
 ----------------------------------------------------------------
 |                                                              |
List接口                                                       Set接口
 |                                                              |

—————- ————-
| | | |
ArrayList類 LinkedList類 HashSet類 LinkedHashSet類

04集合Collection的方法

A:集合Collection的方法

     /*
      *  Collection接口中的方法
      *  是集合中所有實現類必須擁有的方法
      *  使用Collection接口的實現類,程序的演示
      *  ArrayList implements List
      *  List extends Collection
      *  方法的執行,都是實現的重寫
      */
     public class CollectionDemo {
      public static void main(String[] args) {
        function_2();
      }


      /*  Collection接口方法
       *  Object[] toArray() 集合中的元素,轉成一個數組中的元素, 集合轉成數組
       *  返回是一個存儲對象的數組, 數組存儲的數據類型是Object
       */
      private static void function_2() {
        Collection<String> coll = new ArrayList<String>();
        coll.add("abc");
        coll.add("itcast");
        coll.add("itheima");
        coll.add("money");
        coll.add("123");

        Object[] objs = coll.toArray();
        for(int i = 0 ; i < objs.length ; i++){
          System.out.println(objs[i]);
        }
      }
      /*
       * 學習Java中三種長度表現形式
       *   數組.length 屬性  返回值 int
       *   字符串.length() 方法,返回值int
       *   集合.size()方法, 返回值int
       */

      /*
       * Collection接口方法
       * boolean contains(Object o) 判斷對象是否存在於集合中,對象存在返回true
       * 方法參數是Object類型
       */
      private static void function_1() {
        Collection<String> coll = new ArrayList<String>();
        coll.add("abc");
        coll.add("itcast");
        coll.add("itheima");
        coll.add("money");
        coll.add("123");

        boolean b = coll.contains("itcast");
        System.out.println(b);
      }


      /*
       * Collection接口的方法
       * void clear() 清空集合中的所有元素
       * 集合容器本身依然存在
       */
      public static void function(){
        //接口多態的方式調用
        Collection<String> coll = new ArrayList<String>();
        coll.add("abc");
        coll.add("bcd");
        System.out.println(coll);

        coll.clear();

        System.out.println(coll);

      }
     }

###05集合Collection的remove方法
   A:05集合Collection的remove方法
    /*
     * Collection接口方法
     * boolean remove(Object o)移除集合中指定的元素
     */
    private static void function_3(){
      Collection<String> coll = new ArrayList<String>();
      coll.add("abc");
      coll.add("money");
      coll.add("itcast");
      coll.add("itheima");
      coll.add("money");
      coll.add("123");  
      System.out.println(coll);

      boolean b = coll.remove("money");
      System.out.println(b);
      System.out.println(coll);
    }

=======================第二節課開始=============================================

06迭代器的概述

A:迭代器概述:
a:java中提供了很多個集合，它們在存儲元素時，採用的存儲方式不同。
我們要取出這些集合中的元素，可通過一種通用的獲取方式來完成。

b:Collection集合元素的通用獲取方式：在取元素之前先要判斷集合中有沒有元素，
如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來。一直把集合中的所有元素全部取出。這種取出方式專業術語稱爲迭代。

c:每種集合的底層的數據結構不同,例如ArrayList是數組,LinkedList底層是鏈表,但是無論使用那種集合,我們都會有判斷是否有元素
以及取出裏面的元素的動作,那麼Java爲我們提供一個迭代器定義了統一的判斷元素和取元素的方法

07迭代器的實現原理

*A:迭代器的實現原理
/*
* 集合中的迭代器:
* 獲取集合中元素方式
* 接口 Iterator : 兩個抽象方法
* boolean hasNext() 判斷集合中還有沒有可以被取出的元素,如果有返回true
* next() 取出集合中的下一個元素
*
* Iterator接口,找實現類.
* Collection接口定義方法
* Iterator iterator()
* ArrayList 重寫方法 iterator(),返回了Iterator接口的實現類的對象
* 使用ArrayList集合的對象
* Iterator it =array.iterator(),運行結果就是Iterator接口的實現類的對象
* it是接口的實現類對象,調用方法 hasNext 和 next 集合元素迭代
*/

08迭代器的代碼實現

*A:迭代器的代碼實現

     public class IteratorDemo {
        public static void main(String[] args) {
          Collection<String> coll = new ArrayList<String>();
          coll.add("abc1");
          coll.add("abc2");
          coll.add("abc3");
          coll.add("abc4");
          //迭代器,對集合ArrayList中的元素進行取出

          //調用集合的方法iterator()獲取出,Iterator接口的實現類的對象
          Iterator<String> it = coll.iterator();
          //接口實現類對象,調用方法hasNext()判斷集合中是否有元素
          //boolean b = it.hasNext();
          //System.out.println(b);
          //接口的實現類對象,調用方法next()取出集合中的元素
          //String s = it.next();
          //System.out.println(s);

          //迭代是反覆內容,使用循環實現,循環的條件,集合中沒元素, hasNext()返回了false
          while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
          }



        }
      }
###09迭代器的執行過程
   A:迭代器的執行過程
     a:迭代器的原理:
       while(it.hasNext()) {
            System.out.println(it.next());
       }

       //cursor記錄的索引值不等於集合的長度返回true,否則返回false
         public boolean hasNext() {       
           return cursor != size; //cursor初值爲0

         }

        //next()方法作用:
        //①返回cursor指向的當前元素 
        //②cursor++
        public Object next() {            
                 int i = cursor; 
                 cursor = i + 1;  
                 return  elementData[lastRet = i]; 

             }
     b:for循環迭代寫法:
        for (Iterator<String> it2 = coll.iterator(); it2.hasNext();  ) {
         System.out.println(it2.next());
       }

10集合迭代中的轉型

A:集合迭代中的轉型
a:在使用集合時，我們需要注意以下幾點：
 集合中存儲其實都是對象的地址。
 集合中可以存儲基本數值嗎？jdk1.5版本以後可以存儲了。
因爲出現了基本類型包裝類，它提供了自動裝箱操作（基本類型對象），這樣，集合中的元素就是基本數值的包裝類對象。

  b:存儲時提升了Object。取出時要使用元素的特有內容，必須向下轉型。
     Collection coll = new ArrayList();
     coll.add("abc");
     coll.add("aabbcc");
     coll.add("shitcast");
     Iterator it = coll.iterator();
     while (it.hasNext()) {
      //由於元素被存放進集合後全部被提升爲Object類型
     //當需要使用子類對象特有方法時，需要向下轉型
      String str = (String) it.next();
      System.out.println(str.length());
     }
     注意：如果集合中存放的是多個對象，這時進行向下轉型會發生類型轉換異常。


    c:Iterator接口也可以使用<>來控制迭代元素的類型的。代碼演示如下：
     Collection<String> coll = new ArrayList<String>();
     coll.add("abc");
     coll.add("aabbcc");
     coll.add("shitcast");
     Iterator<String> it = coll.iterator();
     while (it.hasNext()) {
      String str =  it.next(); 
     //當使用Iterator<String>控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型
      System.out.println(str.length());
     }

=========================第三節課開始====================================

11增強for循環遍歷數組

*A:增強for循環遍歷數組
a:格式:

  /*
      *  JDK1.5新特性,增強for循環
      *  JDK1.5版本後,出現新的接口 java.lang.Iterable
      *    Collection開是繼承Iterable
      *    Iterable作用,實現增強for循環
      *    
      *    格式:
      *      for( 數據類型  變量名 : 數組或者集合 ){
      *         sop(變量);
      *      }
      */
     public static void function_1(){
        //for對於對象數組遍歷的時候,能否調用對象的方法呢
        String[] str = {"abc","itcast","cn"};
        for(String s : str){
          System.out.println(s.length());
        }
      }

      /*
       *  實現for循環,遍歷數組
       *  好處: 代碼少了,方便對容器遍歷
       *  弊端: 沒有索引,不能操作容器裏面的元素
       */
      public static void function(){
        int[] arr = {3,1,9,0};
        for(int i : arr){
          System.out.println(i+1);
        }
        System.out.println(arr[0]);
      }
###12增強for循環遍歷集合 
      A:增強for循環遍歷集合  
        /*
         *  增強for循環遍歷集合
         *  存儲自定義Person類型
         */
        public static void function_2(){
          ArrayList<Person> array = new ArrayList<Person>();
          array.add(new Person("a",20));
          array.add(new Person("b",10));
          for(Person p : array){
            System.out.println(p);// System.out.println(p.toString());
          }
        }

13泛型的引入

A:泛型的引入
在前面學習集合時，我們都知道集合中是可以存放任意對象的，
只要把對象存儲集合後，那麼這時他們都會被提升成Object類型。
當我們在取出每一個對象，並且進行相應的操作，這時必須採用類型轉換。比如下面程序：

 public class GenericDemo {
      public static void main(String[] args) {
        List list = new ArrayList();
        list.add("abc");
        list.add("itcast");
        list.add(5);//由於集合沒有做任何限定，任何類型都可以給其中存放
                    //相當於:Object obj=new Integer(5);

        Iterator it = list.iterator();
        while(it.hasNext()){
          //需要打印每個字符串的長度,就要把迭代出來的對象轉成String類型
          String str = (String) it.next();//String str=(String)obj;
                                          //編譯時期僅檢查語法錯誤,String是Object的兒子可以向下轉型
                                          //運行時期String str=(String)(new Integer(5))
                                          //String與Integer沒有父子關係所以轉換失敗
                                          //程序在運行時發生了問題java.lang.ClassCastException
          System.out.println(str.length());
        }
      }
    }

14泛型的定義和使用

A:泛型的定義和使用

   /*
     * JDK1.5 出現新的安全機制,保證程序的安全性
     *   泛型: 指明瞭集合中存儲數據的類型  <數據類型>
     */

    public class GenericDemo {
      public static void main(String[] args) {
        function();
      }

      public static void function(){
        Collection<String> coll = new ArrayList<String>();
        coll.add("abc");
        coll.add("rtyg");
        coll.add("43rt5yhju");
    //    coll.add(1);

        Iterator<String> it = coll.iterator();
        while(it.hasNext()){
          String s = it.next();
          System.out.println(s.length());
        }
      }
    }

###15Java中的僞泛型
     A:Java中的僞泛型：
       泛型只在編譯時存在,編譯後就被擦除,在編譯之前我們就可以限制集合的類型,起到作用
     例如:ArrayList<String> al=new ArrayList<String>();
     編譯後:ArrayList al=new ArrayList();

================================第四節課開始======================================================

16泛型類

A:泛型類:
a:定義格式：
修飾符 class 類名<代表泛型的變量> { }

  例如，API中的ArrayList集合：

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

    b:使用格式：
      創建對象時，確定泛型的類型

      例如，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){  }
      }

17泛型的方法

A:泛型的方法
a:定義格式：修飾符 <代表泛型的變量> 返回值類型方法名(參數){ }
b:泛型方法的使用:
1:例如，API中的ArrayList集合中的方法：
public T[] toArray(T[] a){ }
//該方法，用來把集合元素存儲到指定數據類型的數組中，返回已存儲集合元素的數組

  使用格式：調用方法時，確定泛型的類型
例如:

         ArrayList<String> list = new ArrayList<String>();
          String[] arr = new String[100];
          String[] result = list.toArray(arr);
       此時，變量T的值就是String類型。變量T，可以與定義集合的泛型不同
       public <String> String[] toArray(String[] a){  } 
    

      例如:
          ArrayList<String> list = new ArrayList<String>();
          Integer[] arr = new Integer[100];
          Integer [] result = list.toArray(arr);

      此時，變量T的值就是Integer類型。變量T，可以與定義集合的泛型不同
      public <Integer> Integer[] toArray(Integer[] a){  }

18泛型的接口

A:泛型的接口:

   /*
      *  帶有泛型的接口
      *  
      *  public interface List <E>{
      *    abstract boolean add(E e);
      *  }
      * 
      *  實現類,先實現接口,不理會泛型
      *  public class ArrayList<E> implements List<E>{
      *  }
      *  調用者 : new ArrayList<String>() 後期創建集合對象的時候,指定數據類型
      *  
      *  
      *  實現類,實現接口的同時,也指定了數據類型
      *  public class XXX implements List<String>{
      *  }
      *  new XXX()
      */
     public class GenericDemo2 {

     }

19泛型的好處

A:泛型的好處
a:將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
b:避免了類型強轉的麻煩。
演示下列代碼：

    public class GenericDemo {
      public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        //list.add(5);//當集合明確類型後，存放類型不一致就會編譯報錯
                     //集合已經明確具體存放的元素類型，那麼在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
           String str = it.next();
           System.out.println(str.length()); //當使用Iterator<String>      
                                            //控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型
        }
      }
    }

###20泛型的通配符   
   A:泛型的通配符
   /*
    *  泛型的通配符
    */
   public class GenericDemo {
    public static void main(String[] args) {
      ArrayList<String> array = new ArrayList<String>();

      HashSet<Integer> set = new HashSet<Integer>();

      array.add("123");
      array.add("456");

      set.add(789);
      set.add(890);

      iterator(array);
      iterator(set);
    }
    /*
     *  定義方法,可以同時迭代2個集合
     *  參數: 怎麼實現 , 不能寫ArrayList,也不能寫HashSet
     *  參數: 或者共同實現的接口
     *  泛型的通配,匹配所有的數據類型  ?
     */
    public static void iterator(Collection<?> coll){
      Iterator<?> it = coll.iterator();
      while(it.hasNext()){
        //it.next()獲取的對象,什麼類型
        System.out.println(it.next());
      }
    }
   }

###21泛型的限定 
 A:泛型的限定
   /*
    *  將的酒店員工,廚師,服務員,經理,分別存儲到3個集合中
    *  定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法
    */
   import java.util.ArrayList;
   import java.util.Iterator;
   public class GenericTest {
    public static void main(String[] args) {
      //創建3個集合對象
      ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
      ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
      ArrayList<JingLi> jl = new ArrayList<JingLi>();

      //每個集合存儲自己的元素
      cs.add(new ChuShi("張三", "後廚001"));
      cs.add(new ChuShi("李四", "後廚002"));

      fwy.add(new FuWuYuan("翠花", "服務部001"));
      fwy.add(new FuWuYuan("酸菜", "服務部002"));

      jl.add(new JingLi("小名", "董事會001", 123456789.32));
      jl.add(new JingLi("小強", "董事會002", 123456789.33));

   //   ArrayList<String> arrayString = new ArrayList<String>();
      iterator(jl);
      iterator(fwy);
      iterator(cs);

    }
    /*
     * 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法 work
     * ? 通配符,迭代器it.next()方法取出來的是Object類型,怎麼調用work方法
     * 強制轉換:  it.next()=Object o ==> Employee
     * 方法參數: 控制,可以傳遞Employee對象,也可以傳遞Employee的子類的對象
     * 泛型的限定  本案例,父類固定Employee,但是子類可以無限?
     *   ? extends Employee 限制的是父類, 上限限定, 可以傳遞Employee,傳遞他的子類對象
     *   ? super   Employee 限制的是子類, 下限限定, 可以傳遞Employee,傳遞他的父類對象
     */
    public static void iterator(ArrayList<? extends Employee> array){

       Iterator<? extends Employee> it = array.iterator();
       while(it.hasNext()){
         //獲取出的next() 數據類型,是什麼Employee
         Employee e = it.next();
         e.work();
       }
    }
   }

01List接口的特點

A:List接口的特點:
a:它是一個元素存取有序的集合。
例如，存元素的順序是11、22、33。那麼集合中，元素的存儲就是按照11、22、33的順序完成的）。
b:它是一個帶有索引的集合，通過索引就可以精確的操作集合中的元素（與數組的索引是一個道理）。

c:集合中可以有重複的元素，通過元素的equals方法，來比較是否爲重複的元素。

 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<String> list = new ArrayList<String>();
        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<Double> list = new ArrayList<Double>();
        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<Integer> list = new ArrayList<Integer>();
        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迭代器的併發修改異常

A:迭代器的併發修改異常

  /*
      *  迭代器的併發修改異常 java.util.ConcurrentModificationException
      *  就是在遍歷的過程中,使用了集合方法修改了集合的長度,不允許的
      */
     public class ListDemo1 {
      public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");

        //對集合使用迭代器進行獲取,獲取時候判斷集合中是否存在 "abc3"對象
        //如果有,添加一個元素 "ABC3"
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
          String s = it.next();
          //對獲取出的元素s,進行判斷,是不是有"abc3"
          if(s.equals("abc3")){
            list.add("ABC3");
          }
          System.out.println(s);
        }
      }
     }

     運行上述代碼發生了錯誤 java.util.ConcurrentModificationException這是什麼原因呢？
       在迭代過程中，使用了集合的方法對元素進行操作。
       導致迭代器並不知道集合中的變化，容易引發數據的不確定性。

     併發修改異常解決辦法：
        在迭代時，不要使用集合的方法操作元素。
        或者通過ListIterator迭代器操作元素是可以的，ListIterator的出現，解決了使用Iterator迭代過程中可能會發生的錯誤情況。

04數據的存儲結構

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

=======================第二節課開始=============================================

05ArrayList集合的自身特點

A:ArrayList集合的自身特點
底層採用的是數組結構
ArrayList al=new ArrayList();//創建了一個長度爲0的Object類型數組
al.add(“abc”);//底層會創建一個長度爲10的Object數組 Object[] obj=new Object[10]
//obj[0]=”abc”
//如果添加的元素的超過10個,底層會開闢一個1.5*10的長度的新數組
//把原數組中的元素拷貝到新數組,再把最後一個元素添加到新數組中
原數組:
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集合的自身特點
底層採用鏈表結構,每次查詢都要從鏈頭或鏈尾找起,查詢相對數組較慢
但是刪除直接修改元素記錄的地址值即可,不要大量移動元素

 LinkedList的索引決定是從鏈頭開始找還是從鏈尾開始找
 如果該元素小於元素長度一半,從鏈頭開始找起,如果大於元素長度的一半,則從鏈尾找起

07LinkedList特有方法

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

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


      /*
       *  E removeFirst() 移除並返回鏈表的開頭
       *  E removeLast() 移除並返回鏈表的結尾
       */
      public static void function_3(){
        LinkedList<String> link = new LinkedList<String>();
        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() 獲取鏈表的結尾
       */
      public static void function_2(){
        LinkedList<String> link = new LinkedList<String>();
        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<String> link = new LinkedList<String>();
        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) 添加到鏈表的結尾
       */
      public static void function(){
        LinkedList<String> link = new LinkedList<String>();

        link.addLast("heima");

        link.add("abc");
        link.add("bcd");

        link.addFirst("itcast");
        System.out.println(link);


      }
    }

08Vector類的特點

*A:Vector類的特點
Vector集合數據存儲的結構是數組結構，爲JDK中最早提供的集合,它是線程同步的
Vector中提供了一個獨特的取出方式，就是枚舉Enumeration，它其實就是早期的迭代器。
此接口Enumeration的功能與 Iterator 接口的功能是類似的。
Vector集合已被ArrayList替代。枚舉Enumeration已被迭代器Iterator替代。

=======================第三節課開始=============================================

09Set接口的特點

A:Set接口的特點
a:它是個不包含重複元素的集合。
b:Set集合取出元素的方式可以採用：迭代器、增強for。
c:Set集合有多個子類，這裏我們介紹其中的HashSet、LinkedHashSet這兩個集合。

10Set集合存儲和迭代

A:Set集合存儲和迭代

      /*
       *  Set接口,特點不重複元素,沒索引
       *  
       *  Set接口的實現類,HashSet (哈希表)
       *  特點: 無序集合,存儲和取出的順序不同,沒有索引,不存儲重複元素
       *  代碼的編寫上,和ArrayList完全一致
       */
      public class HashSetDemo {
        public static void main(String[] args) {
          Set<String> set = new HashSet<String>();
          set.add("cn");
          set.add("heima");
          set.add("java");
          set.add("java");
          set.add("itcast");

          Iterator<String> it = set.iterator();
          while(it.hasNext()){
            System.out.println(it.next());
          }
          System.out.println("==============");

          for(String s : set){
            System.out.println(s);
          }
        }
      }

11哈希表的數據結構

A:哈希表的數據結構:(參見圖解)

    加載因子:表中填入的記錄數/哈希表的長度
    例如:
    加載因子是0.75 代表:
      數組中的16個位置,其中存入16*0.75=12個元素

    如果在存入第十三個(>12)元素,導致存儲鏈子過長,會降低哈希表的性能,那麼此時會擴充哈希表(在哈希),底層會開闢一個長度爲原長度2倍的數組,把老元素拷貝到新數組中,再把新元素添加數組中

    當存入元素數量>哈希表長度*加載因子,就要擴容,因此加載因子決定擴容時機

12字符串對象的哈希值

   A:字符串對象的哈希值
      /*
       *  對象的哈希值,普通的十進制整數
       *  父類Object,方法 public int hashCode() 計算結果int整數
       */
      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數組中{'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<String> set = new HashSet<String>();
        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.首先調用本類的hashCode()方法算出哈希值

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

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

=======================第四節課開始=============================================

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

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

   /*
      *  HashSet集合的自身特點:
      *    底層數據結構,哈希表
      *    存儲,取出都比較快
      *    線程不安全,運行速度快
      */
     public class HashSetDemo1 {
      public static void main(String[] args) {

        //將Person對象中的姓名,年齡,相同數據,看作同一個對象
        //判斷對象是否重複,依賴對象自己的方法 hashCode,equals
        HashSet<Person> setPerson = new HashSet<Person>();
        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));//每個對象的地址值都不同,調用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集合的自身特點:
          *    底層數據結構,哈希表
          *    存儲,取出都比較快
          *    線程不安全,運行速度快
          */
         public class HashSetDemo1 {
          public static void main(String[] args) {

            //將Person對象中的姓名,年齡,相同數據,看作同一個對象
            //判斷對象是否重複,依賴對象自己的方法 hashCode,equals
            HashSet<Person> setPerson = new HashSet<Person>();
            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;

          /*
           *  沒有做重寫父類,每次運行結果都是不同整數
           *  如果子類重寫父類的方法,哈希值,自定義的
           *  存儲到HashSet集合的依據
           *   
           *  儘可能讓不同的屬性值產生不同的哈希值,這樣就不用再調用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 基於鏈表的哈希表實現
     *   繼承自HashSet
     *   
     *   LinkedHashSet 自身特性,具有順序,存儲和取出的順序相同的
     *   線程不安全的集合,運行速度塊
     */
    public class LinkedHashSetDemo {

      public static void main(String[] args) {
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
        link.add(123);
        link.add(44);
        link.add(33);
        link.add(33);
        link.add(66);
        link.add(11);
        System.out.println(link);
      }
    }

17ArrayList,HashSet判斷對象是否重複的原因

A:ArrayList,HashSet判斷對象是否重複的原因
a:ArrayList的contains方法原理:底層依賴於equals方法
ArrayList的contains方法會使用調用方法時，
傳入的元素的equals方法依次與集合中的舊元素所比較，
從而根據返回的布爾值判斷是否有重複元素。
此時，當ArrayList存放自定義類型時，由於自定義類型在未重寫equals方法前，
判斷是否重複的依據是地址值，所以如果想根據內容判斷是否爲重複元素，需要重寫元素的equals方法。

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

  Set集合不能存放重複元素，其添加方法在添加時會判斷是否有重複元素，有重複不添加，沒重複則添加。
  HashSet集合由於是無序的，其判斷唯一的依據是元素類型的hashCode與equals方法的返回結果。規則如下：
  先判斷新元素與集合內已經有的舊元素的HashCode值
   如果不同，說明是不同元素，添加到集合。
   如果相同，再判斷equals比較結果。返回true則相同元素；返回false則不同元素，添加到集合。
  所以，使用HashSet存儲自定義類型，如果沒有重寫該類的hashCode與equals方法，則判斷重複時，使用的是地址值，如果想通過內容比較元素是否相同，需要重寫該元素類的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 應用程序執行期間，
1.如果根據 equals(Object) 方法，兩個對象是相等的，那麼對這兩個對象中的每個對象調用 hashCode 方法都必須生成相同的整數結果。
2.如果根據 equals(java.lang.Object) 方法，兩個對象不相等，那麼對這兩個對象中的任一對象上調用 hashCode 方法不要求一定生成不同的整數結果。

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

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


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

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

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