java學習第12天1.2

總結

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import com.qianfeng.demo7.Student;

/**
 * List
 *   一、list集合中能夠放置重複元素
 *  ArrayList
 *   一、底層是一個默認長度爲10的數組， list.size超10個以後，
 *    會動態(size * 1.5 + 1)拓展底層那個數組
 *  二、若是系統須要頻繁的查詢元素，獲取元素使用ArrayList 進行元素存儲
 *  三、若是系統須要頻繁的添加 刪除 建議使用LinkedList
 *  四、ArrayList 是一個線程不安全的(不一樣步) 集合
 *  LinkedList
 *   一、底層是一個雙向鏈表
 *   二、若是系統須要頻繁的添加 刪除使用LinkedList
 *   三、若是系統須要頻繁的查詢元素，建議使用 ArrayList
 *   四、LinkedList 是一個線程不安全的(不一樣步) 集合
 *  Vector
 *   一、老版本的Arraylist
 *   二、跟ArrayList是同樣的，惟一區別是vector 線程安全的，Arraylist線程不安全的
 *
 *  運用場景：
 *   由Arraylist 跟 linkedlist特證決定：
 *   一、頻繁的查詢元素，用Arraylist     從數據庫 獲取數據，加工成 Arraylist
 *   二、頻繁的添加 刪除 ,用linkedlist
 *
 * set
 *   一、不能放置重複元素
 *  HashSet
 *   一、底層是一個Map,由於map的key要求是惟一，因此這造就HashSet不能重複放置元素
 *   注意點：自定義類必須重寫  hashcode 跟 equals方法，若是不重寫，只能經過==進行判斷。
 *   二、獲取值的時候，經過查hash表，而後對比值
 *
 *  TreeSet
 *   一、特色跟HashSet 同樣
 *   二、底層實現一個紅黑樹結構存儲方式，因此它帶排序功能
 *    注意：添加進去的元素，必須得可排序的 怎麼實現呢？
 *     方法：一、自定義的類實現 Comparable 接口，進而重寫 CompareTo方法
 *        二、 new TreeSet 本身添加一個比較器(Comparator 接口，實現compare方法)
 *  使用場景：
 *   數據添加的數據須要不重複  HashSet TreeSet  通常選HashSet，可是
 *  若是數據還須要排序時選用TreeSet
 *
 * 總結：
 *   若是數據關注是否重複，選用set，反之選用List
 */
public class CollectionsDemo {
 
 
 public static void main(String[] args) {
  ArrayList<String> list = new ArrayList<String>();
  //將一個線程不安全的list 轉換 爲線程安全的List，返回是一個新的list
  List<String> list2 = Collections.synchronizedList(list);
  System.out.println(list == list2);
  
  
  ArrayList<String> list3 = new ArrayList<String>();
  list3.add("1");
  list3.add("5");
  list3.add("3");
  list3.add("9");
  System.out.println(list3);
  //Collections.sort(list3);   //經過天然順序進行比較
  System.out.println(list3);
  
  
  Collections.sort(list3, new Comparator<String>() {

   @Override
   public int compare(String o1, String o2) {
    return -o1.compareTo(o2);
   }
  });
  System.out.println(list3);
  
  
  //若是是list 集合的元素是自定義的類  時，若是要Collections.sort排序必須實現Comparable
  //或者，使用Comparator Collections.sort(list3, new Comparator<String>()
  /*ArrayList list4 = new  ArrayList(); 
  list4.add(new Student(1, "1", 1));
  list4.add(new Student(2, "2", 2));
  list4.add(new Student(3, "3", 3));
  list4.add(new Student(4, "4", 4));
  Collections.sort(list4);*/
  
  
  System.out.println("---------------");
  
  ArrayList<ArrayList<String>> outer =
     new ArrayList<ArrayList<String>>();
  ArrayList<String> inner = null;
  for(int i = 0; i < 5; i++){
   inner = new ArrayList<String>();
   inner.add(i+"a");
   inner.add(i+"b");
   inner.add(i+"c");
   outer.add(inner);
  }
  for(ArrayList<String> l : outer){
   System.out.println(l);
  }
  
  System.out.println(outer);
  
  //這個不行的緣由：
  // public static <T extends Comparable<? super T>> void sort(List<T> list)
  //方法定義中泛型是 <T extends Comparable<? super T>> 表示T
  //必須是Comparable<? super T> 的子類，而咱們定義的student沒有實現這個接口
  //因此沒法調用，這個就是泛型接口的限制功能
  
  ArrayList<Student> list4 = new  ArrayList<Student>(); 
  list4.add(new Student(1, "1", 1));
  list4.add(new Student(2, "2", 2));
  list4.add(new Student(3, "3", 3));
  list4.add(new Student(4, "4", 4));
  //Collections.sort(list4);
  
  Collections.sort(list4, new Comparator<Student>() {
   @Override
   public int compare(Student o1, Student o2) {
    return 0;
   }
  });
  
  
 }
}