Java入门基础16：集合框架1（Collection集合体系、List、Set）

集合体系结构

Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的。

collection集合体系

Collection的常用方法

package com.itchinajie.d1_collection;

import java.util.ArrayList;
import java.util.HashSet;

/*
* 目标：认识Collection体系的特点。
* */
public class CollectionTest1 {
    public static void main(String[] args) {
        //简单确认一下Collection集合的特点。
        ArrayList<String> list=new ArrayList<>();//有序 可重复 有索引
        list.add("java1");
        list.add("java2");
        list.add("java1");
        list.add("java2");
        System.out.println(list);

        HashSet<String>set = new HashSet<>();
        set.add("java1");
        set.add("java2");
        set.add("java1");
        set.add("java2");
        set.add("java3");
        System.out.println(set);
    }
}



package com.itchinajie.d1_collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTest2API {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();// 多态写法
        //1.public boolean add(Ee）：添加元素，添加成功返回true。
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);

    //2.public void clear()：清空集合的元素。
    //c.clear();
    //system.out.println(c);

    //3.public boolean isEmpty()：判断集合是否为空是空返回true，反之。
        System.out.println(c.isEmpty()); // false

    //4.public int size()：获取集合的大小。
        System.out.println(c.size());

    //5.public boolean contains（object obj)：判断集合中是否包含某个元素。
        System.out.println(c.contains("java1")); // true
        System.out.println(c.contains("Java1")); // false

    //6.public boolean remove(Ee)：删除某个元素：如果有多个重复元素默认删除前面的第一个！
        System.out.println(c.remove( "java1"));
        System.out.println(c);

        //7.public Object [] toArray();把集合转换成数组
        Object[] arr = c.toArray();
        System.out.println(Arrays.toString(arr));

        String[] arr2 = c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(arr2));

        System.out.println("------------------------------------");
        //把一个集合的全部数据倒入到另一个集合中去。
        Collection<String>c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);//就是把c2集合的全部数据倒入到c1集合中去。
        System.out.println(c1);
        System.out.println(c2);

    }
}

Collection的遍历方式

迭代器

迭代器是用来遍历集合的专用方式（数组没有迭代器），在到ava中迭代器的代表是Iterator。

package com.itchinajie.d2_collection_traverse;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
* 目标：Collection集合遍历方式一：使迭代器Iterator遍历
* */
public class CollectionDemo1 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
    //c=[赵敏，小昭，素素，灭绝]
    //                                       it
    //使用迭代器遍历集合
    //1、从集合对象中获取迭代器对象。
        Iterator<String> it = c.iterator();
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
        //System.out.println(it.next());//出现异常的

        //2、我们应该使用循环结合迭代器遍历集合。
        while (it.hasNext()){
//            String ele = it.next();
//            System.out.println(ele);
            System.out.println(it.next());
        }
    }
}

增强for

增强for可以用来遍历集合或者数组。

增强for遍历集合，本质就是迭代器遍历集合的简化写法。

package com.itchinajie.d2_collection_traverse;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 目标：Collection集合遍历方式二：增强for
 * */
public class CollectionDemo2 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
    //c=[赵敏，小昭，素素，灭绝]
    //                    ele
    //使用增强for遍历集合或者数组。
        for (String ele : c){
            System.out.println(ele);
        }

        String[] names = {"迪丽热巴","古力娜扎","稀奇哈哈"};
        for (String name : names){
            System.out.println(name);
        }
    }
}

Lambda表达式

得益于刊DK8开始的新技术Lambda表达式，提供了一种更简单、更直接的方式来遍历集合。

package com.itchinajie.d2_collection_traverse;

import java.util.ArrayList;
import java.util.Collection;

/*
* 目标：Collection集合的遍历方式三：JDK8开始新增的lambda表达式（forEach方法）
* */
public class CollectionDemo3 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("殷素素");
        c.add("周芷若");
        System.out.println(c);
        //[赵敏，小昭，般素素，周芷若]
        //        s
        //default void forEach(Consumer<?superT>action): 结合Lambda表达式遍历集合：

//        c.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
//        //简化
//        c.forEach((String s) -> {
//                System.out.println(s);
//        });
            //简化
//        c.forEach( s -> {
//            System.out.println(s);
//        });
            //简化
//        c.forEach( s -> System.out.println(s));

        c.forEach( System.out::println);



    }
}

List系列集合

List集合的特有方法 List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也都继承了。

List集合的特有方法

package com.itchinajie.d3_collection_list;

import java.util.ArrayList;
import java.util.List;

/**
 目标：掌握List系列集合的特点，以及其提供的特有方法。
 */
public class ListTest1 {
    public static void main(String[] args) {
        //1.创建一个ArrayList集合对象（有序、可重复、有索引）
        List<String> list = new ArrayList<>();// 一行经典代码
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);//【蜘蛛精，至尊宝，至尊宝，牛夫人]

        //2.public void add(int index，E element)：在某个索引位置插入元素。
        list.add( 2,"紫霞仙子");
        System.out.println(list);

        //3.public E remove（int index）：根据索引删除元素，返回被删除元素
        System.out.println(list.remove(2));
        System.out.println(list);

        //4.public E get(int index):返回集合中指定位置的元素。
        System.out.println(list.get(3));

        //5.public E set(int index,E element):修改索引位置处的元素，修改成功后，会返回原来的数据
        System.out.println(list.set(3,"牛魔王"));
        System.out.println(list);
    }
}

遍历方式

List集合支持的遍历方式：

1、for循环(因为List集合有索引)

2、迭代器

3、增强for循环（foreach遍历）

4、Lambda表达式

package com.itchinajie.d3_collection_list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
* List集合支持的遍历方式：
1、for循环(因为List集合有索引)
2、迭代器
3、增强for循环
4、Lambda表达式
* */
public class ListTest2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("糖宝宝");
        list.add("蜘蛛精");
        list.add("至尊宝");

        //(1)for循环
        for (int i=0;i<list.size();i++){
            //i=012
            String s = list.get(i);
            System.out.println(s);
        }

        //(2)迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        
        //(3)增强for循环（foreach循环）
        for (String s : list) {
            System.out.println(s);
        }

        //(4)JDK1.8开始之后的Lambda表达式
        list.forEach(s -> {
                System.out.println(s);
        });
    }
}

ArrayList集合的底层原理

特点

1、基于数组实现的

2、查询速度快(注意：是根据索引查询数据快)：查询数据通过地址值和索引定位，查询任意数据耗时相同。

3、删除效率低：可能需要把后面很多的数据进行前移。

4、添加效率极低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容。

底层原理

1、利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组；

2、添加第一个元素时，底层会创建一个新的长度为10的数组；

3、存满时，会扩容1.5倍；

4、如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准。

ArrayList集合的应用原理

1、ArrayList适合：根据索I查询数据 ,比如根据随机索引数据（高效）！或者数据量不是很大时！

2、ArrayList不适合：数据量大的同时 ,又要频繁的进行增删操作！

LinkedList集合的底层原理

基于双链表实现的。

什么是链表？有啥特点?

单项链表：链表的特点1：查询慢，无论查询哪个数据都要从头开始找；
链表的特点2：链表增删相对快。

双向链表（基于双链表实现）：基于双链表实现的。
特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的。

新增首尾操作的特有方法

LinkedList集合的应用场景

1、用来设计队列

2、用来设计栈

package com.itchinajie.d3_collection_list;

import java.util.LinkedList;

/**
 目标：掌握List系列集合的特点，以及其提供的特有方法。
 */
public class ListTest3 {
    public static void main(String[] args) {
        //1、创建一个队列。
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("第1号人");
        queue.addLast("第2号人");
        queue.addLast("第3号人");
        queue.addLast("第4号人");
        System.out.println(queue);
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
        System.out.println("------------------------------------");
        //2、创建一个栈对象。
        LinkedList<String> stack = new LinkedList<>();
        //压栈
//        stack.addFirst("第1颗子弹");
//        stack.addFirst("第2颗子弹");
//        stack.addFirst("第3颗子弹");
//        stack.addFirst("第4颗子弹");
        stack.push("第1颗子弹");
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);
        //出栈
//        System.out.println(stack.removeFirst());
//        System.out.println(stack.removeFirst());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

set系列集合

package com.itchinajie.d4_collection_set;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

/*
* 目标：整体了解一下Set系列集合的特点
* */
public class SetTest1 {
    public static void main(String[] args) {
        //1、创建一个Set集合的对象
        //Set<Integer>set =new HashSet<>（）;//创建了一个HashSet的集合对象。 一行经典代码 HashSet：无序不重复无索引，
        // 不支持索引操作，一般只会无序一次
        // Set<Integer> set = new LinkedHashSet<>（）;//有序 不重复 无索引
        Set<Integer> set =new TreeSet<>();//可排序（升序） 不重复 无索引
        set.add(666);
        set.add(555);
        set.add(555);
        set.add(888);
        set.add(888);
        set.add(777);
        set.add(777);
        System.out.println(set);

    }
}

HashSet

哈希值

就是一个int类型的数值，Java中每个对象都有一个哈希值。
Java中的所有对象，都可以调用Obejct类提供的hashCode方法，返回该对象自己的哈希值。

package com.itchinajie.d4_collection_set;
/**
 *目标：了解一下哈希值。
 ＊Java中的所有对象，都可以调用Obejct类提供的hashCode方法，返回该对象自己的哈希值。
 * public int hashcode()：返回对象的哈希值。
 ＊同一个对象多次调用hashCode方法返回的哈希值是相同的。
 ＊不同的对象，它们的哈希值一般不相同，但也有可能会相同（哈希碰撞）。
 */
public class SetTest2 {
    public static void main(String[] args) {
        Student s1 = new Student("蜘蛛精",25,169.5);
        Student s2 = new Student("紫霞",24,166.5);
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        String str = new String("abc");
        String str2 = new String("acD");
        System.out.println(str.hashCode());
        System.out.println(str2.hashCode());
    }
}

对象哈希值的特点

同一个对象多次调用hashCode(）方法返回的哈希值是相同的。
不同的对象，它们的哈希值一般不相同，但也有可能会相同（哈希碰撞）。

HashSet的底层原理

了解一下数据结构（树）

1、普通二叉树（无用）

2、二叉查找树（二叉排序树）

小的存左边，大的存右边，一样的不存。

3、平衡二叉树（java常用）

4、java用的红黑树

深入理解HashSet集合去重复的机制。

HashSet集合默认不能对内容一样的两个不同对象去重复！

比如内容一样的两个学生对象存入到HashSet集合中去，HashSet集合是不能去重复的！

如何让HashSet集合能够实现对内容一样的两个不同对象也能去重复？？？

如果希望Set集合认为2个内容一样的对象是重复的必须重写对象的hashCode()和equals()方法。

package com.itchinajie.d4_collection_set;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double height;
//方式一：让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。
    @Override
    public int compareTo(Student o) {
        //约定1：  如果左边的对象 大于 右边对象 请您返回正整数
        //约定2：  如果左边的对象 小于 右边对象 请您返回负整数
        //约定3：  如果左边的对象 等于 右边对象 请您返回0
        //按照年龄升序排序
//        if (this.age > o.age) {
//            return 1;
//        }else if (this.age < o.age){
//            return -1;
//        }
//        return 0;
        //return this.age - o.age;//升序
        return o.age - this.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;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    //容一样就只要两个对象内返回true
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Double.compare(height, student.height) == 0 && Objects.equals(name, student.name);
    }
    //只要两个对象内容一样，返回的哈希值就是一样的。
    @Override
    public int hashCode() {
        return Objects.hash(name, age, height);
    }

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


package com.itchinajie.d4_collection_set;

import java.util.HashSet;
import java.util.Set;

public class SetTest3 {
    public static void main(String[] args) {
        Set<Student> students = new HashSet<>();
        Student s1 = new Student("至尊宝", 28, 169.6);
        Student s2 = new Student("蜘蛛精", 23, 169.6);
        Student s3 = new Student("蜘蛛精", 23, 169.6);
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
        Student s4 = new Student("牛魔王", 48, 169.6);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        System.out.println(students);
    }
}

LinkedHashSet

特点：有序、不重复、无索引。

底层原理

TreeSet

特点：不重复、无索引、可排序(默认升序排序，按照元素的大小，由小到大排序。

底层是基于红黑树实现的排序。

package com.itchinajie.d4_collection_set;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/*
* 目标：掌握TreeSet集合的使用
* */
public class SetTest4 {
    public static void main(String[] args) {
        Set<Integer> set1 = new TreeSet<>();
        set1.add(6);
        set1.add(5);
        set1.add(5);
        set1.add(7);
        System.out.println(set1);

        //方式一：让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。
        //方式二：通过调用TreeSet集合有参数构造器，可以设置Comparator对像（比较器对象，用于指定比较规则)。
        // new 一个TreeSet的比较器对象的有参构造器，生成一个比较器对象，然后重写对象的匿名内部类
        //day04_oop -> src -> com.itchinajie -> d5_arrays 中讲过自定义排序规则
        //TreeSet就近选择自己自带的比较器对象进行排序
        Set<Student> students = new TreeSet<>(( o1,  o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
        students.add(new Student("蜘蛛精",23,169.7));
        students.add(new Student("紫霞",22,169.8));
        students.add(new Student("至尊宝",26,165.5));
        students.add(new Student("牛魔王",22,183.5));
        System.out.println(students);
    }
}

自定义排序规则

小结

注意：集合的并发修改异常

package com.itchinajie.d5_collection_exception;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class collection_exception {
    public static void main(String[] args) {
        //需求：找出集合中全部带“李”的名字，并从集合中删除。
        List<String>  list = new ArrayList<>();
        list.add("王麻子");
        list.add("小李子");
        list.add("李爱花");
        list.add("张全蛋");
        list.add("晓李");
        list.add("李玉刚");
        System.out.println(list);
        //[王麻子，小李子，李爱花，张全蛋，晓李，李玉刚]

        //System.out.println("--------------------------------------");
        //需求：找出集合中全部带“李"的名字，并从集合中删除。
//        Iterator<String>it = list.iterator();
//        while (it.hasNext()){
//            String name = it.next();
//            if(name.contains("李")){
//                list.remove(name);
//            }
//        }
//        System.out.println(list);
        //报错

        //System.out.println("--------------------------------------");
        //使用for循环遍历集合并删除集合中带李字的名字
        //[王麻子，小李子，李爱花，张全蛋，晓李，李玉刚]
//        for (int i=0;i<list.size();i++){
//            String name = list.get(i);
//            if(name.contains("李")){
//                list.remove(name);
//            }
//        }
//        System.out.println(list);
        //出bug，需要在他的基础上加个i--

        //System.out.println("--------------------------------------");
        //怎么解决呢？
        //使用for循环遍历集合并刷除集合中带李字的名字
        //[王麻子，小李子，李爱花，张全蛋，晓李，李玉刚]
        //i
//        for (int i = 0;i<list.size();i++){
//            String name = list.get(i);
//            if(name.contains("李")) {
//                list.remove(name);
//                i--;
//            }
//        }
//        System.out.println(list);
        //加个i--也可以
        //倒着删除也可以

        System.out.println("--------------------------------------");
        //用迭代器正常删除的方式
        需求：找出集合中全部带“李”的名字，并从集合中删除。
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String name = it.next();
            if (name.contains("李")) {
                //List.remove(name);//并发修改异常的错误。
                it.remove();//删除迭代器当前遍历到的数据，每删除一个数据后，相当于也在底层做了i--
            }
        }
        System.out.println(list);

        //System.out.println("--------------------------------------");
        //使用增强for循环遍历集合并删除数据，没有办法解决bug的
        //由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强fo循环遍历集合，又在同时删
        //除集合中的数据时，程序也会出现并发修改异常的错误
//        for (String name : list){
//            if(name.contains("")){
//                list.remove(name);
//            }
//        }
//        System.out.println(list);

        //System.out.println("--------------------------------------");
        //使用lambda表达式也不行
//        list.forEach(name ->{
//            if(name.contains("李")){
//            list.remove(name);
//            }
//        });
//        System.out.println(list);

    }
}

(本章图片均来自于黑马程序员视频)