Java_day10

忘是亡心i 2021-10-18 08:26 193阅读 0赞

## 十：集合 ##

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 —— 泛型。