/**
 * 单列数据，定义了存取一组对象的方法的集合
 * 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双列集合