12 | JAVASE高级应用-集合

1 JAVASE高级应用

• 集合泛型枚举
• 使用类
• 流
• XML
• 反射
• 线程
• 网络编程

2 知识点的分级

1. 掌握：不光要知道怎么去用，而且还必须能够灵活的运用于实际生
2. 理解：知道这个知识点的运用方式，但是不必深究其原理
3. 了解：了解这个知识点，在实际生产中极少运用，属于是拓宽知识面的内容

3 源码

1. 初级：3年工作经验之内的通许，一般来说是重点在运用阶段，大致了解一些原理性的概念
2. 中级：3-5年工作经验的，可以适当阅读一些通用性（SE）的源码
3. 高级：5年以上，必然要选择方向，然后在该领域当中选择一个方向去深入研究
4. 建议：人不可能面面俱到，不要想着一口吃个胖子

4 集合

4.1 List

有序不唯一的集合

• 所在包：java.util.*
• ArrayList

1. 本质是一个数组；
2. 不适合频繁增减元素，比如一个数组如果有1000W个元素，我如果需要增加一个元素，那么就意味着你需要先创建1000W零1个元素先创建出来，然后复制，这个才算是拓展成功；
3. 擅长随机访问；

• LinkedList

1. 是一个双向链表 ；
2. 适合于增减元素操作 ；
3. 不擅长随机访问；
4. 使用LinkedList,因为该实现类，实现了很多list接口中没有的方法，所以通常使用该类本身来声明。

4.2 Set

无序 ，唯一

• 唯一是指equals相同
• 遍历 set

1. 获取迭代器
2. 增强for循环遍历

• HashSet使用的是HashMap的key

4.3 Map

键值对

• key:具有唯一性，且无序

1. 如果再次放入某个key相同的值，那么value覆盖原来的值
2. key可以是null,但是null值也是一个唯一存在的key

• value:可以重复，可以是任意值
• 获取所有key和所有map

4.4 Hash、set和map

• hashMap

1. Entry:是一个单向链表
2. TreeEntry：包含了hash的双向链
3. 红黑树

• Hash

1. hash可以重写
2. native默认情况下，hash是本地调用提供的，比如调用本地C
3. 集合中的hashCode是被重写过的，默认情况下是地址，重写过的，都不是了

4.5 泛型

目的：统一集合当中的元素
对于基本数据类型：泛型只能使用包装类来定义基本数据类型

4.5.1 实例1

import java.util.ArrayList;  
import java.util.List;  

public class Test1 {  
	public static  void  main(String[] args) {  
      List l1=new ArrayList();  
      l1.add("a");  
      l1.add("b");  
      l1.add("c");  
      List l2=new ArrayList();  
      l2.add("a");  
      l2.add("b");  
      l2.add("c");  
        
      // 1、判断是否包含某个元素:返回的前提是equals是否相等  
      System.out.println(l1.contains("a"));  
      // 内容包含  
      System.out.println(l1.containsAll(l2)); //只要元素包含  
      // 添加  
      l1.addAll(l2);  
      l1.addAll(l2);  
      l1.addAll(l2);  
      System.out.println(l1.toArray());  
      // 3、获取元素的游标，从左到右，第一次遇到的  
     // or -1 if  there is no such index  
      System.out.println(l1.indexOf("a"));   
     // 从右到左，第一次遇到那个  
      System.out.println(l1.lastIndexOf("c"));   
     // 截取：从fromIndex开始，到toIndex游标之前一位  
      List l3 = l1.subList(0,2);   
      System.out.println(l3);   
    }  
}

4.5.2 实例2

public class Test2 {  
    public static  void  main(String[] args) {  
         LinkedList list =new LinkedList();  
         list.addFirst("");  
         list.addLast("");  
         list.getFirst();  
         list.getLast();  
         list.removeFirst();  
         list.removeLast();  
    }  
}  

4.5.3 实例3

public class Test3 {  
    public static  void  main(String[] args) {  
       //无序且唯一  
       //基本数据类型，引用数据类型  
       Set s=new HashSet();  
      s.add("a");  
       s.add("b");  
       s.add("c");  
      System.out.println(s.size());  
       System.out.println();  
         
       // 获取迭代器  
       Iterator is =s.iterator();  
      while(is.hasNext())//判断是否有下一个，如果有返回true，没有则返回false  
       {  
           Object obj= is.next();  
           System.out.println(obj);  
       }    
       // 增强for循环  
       for(Object obj : s){  
           System.out.println(obj);  
       }  
    }  
}  

4.5.4 实例4

public class Test4 {  
    public static  void  main(String[] args) {  
      //自定义游标  
      Map m=new HashMap();  
      //添加元素  key具有唯一性，且无序  
      m.put("K1","V1");  
      m.put("K1", "value1");  
      // 可以为null,null值也是唯一存在的key  
      m.put(null,null);  
      System.out.println(m.get("K1"));  
      m.put(null,"nullStr");  
      System.out.println(m.get(null));  
      //2、获取所有的key  
      Set keys=m.keySet();  
      System.out.println(Arrays.toString(keys.toArray()));  
      // 3、获取所有的value  
      Collection cons  = m.values();  
      System.out.println(Arrays.toString(cons.toArray()));  
    }  
}  

4.5.5 实例5

public class Test5 {  
    public static  void  main(String[] args) {  
        System.out.println("a".hashCode());  
         A a= new A();  
         System.out.println(a.hashCode());  
         System.out.println(Objects.hash(1));//基本数据类型的hash  
         //相同对象的hash，必然一样  
         A a1= new A();  
         A a2 = a1;  
         System.out.println(a1.hashCode());  
         System.out.println(a2.hashCode());  
         //不同对象的hash，必然不一样  
         System.out.println(Objects.hash(new A()));  
         System.out.println(Objects.hash(new A()));  
           
         //set只要元素一致,hash就一致  
         System.out.println(a1.toString());          
         Set s1= new HashSet();  
         s1.add("a");  
         s1.add("b");  
         s1.add("c");  
         s1.add("d");  
         Set s2= new HashSet();  
         s2.add("a");  
         s2.add("b");  
         s2.add("c");  
         s2.add("d");     
         System.out.println(s1.hashCode());  
         System.out.println(s2.hashCode());  
         //map的keyhe value相同，那么他们的hash一样  
         Map m1=new HashMap();  
         m1.put("K1","value1");  
         m1.put("K2","value1");  
         m1.put("K3","value1");  
         Map m2=new HashMap();  
         m2.put("K1","value1");  
         m2.put("K2","value1");  
         m2.put("K3","value1");    
           
        LinkedList l1= new LinkedList();  
        l1.add("a");  
        l1.add("b");  
        l1.add("c");  
        LinkedList l2= new LinkedList();  
        l2.add("a");  
        l2.add("b");  
        l2.add("c");   
        System.out.println(l1.hashCode());  
        System.out.println(l2.hashCode());  
        //Arraylist  
        List la1=new ArrayList();  
        la1.add("a");  
        la1.add("b");  
        la1.add("c");       
        List la2=new ArrayList();  
        la2.add("a");  
        la2.add("b");  
        la2.add("c");   
        System.out.println(la1.hashCode());  
        System.out.println(la2.hashCode());            
    }  
}  
class A {  
}

4.5.6 实例6

public class Test6 {  
    public static  void  main(String[] args) {  
      List<String> l=new ArrayList();  
      l.add("ybb1");  
      l.add("ybb2");  
      l.add("ybb3");  
      l.add("ybb4");      
      for(String str : l) {  
           System.out.println();  
      }  
      Set<String>  s=new HashSet<String>();  
      Map<String,Object>  m=new  HashMap<String,Object>();      
      Set<Double>  s1=new HashSet<Double>();      
      }  
}