Java集合Collection

集合

集合框架

1. 集合、数组都是对多个数据进行存储操作的结构，简称java容器
   说明：此时的存储主要指的是内存方面的存储，不涉及到持久化的存储
2. 数组在存储多个数据方面的特点：
   数组一旦定义好，元素的类型随之确定，只能操作指定类型的数据
   一旦初始化以后，长度就确定了
3. 数组在存储多个数据方面相对于集合的缺点：
   一旦初始化以后，长度就不可以修改
   数组提供的方法非常有限，对于添加，删除，插入数据等操作非常不便，效率不高
   获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
   数组储存数据的特点：有序、可重复。对于无序，不可重复的需求不能满足

    * 二、集合框架：
    *       Collection接口：单例集合，用来储存一个一个的对象
    *           list接口：储存有序的，可重复的数据
    *               ArrayList、LinkedList、Vector
    *           Set接口：储存无序的，不可重复的数据
    *               HashSet、LinkedHashSet、TreeSet
    *       Map接口：双列集合，用来储存一对(key — value)一对的数据
    *               HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
    *

Collection接口

 * 一、Collection接口中的方法和使用
 *       add(Object e)：将元素e添加到集合collection中
 *       size()：获取添加的元素个数
 *       addAll(Collection collection1)：将collection1集合中的元素添加到当前的集合中
 *       isEmpty()：判断当前集合是否为空
 *       clear()：清空集合元素

   public static void main(String[] args) {
        Collection collection = new ArrayList();

        //add(Object e)：将元素e添加到集合collection中
        collection.add("AA");
        collection.add(123);
        collection.add(false);
        collection.add(new Object());

        //size()：获取添加的元素个数
        System.out.println(collection.size()); //3

        //addAll(Collection collection1)：将collection1集合中的元素添加到当前的集合中
        Collection collection1 = new ArrayList();
        collection1.add(456);
        collection.addAll(collection1);

        System.out.println(collection.size()); //4
        System.out.println(collection);

        //isEmpty()：判断当前集合是否为空
        System.out.println(collection.isEmpty()); //false

        //clear()：清空集合元素
        collection.clear();
    }
        @Test
    public void Method1(){
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("jack",18));

        //1.contains(Object obj)：判断当前集合中是否包含obj，判断时会调用obj对象所在类的equals()
        boolean contains = collection.contains(123);
        System.out.println(contains); //true
        System.out.println(collection.contains(new Person("jack",18))); //重写Person的equals()方法可以使false>true


        //2.containsAll(Collection coll)：判断形参coll中的所有元素是否都存在于当前集合中
        Collection collection1 = Arrays.asList("AA", 123);
        System.out.println(collection.containsAll(collection1)); //true
    }

    @Test
    public void Method2(){
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("jack",18));

        //3.remove(Object obj)：从当前集合中移除obj元素。
        collection.remove(123);

        //4.removeAll(Collection coll)：collection中移除两个集合中共有的元素
        Collection collection1 = Arrays.asList("AA",123);
        collection.removeAll(collection1);
        System.out.println(collection);

        //5.retainAll(Collection coll)：collection保留两个集合中的交集部分

        //6.equals(Object obj)：要返回true，需要当前集合和形参集合的元素相同，（ArrayList会考虑顺序）

        //7.hashCode()：返回对象的哈希值
        System.out.println(collection.hashCode());

        //8.toArray()：集合转换为数组
        Object[] o = collection.toArray();

    }

List接口

list接口：储存有序的，可重复的数据

     * ArrayList：List接口的主要实现类，效率高，线程不安全，底层使用Object[] elementData储存
     * LinkedList：对于频繁的插入、删除操作，使用效率比ArrayList高，底层使用双向链表储存
     * Vector：少用，效率低，线程安全，底层使用Object[] elementData储存

* List中的方法
* 增：add(int index, Object o)：在index位置插入o元素
* Boolean addAll(int index, Collection c)：从index位置开始将c中的所有元素添加进来
* 查：Object get(int index)：获取指定index位置的元素
* int indexOf(Object obj)：返回obj在集合中首次出现的位置
* int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
* 删：Object remove(int index)：移除指定index位置的元素，并返回次元素
* 改：Object set(int index, Object o)：设置指定index位置的元素为o
* list subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合

    public void test(){
        ArrayList arrayList = new ArrayList();
        arrayList.add("AA");
        arrayList.add(123);

        arrayList.add(1,"123");
        System.out.println(arrayList);//[AA, 123, 123]

        Collection collection = Arrays.asList(1,2,3);
        arrayList.addAll(3,collection);
        System.out.println(arrayList);//[AA, 123, 123, 1, 2, 3]

        System.out.println(arrayList.get(2)); //123
    }

 * ArrayList的源码分析：
 *      jdk1.7：ArrayList list = new ArrayList(); 底层创建了长度是10的Object[]数组elementData
 *          list.add(123); elementData[0] = new Integer(123); 如果此时添加导致底层elementData数组容量不够，则扩容
 *          默认情况下扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中
 *          结论：建议开发中使用带参构造器：ArrayList list = new ArrayList(int capacity)
 *      jdk1.8：ArrayList list = new ArrayList(); 底层Object[] elementData初始化为{}，并没有创建数组
 *          list.add(123); 第一次调用add()时底层才创建长度为10的数组，并将123添加到elementData中
 *      结论：jdk1.7中的ArrayList的对象创建相当于单例饿汉式，jdk1.8相当于懒汉式，延迟了数组的创建，节省内存

Set接口

   * Set接口：储存无序的，不可重复的数据
*       HashSet：作为Set的主要实现类，线程不安全，可以储存null值
*          LinkedHashSet：作为HashSet子类，可以按照添加顺序遍历
*
*       向TreeSet中添加的数据，要求是相同类的对象
*               两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
*
* 无序性：不等于随机性。数据根据哈希值添加
*
* 不重复性：保证添加元素按照equals()方法判断时，不能返回true，相同元素只能添加一个
* 1.Set接口中没有额外定义新的方法，使用的Collection中的方法
* 2.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
*       重写的hashCode()和equals()尽可能保持一致性

    public void test(){
        Set set = new HashSet();
        set.add(123);
        set.add("lzy");
        set.add(true);
        set.add(new Person());
        System.out.println(set);
    }

    @Test
    public void test2(){
        TreeSet treeSet = new TreeSet();
        treeSet.add(12);
        treeSet.add(234);
        treeSet.add(2378);
        treeSet.add(568);
        treeSet.add(4521);
        System.out.println(treeSet);
    }

Iterator接口

* 集合元素的遍历操作，使用迭代器Iterator接口
* 1.内部方法：hasNext()和next()
* 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
* 3.内部定义了remove()，可以在遍历的时候删除集合中的元素

    public void IteratorTest() {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("jack",18));

        Iterator iterator = collection.iterator();

        //hasNext()：判断是否还有下一个元素
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //测试Iterator中的remove()方法，如果还未调用next()或者在上次调用next()之后调用了remove()又调用remove()都会报异常
    @Test
    public void remove(){
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("jack",18));
        Iterator iterator = collection.iterator();

        while (iterator.hasNext()){
            Object o = iterator.next();
            if ("AA".equals(o)){
                iterator.remove();
            }
        }
    }

    //使用forEach遍历集合中的元素：for(集合元素的类型 局部变量 : 集合对象)
    @Test
    public void forEach(){
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("jack",18));

        for (Object obj : collection){
            System.out.println(obj);
        }
    }

Map接口

* Map接口：双列集合，用来储存一对(key — value)一对的数据
 *      HashMap：主要实现类，线程不安全，效率高
 *          LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序额实现遍历
 *              原理：在原有的HashMap底层结构添加了一对指针，对于频繁遍历操作效率高于HashMap
 *      TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。底层使用红黑树
 *      Hashtable：少用实现类，线程安全，效率低
 *          Properties：常用来处理配置文件。key和value都是String类型
 *
 * Map中的key：无序的、不可重复的，使用Set储存所有的key
 * Map中的value：无序的、可重复的，使用Collection储存所有的value
 * 一个键值对：key-value构成的Entry对象
 * Map中的Entry：无序的、不可重复的，使用Set储存所有的Entry
 *
 * HashMap的底层实现原理：
 *  jdk1.7
 *      HashMap map = new HashMap():实例化以后，底层创建了一个长度18的一维数组Entry[] table
 *      map.put(key1, value1):首先，调用key1所在类的hashCode()计算key1哈希值，算出在Entry数组中该存放的位置
 *                              如果此位置没有数据，则直接添加。如果有数据，则比较key1和已经存在的数据的哈希值，如果不相同则添加成功
 *                              如果相同，继续比较key1所在类的equals()方法，如果返回false则添加成功，如果返回true则覆盖以前的数据
 *                  添加过程中扩容方式：扩容为原来容量的2倍，并恢复原有的数据
 *  jdk1.8
 *      new HashMap()：底层没有创建一个长度为16的数组，底层数组为Node[]，不是Entry[]
 *      首次调用put()方法时，才创建数组

Map接口中的常用方法

    * 添加、删除、修改
    * Object put(Object key, Object value)：将指定key-value添加（或修改）到当前map对象中
    * void putAll(Map m)：将m中的所有key-value对存放到当前map中
    * Object remove(Object key)：移除指定key的key-value对，并返回value
    * void clear()：清空当前map中的所有数值

    public void test(){
        Map map = new HashMap();
        map.put(12,123);
        map.put("qw",123);
        map.put(true,123);

        System.out.println(map); //{qw=123, 12=123, true=123}

        Map map1 = new HashMap();
        map1.put("we",12);
        map1.put("aa",534);
        map1.put("bb",234);
        map.putAll(map1);
        System.out.println(map); //{aa=534, bb=234, qw=123, 12=123, we=12, true=123}

        Object o = map.remove("we");
        System.out.println(o); //12
        System.out.println(map); //{aa=534, bb=234, qw=123, 12=123, true=

        map.clear();
        System.out.println(map); //{}
    }

    * 元素查询的操作：
    * Object get(Object key)：获取指定key对应的value
    * boolean containsKey(Object key)：是否对包含指定的key
    * boolean containsValue(Object value)：是否包含指定的value
    * int size()：返回map中key-value对的个数
    * boolean isEmpty()：判断当前map是否为空
    * boolean equals(Object obj)：判断当前map的参数对象obj是否相等

    public void test1(){
        Map map = new HashMap();
        map.put(12,123);
        map.put("qw",123);
        map.put(true,123);

        System.out.println(map.get("qw")); //123

        System.out.println(map.containsKey(23)); //false

        System.out.println(map.containsValue(1234)); //false

        System.out.println(map.size()); //3

        System.out.println(map.isEmpty()); //false

    * 元视图操作
    * Set keySet()：返回所有的key构成的Set集合
    * Collection values()：返回所有value构成的Collection集合
    * Set entrySet()：返回所有key-values对构成的Set集合

    public void test2(){
        Map map = new HashMap();
        map.put(12,123);
        map.put("qw",1234);
        map.put(true,12345);

        //遍历所有key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集：values()
        Collection values = map.values();
        for (Object o : values){
            System.out.println(o);
        }

        //遍历所有的key-value：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "," + entry.getValue());
        }
    }

Collections工具类

* Collections：操作Collection和Map的工具类
*   类中提供了多个synchronizedXXX()方法，该方法可以将指定集合包装成线程同步的集合，解决线程安全问题
*       List list1 = Collections.synchronizedList(list)
*           返回的list1就是线程安全的list

* reverse(List)：反转List中元素的顺序
* shuffle(List)：对List集合元素进行随机排序
* sort(List)：根据元素的自然顺序指定List元素按升序排序
* sort(List, Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
* swap(List, int, int)：将指定list集合中的i处元素与j处元素进行交换
*
* Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
* Object max(Collection, Comparator)：根据Comparator指定的顺序，返回给定集合的最大元素
* Object min(Collection)：
* Object min(Collection, Comparator)
* int frequency(Collection, Object)：返回指定集合中指定元素的出现次数
* void copy(List dest, List src)：将src中的内容复制到dest中
* boolean replaceAll(List list, Object oldVal, Object newVal

    @Test
    public void test(){
        List list = new ArrayList();
        list.add(123);
        list.add(23553);
        list.add(1232);
        list.add(14534);
        list.add(1);

        System.out.println(list);

        //reverse(List)
        Collections.reverse(list);
        //shuffle(List)
        Collections.shuffle(list);
        //sort(List)
        Collections.sort(list);
        //swap(List, int, int)
        Collections.swap(list, 1, 2);

        //void copy(List dest, List src)
            /* 异常：IndexOutOfBoundsException
            List list1 = new ArrayList();
            Collections.copy(list1, list);
            */
        List list1 = Arrays.asList(new Object[list.size()]);
        Collections.copy(list1, list);
        System.out.println(list1);

        List list2 = Collections.synchronizedList(list);
    }