浅谈Collection接口家族的恩爱情仇!

Collection接口(单值存储)

java.util.Collection接口：子接口： --〉List集合，Set集合
	定义的是所有单列集合中的共性方法，所有的单列集合都可以使用的共性方法
	共性方法：(抽象方法)
		public boolean add（E e）：把给定的对象中添加元素
		
		public void clear（）；清空集合中所有的元素
		
		public boolean remove（）；把给定的对象在当前的集合中删除
		
		public boolean contains（）；判断当前集合是否包含给定的元素
		
		public boolean isEmpty（）；判断集合是否为空，为空返回true
		
		pubic int size（）；返回集合中元素的个数
		
		public Object[]  toAaary（）；把集合中的元素存储到数组中
		
		addALL(Collection c):将参数c中的元素,都添加到调用者集合中
		
		removeAll(Collection c):从调用者集合中，删除那些也存在参数c中的元素
		
		containsAll(Collection c):判断调用者，是否包含参数c中的所有元素
		
		retainAll(Collection c):参数c中有哪些元素，就在调用者中保留那些元素(交集)

List 接口(允许重复)

重写了Collection接口的一些列函数。
继承了add和addAll两个函数的规则。
新增了一些列函数。

特点：
元素有放入顺序，元素可重复.

例如，存元素的顺序是11、22、33。那么集合中，元素的存储就 是按照11、22、33的顺序完成的）。

它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道
理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

list接口中的常用方法(新增)

public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新
前的元素。

实现类:

ArrayList：(常用)
底层数据结构是数组。线程不安全
LinkedList：
底层数据结构是链表。线程不安全
Vector：
底层数据结构是数组。线程安全(如果不需要线程安全用ArrayList)

ArarryList (具体实现)

在进行实现的时候一定要注意坐标的有效性,不要超出集合长度.
Vector实现和其一样.

public class Demo1 {
    public static void main(String[] args) {
        /**
         * ArrayList 数组结构 查找 增加和删除慢
         */
        ArrayList<Integer> data = new ArrayList<>();
        //添加 100 200 300
        data.add(100);
        data.add(200);
        data.add(300);
        //通过坐标添加元素 400
        data.add(1,400);
        //指定对象删除      即 删除 坐标为1的元素
        data.remove(1);
        //返回指定位置的元素 即 获取 坐标为1的元素
        data.get(1);
        //指定对象替换      即 替换 坐标为1的元素
        data.set(2,500);
        //判断是否包含此对象
        boolean flag =data.contains(200);
        //判断是否为空
        boolean flag1 =data.isEmpty();
        //返回集合长度
        int size =data.size();
        System.out.println(flag);
        System.out.println(flag1);
        System.out.println(data);
        System.out.println(size);
        //将集合中的元素存到数组里面
        Object [] arr=data.toArray();
        for (Object s: arr){
            System.out.print(s+" ");
        }

    }
    /**
     * true
     * false
     * [100, 200, 500]
     * 3
     * 100 200 500
     */

}

LinkedList 的实现

public class Demo2 {
    public static void main(String[] args) {
        /**
         * LinkedList : 双向链表  增删快 查找慢
         */
        LinkedList<Integer> data = new LinkedList<>();
        // 双向队列模式  头插 尾取

        data.addFirst(100);
        data.addFirst(200);
        int a = data.removeLast();
        System.out.println(a);
        //双向队列模式  尾插 头取
        data.addLast(300);
        data.addLast(400);
        int b =data.removeFirst();
        System.out.println(b);
        System.out.println(data);
        //压栈 push
        data.push(600);
        data.push(700);
        //弹栈 栈顶元素
        int c =data.pop();
        System.out.println(c);
        //判断是否包含元素 即:是否为空
        System.out.println(data.isEmpty());

    }
}

Set 接口

元素无放入顺序，元素不可重复.

并没有新增自己的函数
重写了Collection接口的部分函数
继承了add函数和addAll函数

实现类:

- HashSet：底层数据结构是哈希表(是一个元素为链表的数组) 即为散列表
- TreeSet：底层数据结构是红黑树(是一个自平衡的二叉树)。保证元素的排序方式
- LinkedHashSet：底层数据结构由哈希表和链表组成。

HashSet实现

public static void main(String[] args) {
        //HashSet : 散列存放
        HashSet<String> set = new HashSet<>();
        boolean flag =set.add("当 我和世界不一样");
        boolean flag1 =set.add("当 我和世界不一样");
        set.add("坚持对我来说就是以刚克刚");
        set.add("最美的愿望 一定最疯狂");
        System.out.println(flag);
        System.out.println(flag1);
        Iterator<String> it =set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

TreeSet实现

public static void main(String[] args) {
        TreeSet<String> set =new TreeSet<>();
        set.add("D");
        set.add("A");
        set.add("C");
        set.add("B");
        //按照ASCII码值排列
        for (String a: set) {
            System.out.println(a);
        }

当如果是引用类型是就需要重写方法:

public static void main(String[] args) {
        TreeSet<Person> data =new TreeSet<>();
        Person person =new Person("陈潮",19);
        Person person1 =new Person("陈2",13);
        Person person2 =new Person("陈3",16);
        data.add(person);
        data.add(person1);
        data.add(person2);
        for (Person p:data) {
            System.out.println(p);
        }
    }
    static class Person implements Comparable<Person>{
        private String name;
        private int age;

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

        @Override
        public int compareTo(Person o) {
            //this 与 o 比较
            if(this.age>o.age){
                return 1;
            }else if(this.age  ==o.age){
                return 0;
            }
            return -1;
        }

        public Person() {
        }

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

Iterator 接口

Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

boolean hasNext()  如果迭代器中还有元素那么返回true。
E next()  返回迭代器中游标的下一元素
void remove()  从迭代器指向的 collection 中移除迭代器返回的最后一个元素。每次调用 next 后只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的 collection，则迭代器的行为是不确定的。

实现

public static void main(String[] args) {
        //使用多态方式创建对象
        Collection<String> list = new ArrayList<>();
        //添加元素到集合
        list.add("hello");
        list.add("world");
        list.add("java");
        //创建迭代器对象
        Iterator<String> it = list.iterator();
        //遍历操作
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }

增强for循环

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

遍历数组:

public static void main(String[] args) {
        int [] arr ={2,3,4,5};
        for (int s :arr){
            System.out.println(s);
        }
    }

遍历集合:

 public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("四面楚歌");
        collection.add("司马八荒");
        collection.add("一生牵挂");
        for(String s : collection){
            System.out.println(s);
        }