? List ： 元素有序、可重复的集合

? Set ： 元素无序、不可重复的集合

1 、添加

? add(Object obj)

?addAll(Collection coll)

2 、获取有效元素的个数

? int size()

3 、清空集合

? void clear()

4 、是否是空集合

? boolean isEmpty()

5 、是否包含某个元素

? boolean contains(Object obj) ： 是通过元素的 equals 方法来判断是否

是同一个对象

? boolean containsAll(Collection c) ： 也是调用元素的 equals 方法来比

较的。拿两个集合的元素挨个比较。

6 、删除

? boolean remove(Object obj) ： 通过元素的 equals 方法判断是否是

要删除的那个元素。只会删除找到的第一个元素

? boolean removeAll(Collection coll) ： 取当前集合的差集

7 、取两个集合的交集

? boolean retainAll(Collection c) ： 把交集的结果存在当前集合中，不

影响 c

8 、集合是否相等

? boolean equals(Object obj)

9 、转成对象数组

? Object[] toArray()

10 、获取集合对象的哈希值

? hashCode()

11 、遍历

? iterator() ： 返回迭代器对象，用于集合遍历

案例

/**
 * 单列数据，定义了存取一组对象的方法的集合
 * ?List：元素有序、可重复的集合
 * ?Set：元素无序、不可重复的集合
 */
public class CollectionDome
{
    public static void main(String[] args) {
//        f1();
//        f2();
        f3();
    }
    //基础方法
    public static void f1(){
        Person person1=new Person("张三",22);
        Person person2=new Person("王五",12);
        Collection collection1=new ArrayList<>();
        //添加单个元素元素
        collection1.add(123);
        collection1.add("DFP");
        collection1.add(person1);
        System.out.println("collection1:"+collection1);

        Collection collection2=new ArrayList<>();
        collection2.add(345);
        collection2.add("CCC");
        collection2.add(person2);
        System.out.println("collection2:"+collection2);
        //添加单个集合元素
        collection1.addAll( collection2);
        System.out.println("collection1:"+collection1);
        //获取有效元素的个数
        int size = collection1.size();
        System.out.println("长度:"+size);

        //是否是空集合
        boolean empty1 = collection1.isEmpty();
        System.out.println(empty1);
        //清空集合
//        collection2.clear();
        System.out.println("collection2.isEmpty:"+collection2.isEmpty());

        //是否包含某个元素是通过元素的equals方法来判断是否是同一个对象
        System.out.println("equals方法来判断是否是同一个对象"+collection1.contains(123));
//        也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
        System.out.println("是否包含某个集合"+collection1.containsAll(collection2));

        //移除某个元素
        boolean remove = collection2.remove(345);
        System.out.println("移除某个元素"+remove);
        System.out.println("collection2:"+collection2);

        Collection collection3=new ArrayList<>();
        collection3.add("CCC");
        //取当前集合的差集
        boolean removeAll = collection1.removeAll(collection3);
        System.out.println("取当前集合的差集:"+removeAll);
        System.out.println("C1:"+collection1);

        //取两个集合的交集
        System.out.println(collection2);
        boolean b = collection2.retainAll(collection3);
        System.out.println("collection2:"+collection2);

    }
    //迭代器运用
    public static void f2(){
        Person person1=new Person("张三",22);
        Collection collection1=new ArrayList<>();
        //添加单个元素元素
        collection1.add(123);
        collection1.add("DFP");
        collection1.add(person1);
        System.out.println("collection1:"+collection1);
        //获取Iterator类
        Iterator iterator = collection1.iterator();
        System.out.println("iterator:"+iterator);

//        while (iterator.hasNext()){
//            Object next = iterator.next();
//            System.out.println(next);
//        }
        //因为上面的遍历 已经将iterator遍历到末尾，如果不重新创建Iterator类下一个指向空指针
//        System.out.println(iterator.next());//报错
        //执行行到末尾报错空指针
//        while (iterator.next()!=null){
//            System.out.println(iterator.next());
//        }
        for (Iterator it = iterator; it.hasNext(); ) {
            System.out.println(iterator.next());
        }

    }
    //转换
    public static void f3(){
        Collection list=new ArrayList<>();
        //数组  转换为  列表
        char[] c=new char[] {'c','b','w'};
        List<char[]> chars = Arrays.asList(c);
        System.out.println(chars);
        Iterator<char[]> iterator = chars.iterator();
        while (iterator.hasNext()){
            char[] next = iterator.next();
            System.out.println(next);
        }

        list.add(1);
        list.add(11);
        list.add(111);
        //列表转换为 数组
        Object[] objects = list.toArray();
        System.out.println(objects);
        for (int i=0;i<objects.length;i++){
            System.out.println(objects[i]);
        }
    }
}

1.2List接口

List的实现类 :

ArrayList:list的主要实现类、线程不安全，查找效率高，底层使用Object [] elementDate数组。自动扩容 1.5倍。

LinkedList :对于频繁 插入、删除效率更高，底层使用双向链表。

Vector:list的古老接口的实现类，线程安全，效率低，使用object对象。

public class ListDome {
    public static void main(String[] args) {
//        f1();
        f2();
    }
    //ArrayList方法操作
    public static void f1(){
        Person person=new Person("张三",22);
        List list=new ArrayList<>();
        list.add(1234);
        list.add("DFP");
        list.add("222");
        list.add(person);
        System.out.println("Lsit:"+list);

        List list1=new ArrayList<>();
        list1.add(111);
        //在index位置插入ele元素
        list1.add(0,222);

        List list2=new ArrayList<>();
        list2.add(222);
        list2.add(222);

        list.addAll(list1);
        //从index位置开始将eles中的所有元素添加进来
        list.addAll(0,list2);
        System.out.println("Lsit:"+list);

        //获取指定index位置的元素
        System.out.println("获取指定index位置的元素:"+list.get(2));

        //返回obj在集合中首次出现的位置
        System.out.println("返回obj在集合中首次出现的位置:"+list.indexOf(1234));
        //返回obj在当前集合中末次出现的位置
        System.out.println("返回obj在当前集合中末次出现的位置:"+list.lastIndexOf(person));

        //移除指定index位置的元素，并返回此元素
        Object remove = list.remove(2);
        System.out.println("移除:"+remove+"后的："+list);
        Object remove1 = list.remove(person);
        System.out.println("移除:"+remove1+"后的："+list);
        //设置指定index位置的元素为xx，返回值是当前位置的原有值并且替换了
        Object set = list.set(2, "00");
        System.out.println("set:"+set+"后的："+list);

        //返回从fromIndex到toIndex 位置的子集合 不包含 2位置的
        List list3 = list.subList(0, 2);
        System.out.println(list3);

        for (Object i:list) {
            System.out.println(i);
        }


    }
    //LinkedList放操作
    public static void f2(){
        LinkedList list=new LinkedList<>();
        list.add(11);
        list.add("sss");
        list.add(new Person("DFP",18));
        System.out.println(list);
        //大部分方法和ArrayList相识 介绍不同的方法
        //收尾插入
        list.addFirst("the 1");
        list.addLast("the end");
        list.add(0,"00");
        System.out.println(list);

        Object[] objects = list.toArray();
        for (Object object : objects) {
            System.out.println("sss:"+object);
        }

        //获取收尾元素
        Object first = list.getFirst();
        Object last = list.getLast();
        System.out.println(first);
        System.out.println(last);

        //移除收尾元素
        list.removeFirst();
        list.removeLast();
        System.out.println(list);


    }
}

1.3set接口

主要实现类

HashSet：存储无序的，不可重复的数据

LinkedHashSet：HashSet的子类，遍历数据的时候可以按照插入顺序遍历 对于频繁的操作效率更高。

TreeSet：按照对象的指定属性进行排序

*  1.无序性不等于随机性、存储的数据再底层数组中并非按照数组的索引的顺序进行添加而是根据数据的哈希值进行添加.
* 2.不可重复性，在保证添加的的元素按照equals()判断，不放回为true进行添加

要求；添加到set中的数据 在他的类中 要包含 hashCode和equals方法重写的hashCode和equals方法  尽可能保持一致性。

/**
 * 添加过程hashset为例：（数组+链表）
 *      向hashset添加a元素的时候，首先调用元素a类中的hashCode（）方法计算值
 *      此时的哈希值接着计算出HashSet底层数组的存放位置（索引位置），再判断这
 *      个位置有没有占用元素。
 *          如果没有--元素a直接添加  *
 *          如果有其他元素b---(获取一链表的形式以存在多个元素)，比较a，b的hash值
 *              如果hash值不相同 a元素成功添加 *
 *              如果相同，需要调用equals（）方法进行比较
 *                  返回true a添加失败
 *                  返回false a添加成功 *
 * 3.要求；添加到set中的数据 在他的类中 要包含 hashCode和equals方法
 *        重写的hashCode和equals方法  尽可能保持一致性
 */
public class SetDome {
    public static void main(String[] args) {
//        f1();
//        f2();
        f3();
    }
    //HashSet
    public static void f1(){
        //set中的方法和Collection一样 使用方法也相识
        HashSet set=new HashSet<>();
        set.add(11);
        set.add("ccc");
        set.add(new Person("DFP",23));
        System.out.println("HashSet:"+set);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    //LinkedHashSet
    public static void f2(){
        /**
         * 因为底层添加了链表 记录了添加的顺序
         */
        Set set=new LinkedHashSet();
        set.add(111);
        set.add("ccc");
        set.add(new Person("DFP",23));
        System.out.println("LinkedHashSet："+set);
    }

    /**TreeSet
     *  //为了实现自然或者定制排序 实现Comparable或者Comparator
     *  自然排序中，比较2个对象是否相等的标准为：compareTo()返回0  不再是equals方法
     *  定制排序比较2个对象是否相等的标准为：compare()返回0  不再是equals方法
     *
     */
    public static void f3(){
        TreeSet treeSet=new TreeSet<>();
        treeSet.add(11);
        treeSet.add(22);
        treeSet.add(2);
        treeSet.add(-67);
//        treeSet.add("1");//报错所以内容类型一致性
        System.out.println(treeSet);

        TreeSet treeSet1=new TreeSet<>();
        treeSet1.add(new Person("DFP",22));
        treeSet1.add(new Person("AB",77));
        treeSet1.add(new Person("Jm",25));
        //排序规则的体现
        treeSet1.add(new Person("Tom",17));
        treeSet1.add(new Person("Tom",67));
        treeSet1.add(new Person("Tom",41));
        System.out.println(treeSet1);

    }
}

2.Map双列集合

主要的实现类 HashMap、 LinkedHashMap、 TreeMap、 Hashtable

 *  HashMap底层原理（jdk7）：
 *      HashMap map=new HashMap(); 在实例化与一个对象之后 创建一个长度是16的一位数组Entry【】table;
 *      在执行多次put之后...map.put(k1,v1);
 *      首先调用，k1所在类的hashCode（）计算k1的哈希值，此时哈希值经过某种算法之后，得到Entry数组中的存放位置。
 *     1. 如果此时位置上的数据不为空，此时的k1-v1直接成功添加。
 *     2. 如果此时位置的数据不为空，（意味着此时位置上存在一个或者多个数据通过链表的形式存储），比较k1和已存在的数据的哈希值。
 *          a.如果k1的哈希值与已存在的数据的哈希值不相同，此时的k1-v1 添加成功。
 *          b。如果k1的哈希值和已存在的某个（key-value）的哈希值相同，继续比较k1类的equals（key）
 *              如果equals返回结果false表示不相同。成功添加k1-v1
 *              如果equals返回结果true表示相同，使用v1替换value。
 *     3.扩容问题：
 *          超出临界值并且存储的位置非空的时候触发
 *          默认方式：扩容为原来 的2倍 将原数据拷贝过来
 * HashMap底层原理（jdk8）：
 *         1. HashMap map=new HashMap()：不创建长度16的数组
 *         2. 是Node【】数组不是 entry【】数组
 *         3、首次调用put方法的时候，创建长度16的数组
 *         4.数组+链表+红黑树：当前数组的某个位置的索引位置上的元素以链表形式存在的数据个数>8
 *              且长度>64的时候 此时的数组改为红黑树存储

保证在遍历Map元素的时候，可以按照添加属性进行遍历。原因是在HashMap的基础上底层结构上，添加了一对指针，指向首尾。频繁的遍历操作，效率更高。

在保证按照添加的key-value对进行排序，实现排序的遍历，此时可以考虑key的自然或者定制排序（底层使用红黑树）。

古老的实现类，线程安全。

public class MapDome {
    public static void main(String[] args) {
        f1();
//        f2();
    }
    //HashMap
    public static void f1(){
        System.out.println("f1*****************");
        Map map=new HashMap<>();
        map.put("A",-5);
        map.put("kk",76);
        map.put("3412",1);
        map.put("D",new Person("张三",22));
        System.out.println(map) ;
//        HashMap hashMap=new HashMap<>();
//        hashMap.put("李四",145);
//        hashMap.put("李六",190);
//        hashMap.put("王四",1425);
//        System.out.println("hashMap:"+hashMap);
//        //将m中的所有key-value对存放到当前map中
//        hashMap.putAll(map);
//        System.out.println("hashMap:"+hashMap);
//        //移除指定key的key-value对，并返回value
//        Object remove = hashMap.remove("3412");
//        System.out.println("移除"+remove+"的hashMap:"+hashMap);
//        //获取指定key对应的value
//        Object o = hashMap.get("李四");
//        System.out.println("得到李四："+o);
//        //是否包含指定的key
//        System.out.println("存在王四？"+hashMap.containsKey("王四"));
        是否包含指定的value
//        System.out.println("存在1425？"+hashMap.containsValue(1425));
//        //返回map中key-value对的个数
//        System.out.println("hashmap的长度："+hashMap.size());
//        //清空当前map中的所有数据
//        hashMap.clear();
//        System.out.println(hashMap);
        //替换key的value，返回原来的value
        Object replace = map.replace("A", 100);
        System.out.println("替换"+replace+":"+map);
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
    //LinkedHashMap
    public static void f2(){
        //方法上一致
        System.out.println("f2*****************");
        LinkedHashMap map=new LinkedHashMap<>();
        map.put("A",-5);
        map.put("kk",76);
        map.put("3412",1);
        map.put("D",new Person("张三",22));
        System.out.println(map);
        //遍历
        /**
         * 因为我们的map集合是双列集合
         *      对于key这一列：用set结构的方式存放 不允许重复
         *      对于value这一列 相当于Collection
         *
         * ? Set keySet()：返回所有key构成的Set集合
         * ? Collection values()：返回所有value构成的Collection集合
         * ? Set entrySet()：返回所有key-value对构成的Set集合
         */
        Set set = map.keySet();
        Collection values = map.values();
        Iterator setI = set.iterator();
        Iterator valueI = values.iterator();
        while (setI.hasNext()){
            Object next = setI.next();
            System.out.print(next+"\t");
        }
        System.out.println();
        while (valueI.hasNext()){
            Object nextv = valueI.next();
            System.out.print(nextv+"\t");
        }
        System.out.println();
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }


    }

}