集合

集合框架

• Collection接口：全部單列集合最頂層接口

  • List接口：單列集合中的一種

    是有序的集合，容許儲存重複的元素，有索引，能夠使用普通for循環遍歷

    • ArrayList集合：底層是數組實現的，查詢快，增刪慢
    • LinkedList集合：底層是鏈表實現的，查詢慢，增刪快
    • Vector集合

  • Set接口：單列集合中的一種

    不容許儲存重複元素，沒有索引，不能使用普通for循環遍歷

    • HashSet集合：底層是哈希表（+紅黑樹）實現的，無序集合
    • LinkedHashSet集合：底層是哈希表+鏈表實現的，有序集合
    • TreeSet集合：底層是二叉樹實現，通常用於排序，無序集合

• Collection單列集合共性方法：

  boolean add(E) //增長元素
  boolean contains(E) //判斷是否存在某個元素
  boolean remove(E) //刪除元素
  boolean isEmpty() //判斷集合是否爲空
  int size() //獲取大小
  Object[] toArray() //集合轉換爲數組
  void clear() //清空

集合遍歷

迭代器

• 迭代：集合元素通用獲取方式，取出元素前先判斷集合中有沒有元素，若是有就把該元素取出來，再繼續，直到取出全部元素

• 使用Iterator接口對集合進行遍歷

  • Iterator迭代器是一個接口，沒法直接使用，須要使用Iterator接口的實現類對象

  • Collection接口中有一個方法是Iterator()，返回的是Iterator接口的實現類對象

• 使用步驟：

  • 使用集合中Iterator()方法獲取迭代器實現類對象，使用Iterator接口接收（多態）

  • 使用Iterator接口中的hasNext方法判斷有沒有下一個元素

  • 使用Iterator接口中的Next方法取出集合中的下一個元素

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    //Iterator迭代器
    public class IteratorDemo01 {
        public static void main(String[] args) {
            Collection<String> collection = new ArrayList<>();
            collection.add("hello");
            collection.add("java");
            collection.add("100");
    
            //獲取迭代器
            Iterator<String> iterator = collection.iterator();
            //使用Iterator接口中的hasNext方法判斷有沒有下一個元素，返回boolean值
            while (iterator.hasNext()){
                //使用Iterator接口中的Next方法取出集合中的下一個元素
                System.out.println(iterator.next());
            }
        }
    }

加強型for循環

• 底層使用的也是迭代器，使用for循環的格式簡化

• 全部單列集合均可以使用加強for循環

• 加強for循環能夠用來遍歷集合和數組

  for(數據類型 變量名 : 集合名){ // }

  //加強for循環
  for(String s : collection){
      System.out.println(s);
  }

泛型

• 泛型是一種未知的數據類型，當不知道使用什麼數據類型的時候能夠使用泛型，如E

• 建立集合對象的時候就會肯定泛型的數據類型

  ArrayList<Student> list = new ArrayList<>();

• 定義含有泛型的類和方法：

  方法格式：修飾符 <泛型> 返回值類型 方法名(參數列表(使用泛型)){ //方法體; }

  //定義含有泛型的類
  public class GenericClassDemo<E> {
      private E name;
  
      public E getName() {
          return name;
      }
  
      public void setName(E name) {
          this.name = name;
      }
      
      //定義含有泛型的普通方法
      public <E> void method1 (E e){
          System.out.println(e);
      }
  
      //定義含有泛型的靜態方法
      public static <E> void method2(E e){
          System.out.println("靜態方法，輸入數據："+e);
      }
      
      public static void main(String[] args) {
              //建立一個泛型爲Integer的對象
              GenericClassDemo<Integer> list1 = new GenericClassDemo<>();
              list1.setName(200);
              Integer name1 = list1.getName();
              System.out.println(name1);
          	list1.method1(100);//調用方法時肯定泛型
  
              //建立一個泛型爲String的對象
              GenericClassDemo<String> list2 = new GenericClassDemo<>();
              list2.setName("小明");
              System.out.println(list2.getName());
          
          	//調用靜態方法
         	    GenericClassDemo.method2("200");
          }
  }

• 含有泛型的接口：

  //定義含有泛型的接口
  public interface GenericInterface<E> {
      public abstract void method(E e);
  }
  
  ////////////////////////////////////////
  
  /*
  方法一：實現類實現接口，並指定接口泛型，此時覆蓋重寫和調用方法時默認泛型爲指定類型
   */
  public class GenericInterfaceImpl01 implements GenericInterface<Double>{
      @Override
      public void method(Double d) {
          System.out.println("方法一覆蓋重寫，輸入數據："+d);
      }
  }
  
  /*
  方法二：接口用什麼泛型，實現類就用什麼泛型，建立對象的時候肯定泛型類型
   */
  public class GenericInterfaceImpl02<E> implements GenericInterface<E>{
      @Override
      public void method(E e) {
          System.out.println("方法二覆蓋重寫，輸入數據："+e);
      }
  }
  
  ////////////////////////////////////////
  
  public class GenericClassMain {
      public static void main(String[] args) {
          GenericInterfaceImpl01 list3 = new GenericInterfaceImpl01();
          list3.method(8.8);//泛型已經默認爲Double
          GenericInterfaceImpl02<String> list4 = new GenericInterfaceImpl02<>();
          list4.method("garen");//建立對象的時候肯定泛型類型
      }
  }

• 泛型通配符：<?> 表示，表明了任意數據類型

  • 不能建立對象使用

  • 只能做爲方法參數使用

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class GenericWildcard {
        public static void main(String[] args) {
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("garen");
            list1.add("temmo");
    
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(100);
            list2.add(200);
    
            arrayPrint(list1);
            arrayPrint(list2);
        }
    
        //定義一個方法能遍歷全部類型的ArrayList集合
        //此時不知道泛型類型，用泛型通配符
        public static void arrayPrint(ArrayList<?> list){
            Iterator<?> iterator = list.iterator();//獲取迭代器
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            
    //        for(Object o: list){
    //            System.out.println(o);
    //        }
        }
    }