集合与泛型01（二）

• Collection 集合
• List 集合
• Set 集合

第一章 Collection集合

第01节 基础理论

集合的由来

数组有什么特点？

1. 可以存储任意数据类型（基本数据类型或者引用数据类型）
2. 数组的长度是固定的，不可以改变的

上面特点当中，我们知道数组的长度固定，无法满足变化的需求，有时候，长度需要不断的变化，这种情况下，怎么办？

就需要采用集合类去完成。

集合的特点：

1. 可以存储引用数据类型。（不能存放基本数据类型）
2. 长度是可变的

集合是一种容器，比方说我们的水杯。根据容器存放的数据不同，大小形状不同，数据结构不同。将集合分为不同的类型。

集合的体系结构

第02节 常用方法

方法介绍

方法API	方法说明
public boolean add(E)	将指定的对象，添加到集合当中
public boolean remove(E)	删除掉集合当中，指定的对象
public void clear()	清空掉集合当中所有的元素
public boolean contains(E)	判断集合当中是否包含指定的元素
public boolean isEmpty()	判断当前的集合当中是否为空
public int size()	返回集合当中元素的个数
public Object[] toArray()	把集合当中的元素，存储到数组当中

快速入门

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

//目标：学习Collection集合的快速入门
public class Test01 {

    public static void main(String[] args) {

        //创建对象: 左父右子，多态的写法
        Collection<String> c = new ArrayList<>();

        //添加数据
        c.add("hello");
        c.add("world");
        c.add("java");

        //展示结果
        System.out.println(c); //[hello, world, java]
    }
}

//小结：
//1. 创建对象格式，采用的是多态的方式
//2. 添加数据使用 add()方法
//3. 在ArrayList集合的爷爷当中，重写过 toString()方法

第03节 集合遍历

方式一：toArray 转数组

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

//目标：学习Collection的 toArray方法
public class Test03 {

    public static void main(String[] args) {
        //创建对象
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");
        //Object[] toArray()
        //直接调用方法
        Object[] objects = c.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        System.out.println("-----------");
        //<T> T[]  toArray(T[] a)
        //    T[]  toArray(T[] a)
        //    String[]  toArray(String[] a)
        String[] strings = c.toArray(new String[c.size()]);
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
    }
}
//小结：
//toArray() 方法可以将集合转换成为数组。
//如果有泛型，则得到的是具体类型的数组，没有则是Object数组

方式二：迭代器

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

//目标：学习迭代器 Iterator 的基础使用
public class Test04 {

    public static void main(String[] args) {

        //创建对象
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");

        //编写代码的快捷键： c.it  itit
        //通过集合c 获取到迭代器的对象 Iterator<String>
        Iterator<String> iter = c.iterator();
        //循环遍历数据 iter.hasNext() 查看是否还存在下一个数据
        while (iter.hasNext()) {
            //获取到当前的数据 iter.next();
            String next = iter.next();
            //展示结果
            System.out.println(next);
        }
    }
}
//小结：关于迭代器的使用步骤
//1. 获取到迭代器的对象  c.iterator();
//2. 循环判断 iter.hasNext() 是否存在下一个元素
//3. 获取到当前的元素 iter.next()

迭代器的工作原理

迭代器的注意事项，并发修改异常 Concurrent modification exception

方式三：增强for循环

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

//目标：学习增强for循环去遍历集合
@SuppressWarnings("all")
public class Test06 {

    public static void main(String[] args) {

        //创建对象
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");
        //使用增强for循环遍历集合。快捷键:  c.for 回车
        for (String s : c) {
            System.out.println(s);
        }
    }
}

说明： 在增强for循环当中，也不能使用 集合进行增删操作，否则出现 并发修改异常。ConcurrentModificationException

简单一点说，增强for循环就是针对于 迭代器的简化版本。我们专业说法叫做 “语法糖”

第二章 List集合

第01节 基础理论

List集合的特点

（1） 有序：存的顺序和取的顺序是一致的
（2） 有重复：可以存放重复的元素
（3） 有索引：拥有带索引的方法

方法介绍

方法API	方法说明
void add(int,E)	列表当中，指定索引位置，插入元素
E remove(int)	列表当中，删除指定索引位置的元素
E set(int,E)	列表当中，修改指定索引位置的元素
E get(int)	列表当中，获取指定索引位置元素

List集合遍历

集合的遍历操作

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

//List集合的遍历方式
//1. 转数组
//2. 迭代器
//3. 增强for
//4. 普通for
@SuppressWarnings("all")
public class Test02 {

    public static void main(String[] args) {
        //创建对象(多态的写法：左父右子)
        List<String> mList = new ArrayList<>();
        //添加数据
        mList.add("迪丽热巴");
        mList.add("古力娜扎");
        mList.add("马尔扎哈");
        System.out.println("1. 转数组：");
        String[] array = mList.toArray(new String[mList.size()]);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("2. 迭代器:");
        Iterator<String> iter = mList.iterator();
        while (iter.hasNext()) {
            String next = iter.next();
            System.out.println(next);
        }
        System.out.println("3. 增强for");
        for (String s : mList) {
            System.out.println(s);
        }
        System.out.println("4. 普通for");
        for (int i = 0; i < mList.size(); i++) {
            System.out.println(mList.get(i));
        }
    }
}

第02节 ArrayList 集合

经典问题

在 ArrayList 集合做删除操作需要注意什么问题呢？

代码

//目标：集合的删除操作
public class Test04 {

    public static void main(String[] args) {
        //创建集合的对象
        ArrayList<String>  array = new ArrayList<>();
        //添加数据
        array.add("迪丽热巴");
        array.add("张三丰");
        array.add("郭靖");
        array.add("黄蓉");
        array.add("张无忌");
        array.add("令狐冲");
        array.add("东方菇娘");
        array.add("中原一点红");
        //注意：删除掉名字是两个字的人。
        for (int i = 0; i < array.size(); i++) {
            //获取到每个人的名字
            String s = array.get(i);
            //判断集合当中元素的长度大小
            if (s.length() == 2){
                array.remove(s);
                i--;  //删除之后，添加一个i--的操作
            }
        }
        //打印输出结果
        for (String s : array) {
            System.out.println(s);
        }
    }
}
//说明: 在删除的过程当中，需要添加 i--的操作
//主要是集合删除的过程当中，长度的在改变，数据往前移动了。

第03节 LinkedList集合

底层结构是 链表 （增删快，查询慢）

方法API	方法说明
public void addFirst(E)	将指定元素，添加到此列表的开头
public void addLast(E)	将指定元素，添加到此列表的末尾
public E getFirst()	返回此列表的第一个元素
public E getLast()	返回此列表的最后一个元素
public E removeFirst()	移除并且返回此列表的第一个元素
public E removeLast()	移除并且返回此列表的最后一个元素
public E pop()	从此列表当中，在堆栈里面弹出一个元素，等效于 removeFirst
public void push(E)	从此列表当中，将元素压入堆栈第一个元素，等效于 addFirst

第三章 Set 集合

第01节 基础理论

Set集合的特点

（1）无序：存放的顺序和取出的顺序，可能不一致
（2）无重复：不能存放重复的元素
（3）无索引：没有带索引的方法

快速入门

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

//目标：学习Set集合的快速入门
public class Test01 {

    public static void main(String[] args) {

        //创建对象(多态写法：左父右子)
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("hello");
        set.add("world");
        set.add("java");
        set.add("java");
        set.add("java");
        set.add("hello");
        System.out.println("set = " + set); //set = [world, java, hello]
        //遍历集合怎么操作呢?
        //迭代器
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()) {
            String next = iter.next();
            System.out.println(next);
        }
        //增强for
        for (String s : set) {
            System.out.println(s);
        }
    }
}

第02节 HashSet集合

需求

采用HashSet集合存储自定义对象，并且遍历。

案例代码

教练类

//教练类
public class Coach {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Coach coach = (Coach) o;

        if (age != coach.age) return false;
        return name != null ? name.equals(coach.name) : coach.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    public Coach() {
    }

    public Coach(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;
    }

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

测试类

import java.util.HashSet;

//目标：学习HashSet集合存储 自定义对象
public class Test02 {

    public static void main(String[] args) {

        //创建集合对象，添加数据
        HashSet<Coach> set = new HashSet<>();
        Coach c1 = new Coach("刘国梁",50);
        Coach c2 = new Coach("姚明",40);
        Coach c3 = new Coach("杜峰",50);
        Coach c4 = new Coach("刘国梁",50);

        //添加数据
        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);

        //展示结果
        for (Coach c : set) {
            System.out.println(c);
        }
    }
}

HashSet集合去重原理

如果想要对 HashSet 集合去重，需要重写两个方法： 【缺一不可】
	1. hashCode() 方法： 返回对象的hash值。根据属性计算出来的整数
	2. equals() 方法：比较两个对象的属性是否相同。

强调 hash值的概念。
	A. 同一个对象，多次调用 hashCode() 方法，hash值是相同的。
	B. 不同对象，调用 hashCode() 方法，hash值 可能相同。 （字符串 "通话" 和  "重地"）

对于 HashSet 集合去重的流程说明：

1. 先比较 hash 值是否相同。
	A. 如果 hash值不相同，系统认定为 两个对象，不同。（后面就不需要比较了）
	B. 如果 hash值相同，系统还需要比较 属性值，根据 equals() 方法去比较。
2. 在hash值相同的情况下，比较 equals值。
	A. 如果 equals 比较的结果是 true 则表示 相同。不能存放
	B. 如果 equals 比较的结果是 false则表示不同，可以存放

效果图

第03节 TreeSet集合

快速入门

//目标：学习 TreeSet 集合
public class Test04 {

    public static void main(String[] args) {

        //创建对象
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(19);
        ts.add(11);
        ts.add(17);
        ts.add(13);
        ts.add(13);
        ts.add(13);
        ts.add(13);
        ts.add(15);
        //展示结果
        for (Integer num : ts) {
            System.out.println(num);
        }
    }
}
//小结： TreeSet 集合有什么作用呢？
//1. 可以去重
//2. 可以排序

运行的结果如下：

11
13
15
17
19

内部比较器

学生类

//学生类
public class Student implements Comparable<Student>{

    String name;
    int age;

    //比较规则：
    //升序： this - o
    //降序： o - this
    @Override
    public int compareTo(Student o) {
        //想要按照 年龄升序排列
        int result = this.age - o.age;
        //当年龄相同的情况下，还要比较姓名, 按照姓名降序
        result = (result == 0)? o.name.compareTo(this.name):result;
        return result;
    }

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

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

测试类

import java.util.TreeSet;

public class Test05 {

    public static void main(String[] args) {

        TreeSet<Student> ts = new TreeSet<>();
        Student stu1 = new Student("zhanhang",18);
        Student stu2 = new Student("zhanhang",19);
        Student stu3 = new Student("wanghan",18);
        ts.add(stu1);
        ts.add(stu2);
        ts.add(stu3);
        ts.add(stu3);
        //展示结果
        for (Student stu : ts) {
            System.out.println(stu);
        }
    }
}
//Student{name='zhanhang', age=18}
//Student{name='wanghan', age=18}
//Student{name='zhanhang', age=19}

外部比较器

老师类

//老师类
public class Teacher {

    String name;
    int age;

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

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

测试类

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

//目标：学习外部比较器
public class Test06 {

    public static void main(String[] args) {

        //可以采用 外部比较器完成比较的操作
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            //升序： o1 - o2
            //降序： o2 - o1
            @Override
            public int compare(Teacher o1, Teacher o2) {
                int result = o1.age - o2.age;
                result = (result==0)?o2.name.compareTo(o1.name):result;
                return result;
            }
        });
        //创建老师的对象
        Teacher one = new Teacher("hualaoshi",33);
        Teacher two = new Teacher("huashishi",50);
        Teacher three = new Teacher("huahua",50);
        Teacher four = new Teacher("huahua",50);
        Teacher five = new Teacher("zhangsan",40);
        //添加数据到集合当中
        ts.add(one);
        ts.add(two);
        ts.add(three);
        ts.add(four);
        ts.add(five);
        //展示结果
        for (Teacher t : ts) {
            System.out.println(t);
        }
    }
}