java基础重要知识:集合体系

集合体系
一.单列集合(Collection):
    Collection:以单个元素形式存储
        List集合:有序,有索引,可重复
            ArrayList:数组结构,查询快,增删慢
                增加:
                    add(E e) 将指定的元素追加到此列表的末尾
                删除:
                    remove(int index):删除该集合中指定位置的元素
                    remove(Object o) :删除集合中指定的第一个出现元素
                修改:
                    set(int index, E element) :用指定的元素替换此集合中指定位置的元素 
                查看:
                    get(int index) :返回此集合中指定位置的元素 
                    (遍历取值:普通for循环,迭代器,增强for循环)
                    方式一:普通for循环
                    for(int i=0; i<list.size();i++){
                        Object obj = list.get(i);
                        System.out.println(obj);
                    }
                    方式二:迭代器
                    Iterator<Object> iterator = list.iterator();
                    while(iterator.hasNext()){
                        Object obj =iterator.next();
                        System.out.println(obj);
                    }
                    方式三:增强for循环
                    for(Object obj: list){
                        System.out.println(obj);
                    }                
            LinkedList:链表结构,增删快,查询慢
            Vector:线程安全的,同步的,效率低,被ArrayList替代
            
        Set集合:无序,无索引,不能重复
            HashSet:哈希表结构,保证元素不重复需要重写hashCode()和equals()方法
                增加:add(E e) 将指定的元素添加到此集合(如果不存在添加,如果存在就不添加)
                删除:remove(Object o) 如果存在则从该集合中删除指定的元素 
                修改:
                    if(set.contains(obj)){
                        set.remove(obj);
                        set.add(newObj);
                    }
                查看:(遍历取值:迭代器,增强for循环)
                    方式一:迭代器
                    Iterator<Object> iterator = set.iterator();
                    while(iterator.hasNext()){
                        Object obj =iterator.next();
                        System.out.println(obj);
                    }
                    方式二:增强for循环
                    for(Object obj: set){
                        System.out.println(obj);
                    }    
            LinkedHashSet:哈希表+链表结构,保证元素有序(存入的顺序和取出的顺序一致)
            TreeSet:二叉树结构,可以对元素进行排序
                    
            
二.双列集合(Map):以键值对的形式存储
    HashMap:哈希表结构,所有的键构成了set集合
        增加: 
            put(K key, V value) :将指定的值与值相关联,存入集合中 
        删除:
            remove(Object key) :从该map集合中删除指定的键对应的值(如果存在才会删除) 
            remove(Object key, Object value) :仅当指定的键和对应的值同时存在才会删除
        修改:
            重新put(相同的键,不同的值);
        查看:(遍历取值:迭代器,增强for循环)
            1)获取所有的键key:然后通过键去map集合中取值
                Set<Object> keySet = map.keySet();
                for(Object key : keySet){
                    Object value = map.get(key);
                    System.out.println(key + "=" + value);
                }
            2)获取所有的键值对entry,通过entry获取键和值
                Set<Map.Entry<Object, Object>> entrySet = map.entrySet();
                for(Map.Entry<Object, Object> entry : entrySet){
                    Object key = entry.getKey();
                    Object value = entry.getValue();
                    System.out.println(key + "=" + value);
                }
    LinkedHashMap:哈希表+链表结构,保证元素有序
    TreeMap:可以对元素进行排序
    Hashtable:不能存储null键和null值
    Properties:属性类,存储的键和值只能是字符串类型

三.迭代器(Iterator):
    HashSet<Object> set = new HashSet<>();
    //获取迭代器对象
    Iterator<Object> iterator = set.iterator();
    //判断有没有下一个元素
    while(iterator.hasNext()){
        //迭代获取元素值
        Object obj =iterator.next();
        System.out.println(obj);
    }
    
    增强for循环:底层的实现就是通过迭代器
    for(Object obj: set){
        System.out.println(obj);
    }    
    注意:
        使用迭代器或者增强for循环只能用于取值,不能对集合中的元素进行增删改

四.比较器(Comparable和 Comparator)
    第一种:
        Comparable:对实现Comparable接口的类进行整体排序,需要重写compareTo()方法
        public class Student implements Comparable<Student>{
            @Override
            public int compareTo(Student o) {
                //return this.getAge() - o.getAge();  //按照年龄升序排序
                return o.getAge() - this.getAge();   //按照年龄降序排序
            }
        }
        
        public static void main(String[] args) {
            Collections.sort(list);    
        }
            
    
    第二种:Comparator:对指定的某个对象进行整体排序,需要重写compare()方法
        public static void main(String[] args) {
            Collections.sort(list, new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    //return o1.getAge() - o2.getAge();  //按照年龄升序排序
                    return o2.getAge() - o1.getAge();  //按照年龄降序排序
                }
            });
        }
        
        
五.工具类(Collections)
    addAll(Collection<T> c, T... elements) :将所有指定的元素添加到指定的集合中
    sort(List<T> list) :对指定的List集合进行排序,需要注意存储的数据类型必须实现Comparable接口,重写compareTo()方法,指定排序规则
    sort(List<T> list, Comparator<T> c) 根据指定的比较器对指定的集合进行排序, 需要重写compare()方法,指定排序规则
    shuffle(List<T> list) :使用默认的规则随机排列指定的集合,打乱集合中的顺序