CoreJava学习第十二课-集合

一：集合

1.什么是集合

一类特殊的对象: 用于保存多个对象的对象.

二：Collection

·特点:Collection 接口的特点是元素是 Object。遇到基本类型数据，需要转换为包装类对象
·Collection 没有实现类，它的子接口有实现类，所以Collection元素必须是引用类型.
    
常见方法：
boolean add(E e)            添加元素到集合中。 
boolean remove(Object o)     从集合中移除一个对象 
void clear()                移除此 collection 中的所有元素 
int size()                  返回此 collection 中的元素数。
Object[] toArray()           返回包含此 collection 中所有元素的数组。
boolean contains(Object o)   判断集合是否包含特定的元素
​
遍历
    1. 迭代器遍历  Collection   可以通过迭代器,删除集合中的元素
    2. for-each    Collection   JDK5
    3. forEach() 方法 需要实现java.util.function.Consumer接口  JDK8

三：List

特点:元素按顺序（有下标）存储，内容可以重复
​
void add(int index, E element)  指定位置插入元素
E get(int index) 获取指定下标元素
E remove(int index) 根据下标移除元素
E set(int index, E element) 更新指定下标元素
int indexOf(Object o) 返回元素首次出现的下标     
List<E> subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1处所有元素组成的子集合
​
遍历:
 1.下标遍历    可遍历List
    static void print1(List list){
        for(int i = 0 ; i < list.size() ; i++){
            Object o = list.get(i);
            String s = (String)o;
            System.out.println(s.toUpperCase());
        }
    }
 2.迭代器遍历  可遍历Collection   把集合中的元素拿到迭代器中，可以通过迭代器,删除集合中的元素
    static void print2(Collection con){
        Iterator it = con.iterator(); //迭代器
        while(it.hasNext()){
            Object o = it.next();
            String s = (String)o;
            if ("Liucy".equals(s)){
                it.remove();
                continue;
            }
            System.out.println(s.toUpperCase());
        }
    }
 3. for-each    可遍历Collection   From JDK5(底层是迭代器遍历) 【可遍历数组和集合】
    static void print3(Collection con){
        for(Object o : con){
            String s = (String)o;
            if ("Liucy".equals(s)){
                con.remove(s);
                continue;
            }
            System.out.println(s.toUpperCase());
        }
    }
 4. forEach() 方法 需要实现java.util.function.Consumer接口 JDK8
    static void print4(Collection con){
        con.forEach(new Consumer(){//接口回调，匿名内部类实现
            public void accept(Object o){
                String s = (String)o;
                System.out.println(s.toUpperCase());
            }
        });
    }
                                   
常见实现类:
    1. ArrayList    JDK1.2  数组实现    查询快 增删慢 线程不安全   轻量级实现   效率高         
    2. LinkedList   JDK1.2  链表实现    查询慢 增删快     
    3. Vector       JDK1.0  数组实现    查询快 增删慢 线程安全    重量级实现   效率低        

四:泛型

泛型:编译期语法，给编译器用的。
    参数化类型   模板编程    
    定义类型时使用类型变量代替, 使用泛型类型时,必须传入确切类型. 泛型默认为Object类型
    利用泛型技术可以构建元素类型安全的集合!!!

五：Set

特点:元素内容不可以重复    无序无下标
​
常见方法:全部从父接口中继承而来(没有修改和查询方法，因为没下标)
    boolean add(E e) 添加元素到集合中。 如果此 set 已经包含该元素，则该调用不改变此 set 并返回 false。
    boolean remove(Object o)  从集合中移除一个对象
    int size() 返回此 collection 中的元素数。
    Object[] toArray() 返回包含此 collection 中所有元素的数组。 
    void clear() 移除此 collection 中的所有元素 
    boolean contains(Object o) 判断集合是否包含特定的元素
 
常见实现类:
    1.HashSet[重点]   JDK1.2      用散列表实现  
       添加元素的过程:
        a） 元素调用hashCode()获取哈希码,然后%length获取下标index
        b）如果index处之前没有保存元素,则直接添加；
           如果index处已经存有元素，则使用equals和已经存在的元素（1-n个，有几个元素，调用几次equals方             法）比较内容是否相同,如果相同,添加失败，不同,则使用链表和之前的元素连起来
        
        自定义类型为保证元素内容不重复,必须重写hashCode和equals
        hashCode重写要求:
            a 内容相同的对象必须返回相同哈希码
            b 为保证效率，内容不同的对象极可能返回不同的哈希码
        public int hashCode(){
            //哈希码的计算方式:由对象的属性内容计算而来
            //基本类型属性 --> int : byte short char int 直接赋值 long float double 强制赋值                                        boolean进行判断然后赋值
            //引用类型属性 --> int : 调用hashCode() 
            int result = 0;
            if(name != null) result += name.hashCode();
            result += age;
            return result;
        
    //调用父类的hashCode值，但是父类的是根据地址转换而来，所以不同的对象返回值不一样，不可用于hashCode()
            //return super.hashCode();
        }
    2. LinkedHashSet    JDK1.2      用散列表+链表实现
        可以保证元素的遍历顺序和添加顺序一致!!!
        自定义类型为保证元素内容不重复,必须重写hashCode和equals
        
    3. TreeSet          JDK1.2      用红黑树实现  
        可以根据元素内容进行自动的升序排列
        自定义类型为保证元素内容不重复,必须实现Comparable接口,提供compareTo方法实现

六：Map

1.特点:元素由key(键)和value(值),其中键不能够重复,值可以重复  
2.常见方法:
    V put(K key, V value) 将指定的键值对数据放入map集合中,
        map之前没有包含相同key的键值对,则直接添加;
        如果已经包含相同的key的键值对,则新value替换旧value,并将旧值返回.
    V remove(Object key) 从map中根据key移出整个键值对,返回被移出的键值对的值
    V get(Object key)  根据key查询对应的value
    int size() 返回此map中的键-值映射关系数。
    boolean containsKey(Object key) 判断map中是否包含给定的key，则返回 true。 
    boolean containsValue(Object value) map中是否包含给定的value，则返回 true。  
3.Map的遍历方式:
    ① 键遍历[重点]
            //获取map中所有key组成的Set集合
            Set<String> set = map.keySet();
            //遍历Set集合,获取每一个key
            for(String key:set){
                System.out.println(key+"-->"+map.get(key));
            }
    ② 值遍历
            //获取map中所有value组成的Collection集合
            Collection<String> c = map.values();
            //遍历Collection集合,获取每一个value
            for(String value:c){
                System.out.println(value);
            }
    ③ 键值对遍历
            //将key和value封装为一个键值对对象,获取map中所有键值对(Map.Entry)对象组成的Set集合
            Set< Map.Entry<String,String> > set = map.entrySet();
            //遍历Set集合,获取的元素为一个键值对对象
            for(Map.Entry<String,String> e:set){
                //调用方法,获取键值对对象包含的key和value
                String key = e.getKey();
                String value = e.getValue();
                System.out.println(key+"-->"+value);
            }
    备注：
        在 Map 接口中，有一个方法叫做 entrySet。这个方法返回一个 Set 集合，这个集合中装的元素的类型是         Map.Entry 类型。
        Map.Entry 是 Map 接口的一个内部接口。这个接口封装了 Map 中的一个键值对。在这个接口中，主要定义了        这样几个方法：
          getKey() : 获得该键值对中的键
          getValue(): 获得该键值对中的值
          setValue()：修改键值对中的值
4.实现类:                       底层实现       特点
    ① HashMap           JDK1.2  散列表         线程不安全   轻量级实现   允许null键值对       
    ② LinkedHashMap     JDK1.2  散列表+链表     保证键值对的遍历顺序和添加顺序一致!!!         
    ③ TreeMap           JDK1.2  红黑树         可以根据key的内容对键值对进行自动的升序排列         
    ④ Hashtable         JDK1.0  散列表         线程安全 重量级实现  不允许null键值对  
    ⑤ Properties        JDK1.0  Hashtable子类   键和值都是String. 专门用于读取配置文件信息