Java_day10

十：集合

10.1:数组的升级版.--->集合  =  数组/其他内存结构  +  可变长度  +  一堆方法  +  简单操作。
10.2:集合位于java.util包中
     注意：集合只能存放引用数据类型的数据。

10.3:集合分类 
   10.3.1: Set : 无序, 对象不能重复
   10.3.2: List: 有序(放入的先后的次序), 对象可以重复
   10.3.3: Map :  集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。(Key - Value)
    注: 可能存在 value相同，key不同的情况

10.4:集合的从属关系
    _______________________________________________________________________________
    |                                                           实现类  
    |                                                |------>HashSet                             
    |                           |------>Set----|------>TreeSet                                  
    |                           |                    |------>LinkedHashSet    自己了解   
    |                           |     子接口                                                                     
    |    Collection------|                    |------>ArrayList                          
    |         父接口       |------>List----|------>Vector       自己了解         
    |                                                |------>LinkedList 自己了解              
    |_______________________________________________________________________________
    |                                                  
    |                                                  |------>HashMap                        
    |    Map--------------------->Map----|------>TreeMap                          
    |    父接口                    子接口    |------>Hashtable  自己了解        
    |                                                             实现类
    |_______________________________________________________________________________    

10.5:涉及集合的基本操作
        10.5.1 :  向集合中添加数据.
        10.5.2 :  从集合中取数据
        10.5.3 :  获得集合长度
        10.5.4 :  遍历集合
        10.5.5 : 清空集合
        10.5.6 : 删除集合中某一个数据
        

10.6 : Collection接口
         Collection接口 声明了 Set接口 和List接口 的通用方法.
        10.6.1 : boolean add(Object o)    向集合中添加数据
        10.6.2 : Iterator iterator();            获取集合的迭代器(迭代器用来遍历集合);
        10.6.3 : int size();                        返回集合中元素的数目；
        10.6.4 : void clear()                     删除集合中的所有对象引用，即不再持有这些对象的引用；
        10.6.5 : contains(Obj)                 判断在集合中是否持有特定对象的引用；
        10.6.6 : isEmpty()                       判断集合是否为空；
        10.6.7 : remove(Obj)                  从集合中删除一个对象的引用；
        10.6.8 : Object[] toArray()          返回一个数组，该数组包含集合中的所有元素；
    
10.7 : Iterator接口(用于遍历Collection集合):迭代器。
        主要方法:
        hasNext()    是否有下一个元素        
        next()        获取下一个元素
        remove()    删除当前元素
            测试练习:利用上诉知识点，创建集合，向集合中5个添加数据,然后遍历集合,删除第3个数据。

10.8 : Set : 集合中的对象无序、不能重复;--->注意：是通过equals方法比较对象是否相同。
        10.8.1 : HashSet:按照哈希算法来存取集合中的对象，存取速度比较快;
        10.8.2 : TreeSet:实现SortedSet接口，具有***排序功能***；
        10.8.3 : LinkedHashSet:HashSet子类，不仅实现Hash算法，还实现链表数据结构，链表数据结构能提高插入和删除元素的性能；
        10.8.4 : 集合操作实例
            Set set = new HashSet();
            set.add("小明");
            set.add("小红");
            set.add("小红");
            set.add("小红1");
            set.remove("小红");    
            set.size();
            Interator it = set.iterator();
            while(it.hasNext()){
                String name = (String)(it.next());//小明 小红
            }
        10.8.5 : HashSet : 先 hashCode() &&  后 equals() 同时满足这两个才被hashSet认为是同一个对象。

        按照哈希算法来存取集合中的对象，存取速度比较快。当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获得哈希码，然后根据这个哈希码进一步计算出对象在集合中的存放位置。
            ---> 两个对象的值相同(equals()比较相同) ,那么这两个对象的hashCode一定相同。
            ---> 两个对象的hashCode相同，那么这两个对象的值不一定相同。
        测试练习:
            1,建立一个类Customer，给两个属性.name,age。
            2,重写equals()方法,如果name相同age相同就返回true,else return false;
            3,创建 HashSet集合,添加两个Customer对象(name,age相同);
            4,打印集合长度--->考虑为啥 是  2 ?
            5,从写hashCode方法(), return age;
            6,再次打印 3 集合--->为何长度是1 ?

        10.8.6 : TreeSet 可以按照规定排序的集合
                     1.自然排序(默认) : 实现了Comparable接口 ,重写  compareTo(Object o);
                              使用情景: 1,treeSet要排序的是类对象,这个类必须要实现Comparable, 重写compareTo(Object o)方法。
                              效果       ：在使用treeSet 添加该类对象的时候 就会自动调用compareTo()方法进行排序
                                                treeSet总是把compareTo()比较得出较小的 放到集合前端。
                     -----------------------------------------------------------------------------------------------------------------
                     JDK类库中实现了Comparable接口的一些类的排序方式： 

                     Byte, Short, Integer, Long, Double, Float     :         按数字大小排序；
                     Character                                                     :         按字符的Unicode值的数字大小排序；
                     String                                                           :         按字符串中字符的Unicode值排序；
                     -----------------------------------------------------------------------------------------------------------------

                  2 .客户端排序:创建比较器--->实现java.util.Comparator接口,重写compare(Object x, Object y)方法。
                      使用:
                          1,写一个比较器(类),实现Comparator接口,重写compare()方法。
                          2,创建该比较器的实例对象。
                          3,将比较器的对象 通过TreeSet的构造器交给TreeSet使用 : eg: new TreeSet(comparator);
                     效果:
                         1,利用比较器创建的TreeSet集合在使用add方法添加数据的时候就会调用compart方法排序.
                         2,treeSet 将compart()返回较小的放到前面。
            
            测试练习:Student类对象在TreeSet集合中按年纪大小排序。
            1,创建Student类,name属性,age属性
            2,写Test.java 写main方法, 在main方法中创建TreeSet集合。
            3,TreeSet集合添加4个Student对象
            4,输出,需要按照年纪大小排序, 大---->小
            5,再写一个TreeSet排序,按照年纪小大排序, 小---->大
            注意：1234,使用自然排序, 5,使用客户端(比较器)排序。10.9 List : 线性方式(数组)存储.
        10.9.1:ArrayList : 代表长度可变的数组。允许对元素进行快速的随机访问，但是向ArrayList中插入与删除元素的速度较慢；
        10.9.2:LinkedList: 在实现中采用链表结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度则相对较慢。
        10.9.3:Vector    : 是线程安全的集合
        10.9.4:集合操作实例
            注意：在使用List接口的时候注意导包.需要导入的是java.util.List包。

            List list =new ArrayList();
            list.add("小明");
            list.add("小红");
            list.add("小明");
            list.add("小红");

            list.size();
            list.remove(index);
            list.remove(object);
            
            Iterator it = list.iterator();
            while(it.hashNext()){
                String name = (String)(it.next());
            }

            list.get(index);

            for(int i = 0;i<list.size();i++){
                String name = list.get(i);
            }

10.10: forEach 遍历 Collection集合--> 加强for循环
        for(String s : set){
            syso(s);
        }
10.11:Map  :  1,把键对象和值对象进行映射的集合，它的每一个元素都包含一对键对象和值对象。
                      2,向Map集合中加入元素时,必须提供一对键对象和值对象. map.put(key,value);
                      3,从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。value = map.get(key);
                      4,Map集合中的键对象不允许重复,如果有多个相同的key那么上一次的值会被覆盖。
            
                      HashMap  :是线程不安全的集合。
                      HashTable:是线程安全的集合。
                      TreeMap  :可以进行排序(对key进行排序)
    
                      HashMap  :  判断key是否相同是通过 hashCode &&  equals方法来判断。
                      TreeMap  :   实现了SortedMap接口，能对 键对象(key) 进行排序。
                      自然排序(默认) : 实现了Comparable接口 ,重写  compareTo(Object o);    
                      客户端排序      : 创建比较器--->实现java.util.Comparator接口,重写compare(Object x, Object y)方法。构造器传入TreeMap Eg:new TreeMap(比较器);
        
           5:map的遍历

              1,map.entrySet()+forEach版本
                   Set entrySet = map.entrySet();
                   for(Entry a: entrySet){
                       System.out.println(a.getKey()+"--------"+a.getValue());
                   }
             2, keySet() + 迭代器
                 Set keySet = map.keySet();
                 Iterator itKey = keySet.iterator();
                 while(itKey.hasNext()){
                      Object key = itKey.next();
                      System.out.println(key + "---"+map.get(key));
                 }
             3, keySet() + forEach
                Set keySet = map.keySet();
                for(Object key: keySet){
                    System.out.println(key+"----"+map.get(key));
                }

---------------------------------------------------------------------------------------------------------------------------------- 

十一：泛型

 用于约束代码.用于灵活代码.

11.1: 集合加泛型:约束该集合只能添加泛型类型的数据.编译时泛型
        11.1.1 : List集合
           语法：List<String> list = new ArrayList<String>();--->生成的.class文件中:List l = new ArrayList();
                 表示该集合list只能添加String类型的数据。发生在编译期间.
             list.add("abc");  √
             list.add(123);    ×
        
        11.1.2 : Set集合
           语法: Set<Book> books = new HashSet<Book>();
             表示该set集合只能添加book类型的数据。不然编译通不过。
        
        11.1.3 : Map集合
           语法: Map<String,String> map = new HashMap<String,String>();
                 表示该map集合只能保持key为String,value为String的数据对。
        
        注意 : 集合中泛型只能是类类型.
11.2: 类名后加泛型: 代码更加灵活.
        11.2.1:语法：
            public  class TestBean<T>  {
                public  T show(T t){}
            }
        11.2.2:使用：
            TestBean<Integer> a  = new TestBean<Integer>();
            Integer value = a.show(123);

            TestBean<String> a  = new TestBean<String>();
            String value = a.show("acb");
        11.2.3: 类名后加两/多个泛型
            public  class TestBean<T,K,V>  {
                Map<K,V> map = new HashMap<K,V>();
                public V show(K key){
                    return map.get(key);
                }
            }
            TestBean<Boolean,String,Integer> t = new TestBean<Boolean,String,Integer>();
            Integer a = t.show("tom");

11.3：泛型解决的问题
          11.3.1:泛型可以使类中的属性的类型可以由外部决定
          11.3.2:不需要强制类型转换
          11.3.3:泛型可以在*编译期间*进行类型检查
          11.3.4:提供了类型安全的操作

    附：    K —— 键，比如映射的键。
               V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。
               E —— 异常类。
               T —— 泛型。