17.集合进阶_public class demofpublic static void main(string[]-CSDN博客

本文链接：https://blog.csdn.net/twilight___/article/details/110521182

1.Collection

通过本章的学习得到了一个快捷键方便对源码的查看：
Alt+7，或者 View→Tool Windows→Structure
就可以查看当前类里所有方法

1.1 集合知识回顾

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

1.2 集合类体系结构

1.3 Collection 集合概述和使用

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

创建Collection集合的对象
● 多态的方式
● 具体的实现类ArrayList

public class CollectionDemo {
    public static void main(String[] args) {

        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();

        //添加元素： boolean add (E e)
        c.add("hello");
        c.add("world");
        System.out.println(c); //这个ArrayList重写了toString方法

    }
}

1.4 Collection 集合常用方法

在这里插入图片描述

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

        //boolean add(E e)：添加元素
        System.out.println(c.add("Rarity")); //由add源码可知，add方法无论怎么插入，返回值都是true
        c.add("Rarity"); // 可以插入重复值
        System.out.println(c);
        System.out.println("--------");

        //boolean remove(Object o)：从集合中移除指定的元素
        System.out.println(c.remove(("Rarity")));
        System.out.println(c.remove(("Rarity1")));
        System.out.println(c);
        System.out.println("--------");

        //void clear()：清空集合中的元素
        c.clear();
        System.out.println(c);
        System.out.println("--------");

        //boolean contains(Object o)：判断集合中是否存在指定的元素
        System.out.println(c.contains("Twilight"));
        c.add("disorder");
        System.out.println(c.contains("disorder"));
        System.out.println("--------");

        //boolean isEmpty()：判断集合是否为空
        System.out.println(c.isEmpty());
        System.out.println(c);
        System.out.println("--------");

        //int size()：集合的长度，也就是集合中元素的个数
        System.out.println(c.size());
    }
}

1.5 Collection 集合的遍历

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

Iterator中的常用方法
● E next()：返回迭代中的下一个元素
● boolean hasNext()：如果迭代具有更多元素，则返回true

public class IteratorDemo {
    public static void main(String[] args) {
        Collection<String> c= new ArrayList<String>();
        c.add("Rarity");
        c.add("Twilight");
        c.add("Rainbow");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();  //通过iterator()方法返回的是一个Iterator接口的具体实现类Itr的对象
        /*
        public Iterator<E> iterator() {
            return new Itr();
        }
        private class Itr implements Iterator<E> {
            ...
           }
        */

        //E next()：返回迭代中的下一个元素
/*        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());  // 报错：NoSuchElementException 表示被请求的元素不存在*/

        //用while循环改进判断
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

1.6 集合的使用步骤

在这里插入图片描述

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

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
① 定义学生类
② 创建Collection集合对象
③ 创建学生对象
④ 把学生添加到集合
⑤ 遍历集合（迭代器方式）

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

        //创建学生对象
        Student s1 = new Student("Rarity", 15);
        Student s2 = new Student("Twilight", 15);

        //把学生对象添加到集合
        c.add(s1);
        c.add(s2);

        //遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
//            System.out.println(it.next());
            Student s = it.next();
            System.out.println("名字：" + s.getName() + "  年龄：" + s.getAge());
        }

    }
}

2.List

2.1 List集合概述和特点

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

List集合特点
● 有序：存储和取出的元素顺序一致
● 可重复：存储的元素可以重复

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

        //添加元素
        list.add("Rarity");
        list.add("Twilight");
        list.add("Sunset");
        list.add("Starlight");

//        System.out.println(list);

        //迭代器的方式遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

    }
}

2.2 List集合特有方法

在这里插入图片描述

public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("Rarity");
        list.add("Twilight");
        list.add("Sunset");
        list.add("Starlight");

        list.add(1,"Rainbow");
//        list.add(11,"disorder");   越界异常 IndexOutOFBoundsException

        System.out.println(list.remove("Sunset"));

        System.out.println(list.set(3,"FlutterShy"));

        System.out.println(list.get(1));

//        System.out.println(list);

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

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

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
①定义学生类
②创建List集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合（迭代器方式，for循环方式）

2.3 并发修改异常

并发修改异常
● ConcurrentModificationException

产生原因
● 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致

解决方案
● 用for循环遍历，然后用集合对象做对应的操作即可
● 或使用列表迭代器

并发修改异常的源码分析：

public interface List<E> {
    Iterator<E> iterator();
    boolean add(E e);
}
public abstract class AbstractList<E>  {
    protected int modCount = 0;
}

//由控制台的错误报告，是在next方法处报错的


public class ArrayList<E> extends AbstractList<E> implements List<E>{

   public boolean add(E e) {
       modCount++;
       add(e, elementData, size);
       return true;
   }

    public Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {

        int expectedModCount = modCount;
        /*
            modCount：实际修改集合的次数
            expectedModCount：预期修改集合的次数
        */

        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

2.4 ListIterator

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

ListIterator中的常用方法
● E next()：返回迭代中的下一个元素
● boolean hasNext()：如果迭代具有更多元素，返回true
● E previous()：返回列表中的上一个元素
● boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
● void add(E e)：将指定的元素插入列表

public class ListIteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("Rarity");
        list.add("Twilight Sparkle");
        list.add("Pinkie Pie");

        //通过List集合的listIterator()方法得到
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("--------");

        //逆向遍历（不常用，知道即可）
        while (lit.hasPrevious()) {
            String s = lit.previous();
            System.out.println(s);
        }
        System.out.println("--------");

        //获取列表迭代器     解决2.3并发修改异常
        ListIterator<String> lit1 = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            if(s.equals("Twilight Sparkle")){
                lit.add("Starlight Glimmer");
            }
        }

        System.out.println(list);
    }
}

2.5 增强for循环

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

增强for的格式
● 格式：
for(元素数据类型变量名：数组或者Collection集合) {
//在此处使用变量即可，该变量就是元素
}

●int[] arr = {1,2,3,4,5};
for(int i :arr){
System.out.println(i);
}

public class ForDemo {
    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[] strArray ={"Rarity","Twilight","Pinkie"};
        for(String s : strArray){
            System.out.println(s);
        }
        System.out.println("--------");
        List<String> list = new ArrayList<String>();
        list.add("Rarity");
        list.add("Twilight");
        list.add("Pinkie");
        for (String s : list){
            System.out.println(s);
        }
        //内部原理是一个Iterator迭代器
        for(String s : list){
            if(s.equals("Rarity")){
                list.add("Starlight");   //如果抛出并发修改异常，就说明是一个Iterator迭代器
            }
        }
    }
}

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

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
① 定义学生类
② 创建List集合对象
③ 创建学生对象
④ 把学生添加到集合
⑤ 遍历集合
1.迭代器：集合特有的遍历方式
2.普通for：带有索引的遍历方式
3.增强for：最方便的遍历方式

2.6 数据结构

2.7 常见数据结构之栈

2.8 常见数据结构之队列

2.9 常见数据结构之数组

2.10 常见数据结构之链表

2.11 List集合子类特点

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

练习：
分别使用ArrayList和LinkedList完成存储字符串并遍历

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();
        array.add("Rarity");
        array.add("Twilight Sparkle");
        array.add("Pinkie pie");

        //遍历
        for(String s : array){
            System.out.println(s);
        }
        System.out.println("--------");
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Flutter Shy");
        linkedList.add("Rainbow Dash");
        linkedList.add("Apple Jack");

        for (String s : linkedList){
            System.out.println(s);
        }
    }
}

案例4.ArrayList集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
① 定义学生类
② 创建ArrayList集合对象
③ 创建学生对象
④ 把学生添加到集合
⑤ 遍历集合
1.迭代器：集合特有的遍历方式
2.普通for：带有索引的遍历方式
3.增强for：最方便的遍历方式

2.12 LinkedList集合的特有功能

在这里插入图片描述

3.Set

3.1 Set集合概述和特点

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

Set集合练习
● 存储字符串并遍历

public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象        由于Set是一个接口不能直接实例化，所以要找其实现类
        //此处使用其实现类 HashSet
        Set<String> set = new HashSet<String>();

        //添加元素
        set.add("Rarity");
        set.add("Twilight");
        set.add("Pinkie");
        set.add("Twilight"); //遍历后发现集合中只有一个Twilight

        //遍历1.迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("--------");
        //遍历2.增强for (普通for用不了)
        for(String s : set){
            System.out.println(s);
        }
    }
}

3.2 哈希值

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

Object类中有一个方法可以获取对象的哈希值
● public int hashCode()：返回对象的哈希码值

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

public class HashDemo {
    public static void main(String[] args) {
        Student s1 = new Student("Rarity",15);

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

        //默认情况下，不同对象的哈希值是不相同的,即默认情况下使用的是Object里的hashCode方法
        //通过方法重写，可以实现不同对象的哈希值是相同的
        Student s2 = new Student("Rarity",15);
        System.out.println(s2.hashCode());

        System.out.println("Disorder".hashCode());
        System.out.println("disorder".hashCode());
        System.out.println("--------");
        System.out.println("重地".hashCode()); //这两个哈希值相同1179395
        System.out.println("通话".hashCode()); //这两个哈希值相同1179395  说明String重写了hashCode方法
    }
}

3.3 HashSet集合概述和特点

HashSet集合特点
● 底层数据结构是哈希表
● 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
● 没有带索引的方法，所以不能使用普通for循环遍历（但可以使用迭代器，增强for遍历）
● 由于是Set集合，所以是不包含重复元素的集合

HashSet集合练习
● 存储字符串并遍历

3.4 HashSet集合保证元素唯一性源码分析

在这里插入图片描述
源码：

public interface Set<E> extends Collection<E> {
    boolean add(E e);
}

public class HashSet<E> extends AbstractSet<E> implements Set<E>{

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;

}

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V> {

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }


    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    //hash值是根据元素的hashCode()方法得到的
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;

        //如果哈希表未初始化，就对其进行初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        //根据对象的哈希值计算对象的存储位置，如果该位置没有元素就存储元素
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;

            /*
                存入的元素和以前的元素比较哈希值
                    如果哈希值不同，会继续向下执行，把元素添加到集合
                    如果哈希值不停，会调用对象的equals()方法进行比较
                        如果返回false，会继续往下执行，把元素添加到集合
                        如果返回true，说明元素重复，不存储
            */
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
}

HashSet集合存储元素：
● 要保证元素唯一性，需要重写hashCode()和equals()

3.5 常见数据结构之哈希表

哈希表
● JDK8之前，底层采用数据+链表实现，可以说是一个元素为链表的数组
● JDK8以后，在长度比较长的时候，底层实现了优化

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

需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求：学生对象的成员变量值相同，我们就认为同一个对象

为保证学生对象的成员变量值相同时，认定为一个元素。
需要在Student类里对hashCode()和equals()进行重写，Alt+insert自动生成即可

3.6 LinkedHashSet集合概述和特点

LinkedHashSet集合特点
● 哈希表和链表实现的Set接口，具有可预测的迭代次序
● 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
● 由哈希表保证元素唯一，也就是说没有重复的元素

3.7 TreeSet集合概述和特点

TreeSet集合特点
● 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据元素的自然排序进行排序
TreeSet(Comparator comparator)：根据指定的比较器进行排序
● 没有带索引的方法，所以不能使用普通for循环遍历
● 由于是Set集合，所以不包含重复元素的集合

Tree集合练习
● 存储整数并遍历

public class TreeSetDemo {
    public static void main(String[] args) {
//        TreeSet<int> ts = new TreeSet<int>();   报错，因为<>内只能是引用类型，如何解决？
        TreeSet<Integer> ts = new TreeSet<>();  //所有基本数据类型存储到集合中时，使用的是其包装类型
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(20);
        //遍历集合
        for (Integer i : ts){
            System.out.println(i);
        }
    }
}

3.8 自然排序Comparable的使用

● 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
● 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论
● 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
● 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
● 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

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 int compareTo(Student o) {
//        return 0;  //认为是重复元素，不添加
//        return 1;  //返回的是正数，就按照升序来存储
//        return -1;  //返回的负数，就按照降序
        //按照年龄从小到大排序
        int num = this.age - o.age;   //按照年龄升序  这个this.age指的应该是插入元素的age  o.age则是集合中本有的元素的age
//        int num = o.age - this.age;  //按照年龄降序
//        return num;
        int num2 = num == 0 ? this.name.compareTo(o.name) : num; //当年龄相同返回的是name对比后的值，年龄不同就返回num
        return num2;
    }
}

3.9 比较器排序Comparator的使用

● 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
● 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论
● 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
● 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
● 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { //匿名内部类的方式
            @Override
            public int compare(Student s1, Student s2) {
            	//在这里 s1相当于this,s2相当于s
                int num = s1.getAge()-s2.getAge();
                int num1 = num==0 ? s1.getName().compareTo(s2.getName()) : num;
                return num1;
            }
        });
        Student s1 = new Student("Rarity",15);
        Student s2 = new Student("Twilight",14);
        Student s3 = new Student("FlutterShy",16);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);

        for(Student s : ts){
            System.out.println("name:" +s.getName() + "   age:" + s.getAge());
        }

    }
}

案例6：成绩排序

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

案例7：不重复的随机数

需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

思路：
① 创建Set集合对象
② 创建随机数对象
③判断集合的长度是不是小于10
是：产生一个随机数，添加到集合
回到3继续
④遍历集合

public class TreeSetDemo {
    public static void main(String[] args) {
        Random r = new Random();
//        Set<Integer> ts = new TreeSet<Integer>(); //有序
        Set<Integer> ts = new HashSet<>(Integer); //无序
        while(ts.size()<10){
            ts.add(r.nextInt(20) + 1);
        }
        for(int i : ts){
            System.out.println(i);
        }
    }
}

4.泛型

4.1 泛型概述

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
他的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别称为泛型类、泛型方法、泛型接口

泛型定义格式：
● <类型>：指定一种类型的格式。这里的类型可以看成是形参
● <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
● 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处：
● 把运行时期的问题提前到了编译时间
● 避免了强制类型转换

/*
    需求：Collection集合存储字符串并遍历
 */
public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
//        Collection c = new ArrayList();
        Collection<String> c = new ArrayList<>();
        c.add("Rarity");
        c.add("Twilight");
        c.add("Flutter");
//        c.add(100);    //如果不使用泛型，会在执行后才会报错这句话
//        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(); //ClassCastException
            String s = it.next();
            System.out.println(s);
        }
    }
}

4.2 泛型类

泛型类的定义格式：
● 格式：修饰类 class 类名<类型> { }
● 范例：public class Generic< T> { }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

public class GenericDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("Rarity");
        System.out.println(s.getName());
        Teacher t = new Teacher();
        t.setAge(30);
//        t.setAge("30");  会报错，因为setAge只接受Integer类型的参数，那怎么解决呢？
        System.out.println(t.getAge());

        System.out.println("---------");//上面需要定义两个类，才能完成输出，下面只需要定义一个泛型类，就能完成输出

        Generic<String> g1 = new Generic<>();
        g1.setT("Twilight");
        System.out.println(g1.getT());
        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());
    }
}

4.3 泛型方法

泛型方法的定义格式：
● 格式：修饰符 <类型> 返回值类型方法名(类型变量名) { }
● 范例：public < T> void show(T t) { }

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

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

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

public class GenericDemo {
    public static void main(String[] args) {
/*        Generic g = new Generic();
        g.show("Rarity");
        g.show(30);
        g.show(true);*/
//        g.show(1.1);   报错，由于没有重载这种格式的方法

/*        Generic<String> g1 = new Generic<String>();
        g1.show("Rarity");
        Generic<Integer> g2 = new Generic<Integer>();
        g2.show(15);
        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.show(true);
        Generic<Double> g4 = new Generic<Double>();
        g4.show(1.1);         //一个类型要写一次类型名，过于繁琐
*/
        Generic g = new Generic();
        g.show("Rarity");
        g.show(15);
        g.show(true);
        g.show(1.1);
    }
}

4.4 泛型接口

泛型接口的定义格式：
● 格式：修饰符interface 接口名<类型> { }
● 范例：public interface Generic< T> { }

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

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

4.5 类型通配符

为了表示各种泛型List的父类，可以使用类型通配符
● 类型通配符： <?>
● List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
● 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
● 类型通配符上限：<? extend 类型>
● List<? extends Number>：它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
● 类型通配符下限：<? super 类型>
● List<? super Number>：他表示的类型是Number或者其父类型

public class GenericDemo {
    public static void main(String[] args) {
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<String>();
        System.out.println("--------");
//        List<? extends Number> list4 = new ArrayList<Object>();  报错，因为上限是Number,所以不能是Number的父类
        List<? extends Number> list4 = new ArrayList<Number>();
        List<? extends Number> list5 = new ArrayList<Integer>();
        System.out.println("--------");
        List<? super Number> list6 = new ArrayList<Object>();
        List<? super Number> list7 = new ArrayList<Number>();
//        List<? super Number> list8 = new ArrayList<Integer>(); 报错
    }
}

4.6 可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
● 格式：修饰符返回值类型方法名(数据类型…变量名) { }
● 范例：public static int sum(int…a) { }

可变参数注意事项
● 这里的变量其实是一个数组
● 如果一个方法有多个参数，包括可变参数，可变参数要放在最后

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3));
        System.out.println(sum(1, 2, 3, 4));
        System.out.println(sum(1, 2, 3, 4, 6, 7, 8, 912, 3, 4, 123, 2));

    }
/*
    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;
    }
*/
/*    public static int sum1(int...a,int b){  报错，因为可变参数要放在后面，不然会导致a把所有参数都接受了，b没有参数
        //...
        return 0;
    }*/

    public static int sum1(int b,int...a){
        //...
        return 0;
    }

    public static int sum(int... a) {
//        System.out.println(a);     // 输出了[I@3f99bd52   [表示是个数组  I表示是Integer类型
        int sum = 0;
        //a是个数组，所以可以用增强for来遍历
        for (int num : a) {
            sum += num;
        }
        return sum;
    }
}

4.7 可变参数的使用

Arrays工具类中有一个静态方法：
● public static < T > List < T > asList(T…a)：返回由指定数组支持的固定大小的列表
● 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法：
● public static < E > List < E > of(E…elements)：返回包含任意数量元素的不可变列表
● 返回的集合不能做增删改操作

Set接口中有一个静态方法：
● public static < E > Set < E > of(E…elements)：返回一个包含任意数量元素的不可变集合
● 在给元素的时候，不能给重复的元素
● 返回的集合不能做增删操作，没有修改的方法

public class ArgsDemo {
    public static void main(String[] args) {
        // public static < T > List < T > asList(T...a)：返回由指定数组支持的固定大小的列表
        List<String> list = Arrays.asList("Rarity", "Twilight", "Pinkie");
//        list.add("Rainbow"); //UnsupportedOperationException 抛出不支持的操作
//        list.remove("Pinkie");UnsupportedOperationException 抛出不支持的操作
        list.set(1, "AJ"); //可行
//由此可知，asList集合方法不能用添加删除方法
        System.out.println(list);
        System.out.println("--------");

        //public static < E >  List < E > of(E...elements)：返回包含任意数量元素的不可变列表
        list = List.of("Rarity", "Twilight", "Rainbow");
        System.out.println(list);
        //同样不可删除添加 UnsupportedOperationException 抛出不支持的操作
//        list.set(1, "Starlight");  UnsupportedOperationException 插入也不可行
        System.out.println("--------");

        //public static < E > Set < E > of(E...elements)：返回一个包含任意数量元素的不可变集合
//        Set<String> set = Set.of("Rarity", "Twilight", "Rainbow","Rainbow"); //报错 不能有重复元素  IllegalArgumentException 抛出表示一种方法已经通过了非法或不正确的参数
        Set<String> set = Set.of("Rarity", "Twilight", "Rainbow");
        //不能做增删操作 UnsupportedOperationException 抛出不支持的操作
        //set方法更是不行，因为Set集合没有索引，不能用set方法
        System.out.println(set);
    }
}

5.Map

5.1 Map集合概述和使用

Map集合概述
● Interface Map<K,V> k：键的类型，V：值得类型
● 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
● 举例：学生的学号和姓名
pony001 Rarity
pony002 Twilight
pony003 FlutterShy

创建Map集合的对象
● 多态的方式
● 具体的实现类HashMap

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

        //V put(K key,V value),将指定的值与该映射中的指定键相关联
        map.put("Pony 001","Rarity");
        map.put("Pony 002","Twilight");
        map.put("Pony 003","Flutter");
        map.put("Pony 003","Rainbow");//put既可以用来添加元素，也可以用来修改对应键的元素
        System.out.println(map);
    }
}

5.2 Map集合的基本功能

在这里插入图片描述

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

        //V put(K key,V value),将指定的值与该映射中的指定键相关联
        map.put("Pony 001", "Rarity");
        map.put("Pony 002", "Twilight");
        map.put("Pony 003", "Flutter");
        map.put("Pony 003", "Rainbow");//put既可以用来添加元素，也可以用来修改对应键的元素

        // V remove(Object key)：根据键删除键值对元素
//        System.out.println(map.remove("Pony 001"));
//        System.out.println(map.remove("Pony 004"));

        // void clear()：移除所有的键值对元素
//        map.clear();

        // boolean containsKey(Object key)：判断集合是否包含指定的键
//        System.out.println(map.containsKey("Pony 003"));
//        System.out.println(map.containsKey("Pony 004"));

        // boolean containsValue(Object value)：判断集合是否包含指定的值
//        System.out.println(map.containsValue("Rarity"));

        // boolean isEmpty()：判断集合是否为空
//        System.out.println(map.isEmpty());

        //int size()：集合的长度，也就是集合中键值对的个数
//        System.out.println(map.size());
        
        System.out.println(map);
    }
}

5.3 Map集合的获取功能

在这里插入图片描述

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String, String>();
        map.put("Pony 001", "Rarity");
        map.put("Pony 002", "Twilight");
        map.put("Pony 003", "Flutter");

        // V get(Object key)：根据键获取值
        System.out.println(map.get("Pony 001"));
        System.out.println(map.get("Pony 004")); //不存在时返回null
        System.out.println("--------");
        //Set<K> keySet()：获取所有键的集合
        Set<String> keySet = map.keySet();
        for(String s : keySet){
            System.out.println(s);
        }
        System.out.println("--------");
        //Collection<V> values()：获取所有值的集合
        Collection<String> values = map.values();
        for (String s : values){
            System.out.println(s);
        }
    }
}

5.4 Map集合的遍历(方式1)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
遍历思路
● 把所有的丈夫给集中起来
● 遍历丈夫的集合，获取到每一个丈夫
● 根据丈夫去找对应的妻子

转换为Map集合中的操作：
● 获取所有键的集合。用keySet()方法实现
● 遍历键的集合，获取到每一个键。用增强for实现
● 根据键去找值。用get(Object key)方法实现

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("Pony 001", "Rarity");
        map.put("Pony 002", "Twilight");
        map.put("Pony 003", "Flutter");
        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

5.5 Map集合的遍历(方式2)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
遍历思路
● 获取所有结婚证的集合
● 遍历结婚证的集合，得到每一个结婚证
● 根据结婚证获取丈夫和妻子

转换为Map集合中的操作：
● 获取所有键值对对象的集合
    怎么获取？
    Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
● 遍历键值对对象的集合，得到每一个键值对对象
    用增强for实现，得到每一个Map.Entry
● 根据键值对对象获取键和值
    用 getKey() 得到键
    用 getValue() 得到值

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("Pony 001", "Rarity");
        map.put("Pony 002", "Twilight");
        map.put("Pony 003", "Flutter");
        //获取所有键值对对象的集合
        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);
        }
    }
}

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

需求：创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历

思路：
① 定义学生类
② 创建HashMap集合对象
③ 创建学生对象
④ 把学生添加到集合
⑤ 遍历集合
方式1：键找值
方式2：键值对对象找键和值

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

需求：创建一个HashMap集合，键是学生对象(Student)，值是居住地(String)。存储多个键值对元素，并遍历。
要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

思路：
① 定义学生类
② 创建HashMap集合对象
③ 创建学生对象
④ 把学生添加到集合
⑤ 遍历集合
⑥ 在学生类中重写两个方法，以保证键的唯一性
hashCode()
equals()

案例10：ArrayList集合存储HashMap元素并遍历

需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历

思路：
① 创建ArrayList集合
② 创建HashMap集合，并添加键值对元素
③ 把HashMap作为元素添加到ArrayList集合
④ 遍历ArrayList集合

public class ArrayListIncludeHashMapDemo {
    public static void main(String[] args) {
        ArrayList<HashMap<String,String>> arrayList = new ArrayList<HashMap<String,String>>();
        HashMap<String,String> hashMap1 = new HashMap<String, String>();
        HashMap<String,String> hashMap2 = new HashMap<String, String>();
        HashMap<String,String> hashMap3 = new HashMap<String, String>();
        hashMap1.put("Rarity","AJ");
        hashMap1.put("Rarity1","AJ1");
        hashMap2.put("RainbowDash","FlutterShy");
        hashMap2.put("RainbowDash1","FlutterShy1");
        hashMap3.put("TwilightSparkle","PinkiePie");
        hashMap3.put("TwilightSparkle1","PinkiePie1");
        arrayList.add(hashMap1);
        arrayList.add(hashMap2);
        arrayList.add(hashMap3);
        //ArrayList迭代器遍历加上HashMap由键到值增强for遍历
/*        Iterator<HashMap> it = arrayList.iterator();
        while(it.hasNext()){
            HashMap hm = it.next();
            Set<String> keySet = hm.keySet();
            for(String key : keySet){
                String value = (String) hm.get(key);
                System.out.println(key + "," + value);
            }
        }*/
        //ArrayList增强for遍历加HashMap由键值对到键和值
        for(HashMap<String,String> hm : arrayList){
            Set<Map.Entry<String, String>> entrySet = hm.entrySet();
            for(Map.Entry<String, String> me : entrySet){
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key + "," + value);
            }
        }
    }
}

案例11：HashMap集合存储ArrayList元素并遍历

需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList，每一个ArrayList的元素是String，并遍历
思路：
① 创建HashMap集合
② 创建ArrayList集合，并添加元素
③ 把ArrayList作为元素添加到HashMap集合
④ 遍历HashMap集合

public class HashMapIncludeArrayListDemo {
    public static void main(String[] args) {
        HashMap<String, ArrayList> hashMap = new HashMap<>();
        ArrayList<String> arr1 = new ArrayList<>();
        ArrayList<String> arr2 = new ArrayList<>();
        ArrayList<String> arr3 = new ArrayList<>();
        arr1.add("Rarity");arr1.add("Twilight");
        arr2.add("PinkiePie");arr2.add("FlutterShy");
        arr3.add("RainbowDash");arr3.add("AJ");
        hashMap.put("Pony Group 001",arr1);
        hashMap.put("Pony Group 002",arr3);
        hashMap.put("Pony Group 003",arr2);

        Set<Map.Entry<String, ArrayList>> entrySet = hashMap.entrySet();
        for(Map.Entry<String, ArrayList> me: entrySet){
            ArrayList arr = me.getValue();
            System.out.println(me.getKey());
            Iterator<String> it = arr.iterator();

            while(it.hasNext()){
                System.out.println("\t"+it.next());
            }

        }
    }
}

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

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数
举例：键盘录入"aababcabcdabcde"
在控制台输出：“a(5)b(4)c(3)d(2)e(1)”

分析：
① 我们可以把结果分成几个部分来看：a(5),b(4),c(3),d(2),e(1)
② 每一个部分可以看成是：字符和字符对应的次数组成
③ 这样的数据，我们可以通过HashMap集合来存储，键是字符，值是字符出现的次数

注意：键是字符，类型不应该用char，而是Character；
值是字符出现的次数，不应该用int，而是Integer

思路：
① 键盘录入一个字符串
② 创建HashMap集合，键是Character，值是Integer
③ 遍历字符串，得到每一个字符
④ 拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果返回值不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
⑤ 遍历HashMap集合，得到键和值，按照要求进行拼接
⑥ 输出结果

public class HashMapDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        HashMap<Character,Integer> hashMap = new HashMap<Character, Integer>();

        for (int i=0;i<s.length();i++){
            char key = s.charAt(i);
            if(hashMap.containsKey(key)){
                int value = hashMap.get(key);
                hashMap.put(key,value+1);
            }else {
                hashMap.put(key,1);
            }
        }
/*        Set<Character> keySet = hashMap.keySet();
        for(Character key : keySet){
            int num = hashMap.get(key);
            System.out.print(key+"("+num+")");
        }*/
        //或使用StringBuilder来进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hashMap.keySet();
        for(char key : keySet){
            int value = hashMap.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

6.Collections

6.1 Collections概述和使用

Collections类的概述
● 是针对集合操作的工具类

Collections类的常用方法
● public static <T extends Compara<? super T>> void sort(List< T > list)：将指定的列表按升序排序
● public static void reverse(List<?> list)：反转指定列表中元素的顺序
● public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(10);list.add(20);list.add(30);list.add(40);list.add(50);
        Collections.sort(list);
        System.out.println(list);
        System.out.println("--------");

        Collections.reverse(list);
        System.out.println(list);
        System.out.println("--------");

        Collections.shuffle(list);
        System.out.println(list);
        System.out.println("--------");
    }
}

案例13.ArrayList存储学生对象并排序

需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

案例14.模拟斗地主

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌

思路：
① 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
② 往牌盒里面装牌
③ 洗牌，也就是把牌打散，用Collections的shuffle()方法实现
④ 发牌，也就是遍历集合，给三个玩家发牌
⑤ 看牌，也就是三个玩家分别遍历自己的牌

案例15.模拟斗地主升级版

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序

思路：
① 创建HashMap，键是编号，值是牌
② 创建ArrayList，存储编号
③ 创建花色数组和点数数组
④ 从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
⑤ 洗牌(洗的是编号)，用Collocations的shuffle()方法实现
⑥ 发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
在这里插入图片描述