黑马全套Java教程（七）：集合进阶

黑马全套Java教程（一）
黑马全套Java教程（二）
黑马全套Java教程（三）
黑马全套Java教程（四）
黑马全套Java教程（五）
黑马全套Java教程（六）

本博客从视频d220开始，视频链接

27 集合进阶

集合类的特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时发生改变

27.1 Collection集合

概述：

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

创建Collection集合的对象

• 多态的方式
• 具体的实现类ArrayList

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

/*
    创建Collection集合的对象
        多态的方式
        ArrayList()
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c =  new ArrayList<String>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        System.out.println(c);
    }
}

Collection集合常用方法

package myCollection.Demo1;

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

/*
    Collection集合常用方法：
        bololean add(E e)：添加元素
        boolean remove(Object 0)：从集合中移除指定的元素
        void clear()：清空集合中的元素
        boolean contains(Object o)：判断集合中是否存在指定的元素
        boolean isEmpty()：判断集合是否为空
        int size()：集合的长度，也就是集合中元素的个数

        alt+7：  打开一个窗口，能够看到类的所有信息
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();

        //1.add()添加元素
        System.out.println("add()：" + c.add("hello")); //调用add方法永远返回true
        c.add("world");
        c.add("java");
        System.out.println(c);
        System.out.println("----------------------");

        //2.remove()移除元素
        System.out.println(c.remove("hello"));
        System.out.println(c.remove("javaee"));
        System.out.println(c);
        System.out.println("---------------------");

        //4.contains()判断是否有这个元素
        System.out.println(c.contains("world"));
        System.out.println(c);
        System.out.println("-----------------------");

        //6.size()计算长度
        System.out.println(c.size());
        System.out.println("_______________________");

        //3.clear()清空集合
        c.clear();
        System.out.println(c);
        System.out.println("--------------------");

        //5.isEmpty判断是否为空
        System.out.println(c.isEmpty());
    }
}

27.2 Iterator迭代器

Iterator：迭代器，集合的专用遍历方式

• Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
• 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中的常用方法：

• E next()：返回迭代中的写一个元素
• bollean hasNext()：如果迭代具有更多元素，则返回true

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

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator<String> it = c.iterator();   //创建迭代器

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);   //实现遍历集合
        }
    }
}

案例：Collection集合存储学生对象并遍历

Studnet.java

public class Stduent {
    private String name;
    private int age;

    public Stduent() {}
    public Stduent(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 "Stduent{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Demo1.java

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

public class Demo1 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Stduent> c = new ArrayList<Stduent>();

        //创建学生对象
        Stduent s1 = new Stduent("林青霞", 30);
        Stduent s2 = new Stduent("张曼玉", 33);
        Stduent s3 = new Stduent("风清扬", 35);

        //添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //遍历集合：迭代器方式
        Iterator<Stduent> it = c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

28 List

• 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可通过整数索引访问元素，并搜索列表中的元素
• 与Set集合不同，列表通常允许重复的元素

特点：

• 有序：存储和取出的元素顺序一致
• 可重复：存储的元素可以重复

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

public class Demo1 {
    public static void main(String[] args) {
        //创建对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");
        System.out.println(list);

        //遍历
        Iterator<String>  it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

List集合特有方法

package myList.Demo1;

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

/*
    List集合特有方法：
        void add(int index, E element)：在此集合中的指定位置插入指定的元素
        E remove(int index):删除指定索引处的元素，返回被删除的元素
        E set(int index, E element):修改指定索引处的元素，返回被修饰的元素
        E get(int index):返回指定索引处的元素
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add(2, "java");

        //1.删除
        list.remove("hello");  //删除指定元素
        System.out.println(list);
        System.out.println("-----------------");

        list.remove(1);     //删除指定索引处的元素
        System.out.println(list);
        System.out.println("------------------");

        list.set(0, "hello");
        System.out.println(list);
        System.out.println("--------------");

        list.add(1,"world");

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

案例：List集合存储学生对象并遍历

学生类的代码上面有，这里便不再重复

package myList.Demo2;

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

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);

        //集合添加学生
        list.add(s1);
        list.add(s2);
        list.add(0, s3);

        //遍历：迭代器和for遍历
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------------------");

        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

并发修改异常

package myList.Demo3;

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

/*
    需求：
        我有一个集合：List<String> list = new ArrauList<String>();
        里面有三个元素：hello world java
        遍历集合，得到每一个元素，看有没有world这个元素；如果有就添加一个javaee
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<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();   //ConcurrentModificationException
            //System.out.println(s);
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);
    }
}

但是for循环实现遍历便可行

package myList.Demo3;

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

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();

        //集合中添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("world")) {
                list.add("javaee");
                break;
            }
        }

        System.out.println(list);
    }
}

28.1 ListIterator

package myList.Demo4;

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

/*
    ListIterator：列表迭代器
        通过List集合的ListIterator()方法得到，所以说它是List集合特有的迭代器
        用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

    ListIterator中的常用方法
        E next():返回迭代中的下一个元素
        boolean hasNext():如果迭代具有更多元素，则返回true
        E previous():返回列表中的上一个元素
        boolean hsaPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
        void add(E e):将指定的元素插入列表
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //遍历
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
            System.out.println(s);
        }
        System.out.println("------------------------");
        System.out.println(list);
        System.out.println("------------------------");

        while (lit.hasPrevious()) {   //逆向遍历，从后到前
            String s = lit.previous();
            System.out.println(s);
        }
    }
}

28.2 增强for循环

package myList.Demo5;

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

/*
    增强for：简化数组和collection集合的遍历
        实现Iterator接口的类允许其对象称为增强for语句的目标
        它是JDK5之后出现的，其内部原理是一个Iterator迭代器

    格式：
        for(元素数据类型 变量名：数组或者Collection集合){
            //在此处使用变量即可，该变量就是元素
        }
 */
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("---------------------");

        String[] strArr = {"hello", "world", "java"};
        for (String i : strArr) {
            System.out.println(i);
        }
        System.out.println("----------------------");

        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        //有三种遍历方式：for，迭代器（这里迭代器也有两种），增强for
        for (String i : list) {
            System.out.println(i);
        }

        //内部原理是一个Iterator迭代器，下面代码会报错   ConcurrentModificationException
        for(String s : list){
            if(s.equals("world")){
                list.add("javaee");
            }
        }
    }
}

案例：List集合存储学生对象，用三种方式遍历

学生类对象代码这里便不再重复

package myList.Demo6;

import java.util.*;

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);

        //集合添加学生
        list.add(s1);
        list.add(s2);
        list.add(1, s3);

        System.out.println(list);

        //遍历
        //1.for
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s);
        }
        System.out.println("---------------------");

        //2.增强for
        for (Student s : list) {
            System.out.println(s);
        }
        System.out.println("------------------------");

        //3.迭代器
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------------------");

        //4.
        ListIterator<Student> lit = list.listIterator();
        while (lit.hasNext()) {
            Student s = lit.next();
            System.out.println(s);
        }
    }
}

31.4 ArrayList

List集合子类特点
List集合常用子类：ArrayList, LinkedList

• ArrayList：底层数据结构是数组，查询快，增删慢
• LinkedList：底层数据结构是链表，查询慢，增删快

练习：

package myList.Demo7;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;

/*
    List集合常用子类：ArrayList  LinkedList
        ArrayList: 底层数据结构是数组，查询快，增删慢
        LinkedList: 底层数据结构是链表，查询慢，增删快

    练习：分别使用完成存储字符串并遍历
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();

        array.add("hello");
        array.add("world");
        array.add("java");

        for (String s : array) {
            System.out.println(s);
        }
        System.out.println("------------------------");

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("javaee");
        ListIterator<String> lit = linkedList.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
    }
}

案例：ArrayList集合存储学生对象用三种方法遍历

Student类不重复

package myList.Demo8;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);

        //集合添加元素
        array.add(s1);
        array.add(s2);
        array.add(1, s3);

        //遍历
        //1.for
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s);
        }
        System.out.println("--------------------------");


        //2.增强for
        for (Student s : array) {
            System.out.println(s);
        }
        System.out.println("--------------------------");

        //3.
        ListIterator<Student> lit = array.listIterator();
        while (lit.hasNext()) {
            Student s = lit.next();
            System.out.println(s);
        }
        System.out.println("--------------------------");

        //4.
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }
    }
}

31.5 LinkedList

LinkedList集合的特有功能

package myList.Demo9;

import java.util.LinkedList;

/*
    LinkedList集合的特有功能：
        public void addFirst(E e): 在该列表开头插入指定的元素
        public void addLast(E e): 将指定的元素追加到此列表的末尾

        public E getFirst(): 返回此列表中的第一个元素
        public E getLast(): 返回此列表中的最后一个元素

        public E removeFirst(): 从此列表中删除并返回第一个元素
        public E removeLast(): 从此列表中删除并返回最后一个元素
 */
public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();

        //添加
        linkedList.add("world");
        linkedList.addFirst("hello");
        linkedList.addLast("java");
        System.out.println(linkedList);
        System.out.println("----------------------");

        //get
        System.out.println("get第一个：" + linkedList.getFirst());
        System.out.println("get最后一个：" + linkedList.getLast());
        System.out.println("-----------------------");

        //remove
        System.out.println("移除第一个：" + linkedList.removeFirst());
        System.out.println("移最后一个：" + linkedList.removeLast());
        System.out.println("linkedList：" + linkedList);
    }
}

29 Set

无序，不含重复元素

Set集合特点

• 不包含重复元素
• 没有带索引的方法，所以不能使用欧通for循环遍历

package mySet.Demo1;

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

/*
    Set集合特点
        不包含重复元素的集合
        没有带索引的方法，所以不能使用普通for循环遍历

    HashSet: 对集合的迭代顺序不作任何保证
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素
        set.add("world");

        //遍历
        for (String s : set) {
            System.out.println(s);
        }
    }
}

29.1 哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

• public int hashCode()：返回对象的哈希码值

对象的哈希值特点

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的
• 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象哈希值相同

代码如下：
Student.java这里就不再写了

package mySet.Demo2;

/*
    哈希值：
        是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

    Object类中有一个方法可以获取对象的哈希值
        public int hashCode(): 返回对象的哈希码值
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("林青霞", 18);

        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());  //1239731077

        //默认情况下 不同对象的哈希值是不相同的
        Student s2 = new Student("林青霞", 18);
        System.out.println(s2.hashCode());
        System.out.println(s2.hashCode());   //557041912

        //通过方法重写，可以实现不同独享的哈希值是相同的

        System.out.println("---------------------------");
        System.out.println("hello".hashCode());
        System.out.println("world".hashCode());
        System.out.println("java".hashCode());

        System.out.println("-------------------");
        System.out.println("重地".hashCode());  //这两个一样！  字符串重写了哈希值的方法
        System.out.println("通话".hashCode());
    }
}

29.2 HashSet集合

无序，不含重复元素

package mySet.Demo3;

import java.util.HashSet;

/*
    HashSet集合的特点
        1.底层数据结构是哈希表
        2.对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
        3.没有带索引的方法，所以不能使用普通for循环遍历
        4.由于是Set集合，所以是不包含重复元素的集合
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<>();

        hs.add("hello");
        hs.add("world");
        hs.add("java");

        //不包含重复元素
        hs.add("hello");
        System.out.println(hs);

        //遍历
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

案例：HashSet集合存储学生对象并遍历

Student.java

package mySet.Demo4;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

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

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

Demo1.java

package mySet.Demo4;

import java.util.HashSet;

public class Demo1 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Student> ha = new HashSet<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        Student s4 = new Student("王祖贤", 20);  //因为是new，这里会默认s3和s4不一样， 所以需要重写HashCode和equals
        ha.add(s1);
        ha.add(s2);
        ha.add(s3);
        ha.add(s4);

        for (Student s : ha) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

29.3 LinkedHashSet集合

这个是有序的，不含重复元素

package mySet.Demo5;

import java.util.LinkedHashSet;

/*
    LinkedHashSet集合特点
        1.哈希表和链表实现的Set接口，具有可预测的迭代次序
        2.由链表保证元素有序，也就是说元素的存储和去除顺序一致
        3.由哈希表保证元素唯一，就是没有重复元素
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();

        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        linkedHashSet.add("world");

        System.out.println(linkedHashSet);

        //遍历
        for(String s:linkedHashSet){
            System.out.println(s);
        }
    }
}

29.4 TreeSet集合

有序，不含重复元素

Student.java

package mySet.Demo6;

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student s) {
//        return 0;
//        return 1;
        int num = this.age - s.age;
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

Demo1.java

package mySet.Demo6;

import java.util.TreeSet;

/*
    TreeSet集合特点
        1.元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
            TreeSet(): 根据其元素的自然排序进行排序
            TreeSet(Comparator comparator): 根据指定的比较器进行排序

        2.没有带索引的方法，所以不能使用普通for循环遍历
        3.由于是Set集合，所以不包含重复元素
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);
        //重复元素
        ts.add(30);

        System.out.println(ts);  //自然排序
        //遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

29.5 自然排序Comparable的使用

案例：

Student.java

Demo2.java

package mySet.Demo6;

import java.util.TreeSet;

/*
    存储学生对象并遍历，创建集合使用无参构造方法
    要求：按照年龄的从小到大排序，年龄相同时，按照姓名的字母顺序排序
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia", 33);
        Student s6 = new Student("linqingxia", 33);

        //添加
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        System.out.println(ts);
        //遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

29.6 比较器排序Comparator的使用

package mySet.Demo7;

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

/*
    存储学生对象并遍历，创建集合使用带参构造方法
    要求：按照年龄的从小到大排序，年龄相同时，按照姓名的字母顺序排序
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia", 33);
        Student s6 = new Student("linqingxia", 33);

        //添加
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        System.out.println(ts);
        //遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

与上一小节输出同样的结果

案例：成绩排序

Demo1.java

package mySet.Demo8;

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

/*
    需求：
        用TreeSet集合存储多个学生信息（姓名， 语文成绩， 数学成绩）， 并遍历该集合
        要求：按照总分从高到低出现

    思路：
        1.定义学生类
        2.创建TreeSet集合对象，通过比较器排序进行排序
        3.创建学生对象
        4.把学生对象添加到集合
        5.遍历集合
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
                return num3;
            }
        });

        //创建学生对象
        Student s1 = new Student("林青霞", 98, 100);
        Student s2 = new Student("张曼玉", 95, 95);
        Student s3 = new Student("王祖贤", 100, 93);
        Student s4 = new Student("成德善", 100, 97);
        Student s5 = new Student("风清扬", 98, 98);

        Student s6 = new Student("左冷禅", 97, 99);
        Student s7 = new Student("张三", 97, 99);

        //添加
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);

        System.out.println(ts);

        //遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum());
        }
    }
}

案例：不重复的随机数

package mySet.Demo9;

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

public class Demo9 {
    public static void main(String[] args) {
        //创建集合
        Set<Integer> set = new HashSet<>();
        //Set<Integer> set = new TreeSet<>();

        //创建随机数对象
        Random r = new Random();

        //判断是否10个
        while (set.size() < 10) {
            //产生一个随机数，添加到集合
            int number = r.nextInt(20) + 1;   //1-20之间
            set.add(number);
        }

        System.out.println(set);
        //遍历集合
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

30 泛型

30.1 概述

package myGeneric.Demo1;

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

//需求：Collection集合存储字符串并遍历
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        //Collection c =new ArrayList();
        Collection<String> c =new ArrayList();   //String泛型

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
//        c.add(100);    //ClassCastException

        //遍历
//        Iterator it = c.iterator();
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
//            Object obj = it.next();
//            System.out.println(obj);
//            String s = (String)it.next();
            String s = it.next();
            System.out.println(s);
        }
    }
}

30.2 泛型类

Generic.java

package myGeneric.Demo2;

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

Demo1.java

package myGeneric.Demo2;

public class Demo1 {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<>();
        g1.setT("林青霞");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<>();
        g2.setT(30);
        System.out.println(g2.getT());

        Generic<Boolean> g3 = new Generic<>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

30.3 泛型方法

版本一：
Generic.java

package myGeneric.Demo3;

public class Generic {
    public void show(String s){
        System.out.println(s);
    }

    public void show(Integer i){
        System.out.println(i);
    }

    public void show(Boolean b){
        System.out.println(b);
    }
}

Demo1.java

package myGeneric.Demo3;

public class Demo1 {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("林青霞");
        g.show(30);
        g.show(true);
        //g.show(12.34);   //报错
    }
}

版本二：
Generic.java

package myGeneric.Demo3;

//泛型类改进
public class Generic<T>{
    public void show(T t){
        System.out.println(t);
    }
}

Demo1.java

package myGeneric.Demo3;

public class Demo1 {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<>();
        g1.show("林青霞");

        Generic<Integer> g2 = new Generic<>();
        g2.show(30);

        Generic<Boolean> g3 = new Generic<>();
        g3.show(true);

        Generic<Double> g4 = new Generic<>();
        g4.show(12.34);
    }
}

版本三：
Generic.java

package myGeneric.Demo3;

//泛型方法改进
public class Generic {
    public <T> void show(T t){
        System.out.println(t);
    }
}

Demo1.java

package myGeneric.Demo3;

public class Demo1 {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("林青霞");
        g.show(30);
        g.show(true);
        g.show(12.34);
    }
}

30.4 泛型接口

Generic.java

package myGeneric.Demo4;

public interface Generic<T> {
    void show(T t);
}

GenericImpl.java

package myGeneric.Demo4;

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

Demo1.java

package myGeneric.Demo4;

public class Demo1 {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<>();
        g1.show("林青霞");

        Generic<Integer> g2 = new GenericImpl<>();
        g2.show(30);
    }
}

30.5 类型通配符

package myGeneric.Demo5;

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

public class Demo1 {
    public static void main(String[] args) {
        //类型通配符： <?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("----------------------");

        //类型通配符上限：<? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("------------------------");

        //类型通配符下限： <? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //List<? super Number> list9 = new ArrayList<Integer>();
    }
}

30.6 可变参数

package myGeneric.Demo6;

//测试类
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));

        System.out.println(sum(10, 20, 30, 40, 50));
        System.out.println(sum(10, 20, 30, 40, 50, 60));
        System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
    }

//    public static int sum(int a, int b) {
//        return a + b;
//    }
//
//    public static int sum(int a, int b, int c) {
//        return a + b + c;
//    }
//
//    public static int sum(int a, int b, int c, int d) {
//        return a + b + c + d;
//    }
//
//    public static int sum(int... a) {  //a其实是数组
//        int sum = 0;
//        for (int i : a) {
//            sum += i;
//        }
//        return sum;
//    }

    public static int sum(int b, int... a){
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }
}

<32>

30.7 可变参数的使用

package myGeneric.Demo6;
/*
    Arrays工具类中有一个静态方法：
        public static <T> List<T> saList(T... a): 返回由指定数组支持的固定大小的列表

    List接口中有一个静态方法
        public static <E> List<E> of (E... elements): 返回包含任意数量元素的不可变列表

    Set接口中有一个静态方法：
        public static <E> Set<E> of (E... elements): 返回一个包含任意数量元素的不可变集合
 */


import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class Demo2 {
    public static void main(String[] args) {
        //1.
        List<String> list = Arrays.asList("hello", "world", "java", "world");
        System.out.println(list);
        //list.add("javaee");  //java.lang.UnsupportedOperationException
        //list.remove("hello");   //UnsupportedOperationException
        list.set(2, "javaee");
        System.out.println(list);
        System.out.println("------------------");

        //2.
        List<String> list1 = List.of("hello", "world", "java", "world");
        System.out.println(list1);
        //add报错
        //remove报错
        //list1.set(3,"javaee");报错
        System.out.println("--------------------");

        //3.
        //Set<String> set = Set.of("hello", "world", "java", "hello");  //报错 IllegalArgumentException
        Set<String> set = Set.of("hello", "world", "java");
        System.out.println(set);
        //add报错
        //remove报错
        //set没有修改方法
    }
}

31 Map

31.1 概述

package myMap.Demo1;

import java.util.HashMap;
import java.util.Map;

/*
    Map集合概述
        Interface Map<K,V>  K:键的类型 V:值的类型
        将键映射到值的对象：不能包含重复的键；每个键可以映射到最多一个值
        举例：学生的学号和姓名
            01  林青霞
            02  张曼玉
            03  王祖贤

        创建Map集合的对象
            多态的方式
            具体的实现类HashMap
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //put
        map.put("01", "林青霞");
        map.put("02", "张曼玉");
        map.put("03", "王祖贤");
        map.put("03", "张三");      //替代，相当于修改

        //输出集合对象
        System.out.println(map);
    }
}

31.2 常见方法

package myMap.Demo1;

import java.util.HashMap;
import java.util.Map;

public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //put添加元素
        map.put("林青霞", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "小龙女");
        //输出
        System.out.println(map);
        System.out.println("---------------------");

        //2.remove
        System.out.println(map.remove("郭靖"));
        System.out.println(map.remove("李四"));
        System.out.println(map);
        System.out.println("-----------------------");

        //containsKey()
        System.out.println(map.containsKey("林青霞"));
        System.out.println(map.containsKey("李四"));
        System.out.println(map);
        System.out.println("-------------------------");

        //containsValue
        System.out.println(map.containsValue("张三"));
        System.out.println(map.containsValue("李四"));
        System.out.println("--------------------------");

        //size()
        System.out.println(map.size());
        System.out.println("------------------------------");

        //2.clear
        map.clear();
        System.out.println(map);
        System.out.println("-----------------------------");

        //isEmpty
        System.out.println(map.isEmpty());
    }
}

31.3 Map集合的获取功能

package myMap.Demo1;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo3 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");

        System.out.println(map);

        //get根据键获取值
        System.out.println(map.get("张无忌"));
        System.out.println(map.get("张三"));
        System.out.println("------------------------------");

        //keySet获取所有键的集合
        Set<String> keySet = map.keySet();
        System.out.println(keySet);
        System.out.println("------------------------");

        //获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);
    }
}

31.4 Map集合的遍历

方式一：

package myMap.Demo1;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo4 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");

        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

方式二：

package myMap.Demo1;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo5 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

案例：存储学生对象并遍历

package myMap.Demo2;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String, Student> hm = new HashMap<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);

        //添加
        hm.put("01", s1);
        hm.put("02", s2);
        hm.put("03", s3);

        //方式一：键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
        System.out.println("------------------------------");

        //方式二，获取键值对
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> i : entrySet) {
            String key = i.getKey();
            Student value = i.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}

案例二

这里Student需要重写hashCode和equals

package myMap.Demo3;

import java.util.HashMap;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        Student s4 = new Student("王祖贤", 20);

        //添加
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");

        System.out.println(hm);

        //遍历
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}

案例三：

package myMap.Demo4;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<HashMap<String, String>> array = new ArrayList<>();

        //创建HashMap集合对象
        HashMap<String, String> hm1 = new HashMap<>();
        hm1.put("孙策", "大乔");
        hm1.put("周瑜", "小乔");

        HashMap<String, String> hm2 = new HashMap<>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");

        HashMap<String, String> hm3 = new HashMap<>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("张三", "李四");

        array.add(hm1);
        array.add(hm2);
        array.add(hm3);

        System.out.println(array);

        //遍历
        for (HashMap<String, String> hm : array) {
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                String value = hm.get(key);
                System.out.println(key + "," + value);
            }
            System.out.println("----------------------");
        }
    }
}

案例四：

package myMap.Demo5;

import myMap.Demo3.Student;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        HashMap<String, ArrayList<String>> hm = new HashMap<>();

        //创建ArrayList集合
        ArrayList<String> sgyy = new ArrayList<>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");

        ArrayList<String> xyj = new ArrayList<>();
        xyj.add("唐僧");
        xyj.add("孙悟空");

        ArrayList<String> shz = new ArrayList<>();
        shz.add("武松");
        shz.add("鲁智深");

        hm.put("三国演义", sgyy);
        hm.put("西游记", xyj);
        hm.put("水浒传", shz);
        System.out.println(hm);

        //遍历
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for (String s : value) {
                System.out.println("\t" + s);
            }
        }
    }
}

案例五：统计字符串中每个字符出现的次数

package myMap.Demo6;

import java.util.*;

public class Demo1 {
    public static void main(String[] args) {
        //键盘录入字符
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //创建HashMap集合对象
//        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        TreeMap<Character, Integer> hm = new TreeMap<>();

        //遍历字符串
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);   //获取每一个字符

            Integer value = hm.get(key);  // 自动装箱

            if (value == null) {
                hm.put(key, 1);
            } else {
                value++;   // 这里会自动拆箱
                hm.put(key, value);
            }
        }

        //进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }

        String result = sb.toString();   //StringBuilder--->String

        System.out.println(result);
    }
}

31.5 Collections

package myMap.Demo7;

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

public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        System.out.println("正常输出："+list);

        Collections.sort(list);
        System.out.println("排序："+list);

        Collections.reverse(list);
        System.out.println("倒序："+list);

        Collections.shuffle(list);   //随机排序，每次执行结果都不一样
        System.out.println("随机排序："+list);
    }
}

案例：

package myMap.Demo8;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<Student> array = new ArrayList<>();

        Student s1 = new Student("linqingxia", 18);
        Student s2 = new Student("zhangmanyu", 19);
        Student s3 = new Student("wangzuxian", 20);
        Student s4 = new Student("zhangsan", 18);

        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        System.out.println(array);
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

31.6 模拟斗地主

package myMap.Demo9;

import java.util.ArrayList;
import java.util.Collections;

public class Demo1 {
    public static void main(String[] args) {
        //创建一个牌盒
        ArrayList<String> array = new ArrayList<>();

        //装牌
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color + number);
            }
        }
        array.add("小王");
        array.add("大王");

        System.out.println(array);

        //洗牌
        Collections.shuffle(array);
        System.out.println(array);

        //发牌
        //创建三个玩家
        ArrayList<String> lqxArray = new ArrayList<>();
        ArrayList<String> zmyArray = new ArrayList<>();
        ArrayList<String> wzxArray = new ArrayList<>();
        ArrayList<String> dpArray = new ArrayList<>();

        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);

            if (i >= array.size() - 3) {
                dpArray.add(poker);
            } else if (i % 3 == 0) {
                lqxArray.add(poker);
            } else if (i % 3 == 1) {
                zmyArray.add(poker);
            } else if (i % 3 == 2) {
                wzxArray.add(poker);
            }
        }

        //看牌
        lookPoker("林青霞", lqxArray);
        lookPoker("张曼玉", zmyArray);
        lookPoker("王祖贤", wzxArray);
        lookPoker("底牌", dpArray);
    }

    //看牌方法
    public static void lookPoker(String name, ArrayList<String> array) {
        System.out.print(name + "的牌是：");
        for (String poker : array) {
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

案例二：升级版

package myMap.Demo9;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Demo2 {
    public static void main(String[] args) {
        //创建HashMap集合，键是编号，值是牌
        HashMap<Integer, String> hm = new HashMap<>();

        //创建ArrayList存储编号
        ArrayList<Integer> array = new ArrayList<>();
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        //存储键值对，装牌
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hm.put(index, color + number);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);

        //洗牌
        Collections.shuffle(array);

        //发牌，发编号
        TreeSet<Integer> lqxSet = new TreeSet<>();
        TreeSet<Integer> zwySet = new TreeSet<>();
        TreeSet<Integer> wzxSet = new TreeSet<>();
        TreeSet<Integer> dpSet = new TreeSet<>();

        for (int i = 0; i < array.size(); i++) {
            int x = array.get(i);  //索引
            if (i >= array.size() - 3) {
                dpSet.add(x);
            } else if (i % 3 == 0) {
                lqxSet.add(x);
            } else if (i % 3 == 1) {
                zwySet.add(x);
            } else if (i % 3 == 2) {
                wzxSet.add(x);
            }
        }

        //看牌
        lookPoker("林青霞", lqxSet, hm);
        lookPoker("张曼玉", zwySet, hm);
        lookPoker("王祖贤", wzxSet, hm);
        lookPoker("底牌", dpSet, hm);
    }

    public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是：");
        for (Integer key : ts) {
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

本博客内容长了点，包含了黑马讲的所有集合类了，到视频d271截止！
只做代码记录，后续遗忘方便学习而已