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