Java学习笔记（六）java集合

学习笔记6

看的是黑马程序员的课，生动有趣，特别是最后的斗地主案例差点让我没绷住ww

集合

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

2. 集合类体系结构：单列数据存储称之为Collection集合，双列数据存储称之为Map集合

   Collection集合中List集合里的数据可重复，Set集合里的数据不可重复

   重点学习List集合下的ArrayList和LinkedList，Set集合下的HashSet和TreeSet，Map集合下的HashMap

3. Collection，Map，List，Set都是接口，剩下的都是实现类

一、 Collection集合

1. 概述

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

2. 创建Collection集合的对象

1. 多态的方式

2. 具体的实现类ArrayList

3. 示例代码

   package com.Collection.lesson01;
    
    
   import java.util.ArrayList;
   import java.util.Collection;
    
   //以多态的方式创建Collection集合的对象
   public class Demo01 {
    
       public static void main(String[] args) {
    
           Collection<String> c = new ArrayList<>();
    
           //添加元素： add(E e)
           c.add("hello");
           c.add("world");
           c.add("java");
    
           //输出
           System.out.println(c);
    
       }
   }
    

3. Collection集合常用方法

• boolean add(E e)//添加元素

• boolean remove(Object o)//从集合中移除指定的元素

• void clear()//清空集合中的元素

• boolean contains(Object o)//判断集合中是否存在指定的元素

• boolean isEmpty()//判断集合是否为空

• int size()//集合的长度，也就是集合中元素的个数

• 示例代码：

  package com.Collection.lesson01;
   
  import java.util.ArrayList;
  import java.util.Collection;
   
  public class Demo02 {
      public static void main(String[] args) {
   
          //创建集合对象
          Collection<String> c = new ArrayList<>();
   
          //Alt + 7 查看项目结构
   
          //boolean add(E e): 添加元素
          System.out.println(c.add("hello"));
          System.out.println(c.add("world"));
          System.out.println(c.add("java"));//返回值为true
   
          c.add("hello");
          c.add("world");
          c.add("java");
          System.out.println(c);
          System.out.println("====================");
   
          //boolean remove(E e): 移除元素
          System.out.println(c.remove("hello"));//从头开始移除，一次移除一个
          System.out.println(c.remove("javaee"));
          c.remove("java");
          System.out.println(c);
          System.out.println("====================");
   
          //void clean(): 清空元素
          c.clear();
          System.out.println(c);
          System.out.println("====================");
   
          //boolean contains(object o): 判断集合中是否有这个元素
          System.out.println(c.contains("hello"));
          System.out.println("====================");
   
          //boolean isEmpty(): 判断集合内是否为空
          System.out.println(c.isEmpty());
          System.out.println("====================");
   
          //int size(): 集合的长度
          System.out.println(c.size());
      }
  }
   

4. Collection 集合的遍历

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

• Iteratoriterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到

• 迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖于集合而存在的

• 示例代码：

  package com.Collection.iterator;
   
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
   
  public class Demo01 {
   
      public static void main(String[] args) {
          Collection<String> c = new ArrayList<>();
          c.add("hello");
          c.add("world");
          c.add("java");
   
          //Iterator<E> iterator() 返回此集合中的迭代器，通过集合的iterator（）方法得到
          Iterator<String> iterator = c.iterator();
   
          //E next()： 返回迭代的最后一个元素
  /*
   
          System.out.println(iterator.next());
          System.out.println(iterator.next());
          System.out.println(iterator.next());
          //System.out.println(iterator.next());//NoSuchElementException: 表示被请求的元素不存在
  */
   
          //boolean hasNext()方法判断迭代的最后一个是否存在
  /*        if(iterator.hasNext()){
              System.out.println(iterator.next());
          }
          if(iterator.hasNext()){
              System.out.println(iterator.next());
          }
          if(iterator.hasNext()){
              System.out.println(iterator.next());
          }
          if(iterator.hasNext()){
              System.out.println(iterator.next());
          }
      */
          //循环遍历
          while (iterator.hasNext()){
              String s = iterator.next();
              System.out.println(s);
          }
      }
  }

5. 集合的使用步骤

步骤1：创建集合对象

步骤2：添加元素

• 创建元素

• 添加元素到集合

  合并为添加元素到集合

步骤3：遍历集合

• 通过集合对象获取迭代器对象
• 通过迭代器对象的hasNext() 方法判断是否还有元素
• 通过迭代器对象的next() 方法获取下一个元素

6. 案例：Collection集合存储

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

示例代码：

Student.java

package com.Collection.demo;
 
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 int getAge() {
        return age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 

Demo.java

package com.Collection.demo;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class Demo {
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<Student>();
 
 
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",20);
 
        //犯了个错误，忘了创建main方法
        c.add(s1);
        c.add(s2);
        c.add(s3);
 
        //使用迭代器遍历集合
        //这里要标一下<Student>, 要不然需要使用Object类强转
        Iterator<Student> iterator = c.iterator();
        while (iterator.hasNext()){
 
            //使用一个学生对象来存放当前的学生元素
            Student s = iterator.next();
 
            System.out.println("学生的姓名为：" + s.getName() +"\t"+
                    "学生的年龄为：" + s.getAge());
        }
    }
}
 

二、List集合

1. 概述

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

2. 特点

1. 有序：存储和取出的元素顺序一致

2. 可重复：存储的元素可以重复

3. 示例代码：

   Demo01.java

   package com.list.lesson01;
    
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
    
   public class Demo01 {
    
       public static void main(String[] args) {
    
           //创建一个集合对象
           List<String> list = new ArrayList<>();
    
           list.add("java1");
           list.add("java2");
           list.add("java3");
           list.add("java3");//可重复
    
           System.out.println(list);
           System.out.println("===============");
    
           //采用迭代器的方式遍历list
           Iterator<String> iterator = list.iterator();
           while (iterator.hasNext()){
               String s = iterator.next();
               System.out.println(s);
           }
       }
   }

3. List集合特有方法

1. void add(int index,E element)：在此集合中的指定位置插入指定的元素

2. E remove(int index)：删除指定索引处的元素，返回被删除的元素

3. E set(int index,E element)：修改指定索引处的元素，返回被修改的元素

4. E get(int index)：返回索引处的元素

5. 示例代码：

   Demo02.java

   package com.list.lesson01;
    
   import java.util.ArrayList;
   import java.util.List;
    
   public class Demo02 {
       public static void main(String[] args) {
    
           //创建集合对象
           List<String> list = new ArrayList<String>();
           list.add("java01");
           list.add("java02");
           list.add("java03");
           System.out.println(list);
           System.out.println("=======================");
    
           //boolean add(int index, E element )在指定位置插入元素
           list.add(1,"java04");
           //list.add(11,"java05");
           //IndexOutOfBoundsException
           System.out.println(list);
           System.out.println("=======================");
    
           //boolean remove(): 移除指定位置元素
           list.remove(1);
           System.out.println(list);
           System.out.println("=======================");
    
           //E set(int index, E element ): 修改指定索引处的元素，返回被修改的元素
           System.out.println(list.set(1, "java04"));
           System.out.println(list);
           System.out.println("=======================");
    
           //E get(int index ): 返回指定索引的元素
           System.out.println(list.get(1));
           System.out.println(list);
           System.out.println("=======================");
    
           //通过索引遍历集合
           for (int i = 0; i < list.size(); i++) {
               String s = list.get(i);
               System.out.println(s);
           }
       }
   }
    

   *注意索引越界异常！！

4. 案例

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

示例代码：

Student.java同上

Demo03.java

package com.list.lesson01;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Demo03 {
    public static void main(String[] args) {
 
        //创建集合类
        List<Student> list = new ArrayList<>();
        //创建学生类
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",20);
 
        //存储学生类
        list.add(s1);
        list.add(s2);
        list.add(s3);
 
 
        //遍历学生类  迭代器方式
        Iterator<Student> iterator = list.iterator();
        while (iterator.hasNext()){
            Student s = new Student();
            s = iterator.next();
            System.out.println("学生姓名为："+s.getName()+"\t"
                    + "学生年龄为：" + s.getAge());
        }
        System.out.println("========================");
 
        //遍历学生类  for循环
        for (int i = 0; i < list.size(); i++) {
            Student s = new Student();
            s = list.get(i);
            System.out.println("学生姓名为："+s.getName()+"\t"
                    + "学生年龄为：" + s.getAge());
        }
        
        //遍历学生类 增强for循环
        for (Student s : list) {
            System.out.println("学生姓名为："+s.getName()+"\t"
                    + "学生年龄为：" + s.getAge());
        }
    }
}
 

5. 并发修改异常

• ConcurrentModificationException
• 产生原因：迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
• 解决方案：1. 用for循环遍历（可以在循环体里面直接添加）2. 迭代器遍历中只判断不添加，在循环体外再添加（是我一开始想的，然后没有遇到这个异常）

6. ListIterator 列表迭代器

1. 通过List集合的listIterator() 方法得到，所以说它是List集合特有的迭代器

2. 用于允许程序员沿着任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

3. 常用方法

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

4. 示例代码：

   ListIteratorDemo.java

package com.list.lesson01;
 
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
 
public class ListIteratorDemo {
 
    public static void main(String[] args) {
 
        //创建一个集合对象
        List<String> list = new ArrayList<>();
 
        list.add("java1");
        list.add("java2");
        list.add("java3");
 
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = listIterator.next();
            System.out.println(s);
        }
        System.out.println("======================");
 
        while (listIterator.hasPrevious()){
            String s = listIterator.previous();
            System.out.println(s);
        }
        System.out.println("======================");
 
        //获取列表迭代器
        while (listIterator.hasNext()){
            String s = listIterator.next();
            if (s.equals("java1")){
                listIterator.add("java0");//在当前迭代的地方加上元素
            }
        }
        System.out.println(list);
    }
}

7. 增强for循环

• 实现Iterator接口的类允许其对想成为增强型for语句的目标
• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
• 已经在java基础里面学过，这里大致掠过

8. 常见数据结构：栈-队列-数组-链表

• 栈
  • 数据进入栈模型的过程称为：压/进栈
  • 数据离开栈模型的过程称为：弹/出栈
  • 先进后出
• 队列
  • 数据从后端进入队列模型的过程成为：入队列
  • 数据从前端离开队列模型的过程称为：出队列
  • 先进先出
• 数组
  • 查询效率高，删除效率低
• 链表
  • 增删快，查询效率低

9. LIst集合子类特点

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

练习：分别使用ArrayList‘和LinkedList遍历字符串

package com.list.lesson01;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
 
public class Demo05 {
    public static void main(String[] args) {
 
        //创建一个集合对象
        ArrayList<String> list1 = new ArrayList<>();
 
        list1.add("java1");
        list1.add("java2");
        list1.add("java3");
 
        //遍历
        for (String s : list1){
            System.out.println(s);
        }
        System.out.println("==================");
 
        for (int i = 0; i < list1.size(); i++) {
            String s = list1.get(i);
            System.out.println(s);
        }
        System.out.println("==================");
 
        Iterator<String> iterator = list1.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("==================");
 
 
        //创建一个集合对象
        LinkedList<String> list2 = new LinkedList<>();
 
        list2.add("java1");
        list2.add("java2");
        list2.add("java3");
 
        //注意自动补齐的是否是你需要的
        Iterator<String> iterator1 = list2.iterator();
        while (iterator1.hasNext()){
            String s = iterator1.next();
            System.out.println(s);
        }
        System.out.println("==================");
 
        for (String s : list2){
            System.out.println(s);
        }
        System.out.println("==================");
 
        for (int i = 0; i < list2.size(); i++) {
            String s = list2.get(i);
            System.out.println(s);
        }
    }
}

10. LinkedList集合的特有功能

• public void addFirst(E e)：在该列表开头插入指定的元素
• public void addLast(E e)：在该列表末尾插入指定的元素
• public E getFirst()：返回此列表的第一个元素
• public E getLast()：返回此列表的最后一个元素
• public E removeFirst()：从此列表删除并返回最后一个元素
• public E removeLast()：从此列表删除并返回最后一个元素
• 示例代码：

package com.list.lesson01;
 
import java.util.LinkedList;
 
public class Demo06 {
    public static void main(String[] args) {
 
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
 
        //public void addFirst(E e)：在该列表开头插入指定的元素
        linkedList.addFirst("javase");
        System.out.println(linkedList);
        System.out.println("=================");
 
        //public void addLast(E e)：在该列表末尾插入指定的元素
        linkedList.addLast("javaee");
        System.out.println(linkedList);
        System.out.println("=================");
 
        //public E getFirst()：返回此列表的第一个元素
        System.out.println(linkedList.getFirst());
        System.out.println("=================");
 
        //public E getLast()：返回此列表的最后一个元素
        System.out.println(linkedList.getLast());
        System.out.println("=================");
 
        //public E removeFirst()：删除此列表的一个元素并返回第一个元素
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList);
        System.out.println("=================");
 
        //public E removeLast()：删除此列表的最后一个元素并返回最后一个元素
        System.out.println(linkedList.removeLast());
        System.out.println(linkedList);
        System.out.println("=================");
 

三、Set集合

1. 特点

• 不包含重复元素的集合
• 没有带索引的方法，所有不能使用普通for循环遍历
• 存储字符串并遍历，示例代码：

package com.collection.set;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class SetDemo01 {
 
    public static void main(String[] args) {
 
        //创建集合对象
        //Hashset: 对集合的迭代顺序不作任何保证
        Set<String> set = new HashSet<String>();
 
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        set.add("java");
 
        //增强for
        for (String s : set){
            System.out.println(s);
        }/*
            world
            java
            hello
            无重复元素
         */
 
        //迭代器方式
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

2. 哈希值

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

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

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

package com.collection.set;
 
import java.util.HashSet;
import java.util.Set;
 
public class HashDemo01 {
    public static void main(String[] args) {
 
        //创建对象
        Set<Student> set = new HashSet<Student>();
 
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
 
        //获取哈希值
        System.out.println(s1.hashCode()); //460141958
        //多次调用hashCode()哈希值是相同的
        //System.out.println(s1.hashCode()); //460141958
        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写可以实现相同的哈希值
        System.out.println(s2.hashCode()); //1163157884
        System.out.println(s3.hashCode()); //1956725890
 
        //String 方法重写了hashCode方法
        System.out.println("重地".hashCode()); //1179395
        System.out.println("通话".hashCode()); //1179395
    }
}

3. HashSet集合概述和特点

HashSet集合特点

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

练习

• 存储字符串并遍历
• 示例代码：

package com.collection.set;
 
import java.util.HashSet;
import java.util.Iterator;
 
public class HashSetDemo01 {
    public static void main(String[] args) {
 
        //创建对象
        HashSet<String> hs = new HashSet<>();
 
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
 
        //增强for遍历
        for (String s : hs){
            System.out.println(s);
        }
 
        //迭代器遍历
        Iterator<String> it = hs.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

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

HashSet集合添加一个元素的过程：

1. 调用对象的hashCode()方法获取对象的哈希值
2. 根据对象的哈希值计算对象的存储位置
3. 判断该位置是否有元素存在
4. 如果没有元素则将元素存储到该位置
5. 如果有则遍历该位置的所有元素，与新存入的元素比较哈希值是否相同
6. 都不相同则将元素存储到该位置
7. 有相同的则调用equals方法比较对象内容是否相同
8. 返回false则将元素存储到该位置
9. 返回true则说明元素重复，不进行存储

HashSet集合存储元素：

• 要保证元素唯一性，需要重写hashCode()和equals()

5. 常见数据结构：哈希表

• JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组（数组长度默认为16）
• JDK8以后，在长度比较长的时候，底层实现了优化

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

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

要求：学生对象的成员变量值相同，我们就认为是同一个对象

注意：Student类需要重写hashCode()和equals()方法，否则不能完成需求。重写在IDEA中可以直接使用快捷键Alt + Insert一键生成

示例代码：

package com.collection.set;
 
import java.util.Objects;
 
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 int getAge() {
        return age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    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;
        return age == student.age && Objects.equals(name, student.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package com.collection.set;
 
import java.util.HashSet;
import java.util.Iterator;
 
public class HashSetDemo01 {
    public static void main(String[] args) {
 
        //创建对象
        HashSet<String> hs = new HashSet<>();
 
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
 
        //增强for遍历
        for (String s : hs){
            System.out.println(s);
        }
 
        //迭代器遍历
        Iterator<String> it = hs.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

7. LinkedHashSet集合概述和特点

LinkedHashSet集合特点

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

LinkedHashSet集合练习

• 存储字符串并遍历
• 示例代码如下：

package com.collection.set;
 
import java.util.Iterator;
import java.util.LinkedHashSet;
 
public class LinkedHashSetDemo01 {
    public static void main(String[] args) {
 
        //创建集合对象
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
 
        lhs.add("hello");
        lhs.add("world");
        lhs.add("java");
 
        //遍历集合  增强for
        for (String s : lhs){
            System.out.println(s);
        }
 
        System.out.println("=================");
 
        //遍历集合  迭代器
        Iterator<String> it = lhs.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

8. TreeSet集合概述和特点

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

练习

• 存储整数并遍历
• 示例代码

package com.collection.set;
 
import java.util.TreeSet;
 
public class TreeSetDemo01 {
    public static void main(String[] args) {
 
        //创建集合对象  String类型
        TreeSet<String> ts = new TreeSet<>();
 
        //添加元素
        ts.add("hello");
        ts.add("world");
        ts.add("java");
 
        //遍历集合  增强for
        for (String s : ts){
            System.out.println(s);
        }
 
        //创建集合对象  int类型
        //只能用引用类型
        //TreeSet<int> ints = new TreeSet<int>();
        TreeSet<Integer> ints = new TreeSet<>();
 
        //添加元素
        ints.add(10);
        ints.add(9);
        ints.add(167);
 
        //遍历集合  增强for
        for (int i : ints){
            System.out.println(i);//会从小到大排序//自然排序
        }
    }
}

9. 自然排序Comparable的使用

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

package com.collection.set;
 
import java.util.Objects;
 
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 int getAge() {
        return age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    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;
        return age == student.age && Objects.equals(name, student.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
 
    @Override
    public int compareTo(Student s) {
//        return 0;
//        return 1;
 
//        //当前是这一个
        int num = this.age - s.age;//传入的是前一个
//        return num;//大于0就放后面，小于0就放前面
        //年龄相同时，按照姓名规则
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

package com.collection.set;
 
import java.util.TreeSet;
 
public class TreeSetDemo02 {
    public static void main(String[] args) {
 
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
 
        //创建学生对象
        Student s1 = new Student("ZhangSan",23);
        Student s2 = new Student("LiSi",24);
        Student s3 = new Student("WangWu",25);
        Student s4 = new Student("LiuLu",21);
        Student s5 = new Student("QianQi",24);
 
        //添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
 
        //遍历集合 增强for
        for (Student s : ts){
            System.out.println("姓名为：" + s.getName() + "\t" +
                    "年龄为：" + s.getAge());
        }
    }
}

结论：

• 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

• 自然排序，就是让元素所属的类实现Comparable接口，重写Compareto(T o)方法

• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

10. 比较器排序Comparator的使用

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

package com.collection.set;
 
import java.util.Objects;
 
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 int getAge() {
        return age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

package com.collection.set;
 
import java.util.Comparator;
import java.util.TreeSet;
 
public class TreeSetDemo03 {
    public static void main(String[] args) {
 
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>(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("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("刘陆", 23);
 
        //添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
 
        //遍历集合
        for (Student s : ts){
            System.out.println("姓名为：" + s.getName() + "\t" +
                    "年龄为：" + s.getAge());
        }
    }
}

11. 案例：成绩排序

需求：用TreeSet集合存储多个学生信息（姓名，语文成绩，数学成绩），并遍历该集合

要求：按照总分从高到低出现

示例代码：

package com.collection.set;
 
public class StudentMassage {
    private String name;
    private int chinese;
    private int math;
 
    public StudentMassage() {
    }
 
    public StudentMassage(String name, int chinese, int math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getChinese() {
        return chinese;
    }
 
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
 
    public int getMath() {
        return math;
    }
 
    public void setMath(int math) {
        this.math = math;
    }
 
    public int getSum(){
        int sum  = this.chinese + this.math;
        return sum;
    }
}

package com.collection.set;
 
import java.util.Comparator;
import java.util.TreeSet;
 
public class TreeSetDemp04 {
    public static void main(String[] args) {
 
        //创建集合对象
        //有参
        TreeSet<StudentMassage> ts = new TreeSet<StudentMassage>(new Comparator<StudentMassage>() {
            @Override
            public int compare(StudentMassage s1, StudentMassage s2) {
 
                int sum = s1.getSum() - s2.getSum();
 
                int num = sum == 0 ? s1.getName().compareTo(s2.getName()) : sum;
 
 
                return num;
            }
        }) ;
 
        //创建学生信息对象
        StudentMassage s1 = new StudentMassage("张三", 90, 91);
        StudentMassage s2 = new StudentMassage("李四", 78, 76);
        StudentMassage s3 = new StudentMassage("王麻子", 60, 100);
        StudentMassage s4 = new StudentMassage("刘小菜", 98, 99);
        StudentMassage s5 = new StudentMassage("陈大荣", 99, 98);
 
        //添加学生对象至集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
 
        //遍历集合
        for (StudentMassage s : ts){
            System.out.println("姓名：" + s.getName() + "\t" +
                    "语文成绩：" + s.getChinese() + "\t" +
                    "数学成绩：" + s.getMath() + "\t" +
                    "总分：" + s.getSum() );
        }
    }
}
 

12. 案例：不重复的随机数

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

示例代码：

package com.collection.set;
 
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
 
public class RadnomSetDemo01 {
    public static void main(String[] args) {
 
        //创建集合对象
        //无序
        Set<Integer> set = new HashSet<>();
        //有序
        //Set<Integer> set = new TreeSet<>();
 
        //创建随机数对象
        Random r = new Random();
 
        //添加随机数至集合
        while(set.size()<10){
            set.add(r.nextInt(20)+1);
        }
 
        //遍历数组
        for (int i : set){
            System.out.println(i);
        }
    }
}

四、泛型

1. 泛型概述

泛型是JDK5中引入的特性，它提供了编译时类型安全监测机制，该机制允许在编译时检测到非法的

类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么

理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法和泛型接口

泛型定义格式：

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

示例代码：

package com.collection.generic;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class GenericDemo {
    public static void main(String[] args) {
 
        //创建集合对象
        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);
        }
    }
}

范型的好处：

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

2. 泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<>{}
• 示例：public class Generic<>{}
• 示例代码：

package com.collection.generic;
 
public class Student {
 
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

package com.collection.generic;
 
public class Teacher {
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    private Integer age;
 
}

package com.collection.generic;
 
public class Generic<T> {
 
    private T t;
 
    public T getT() {
        return t;
    }
 
    public void setT(T t) {
        this.t = t;
    }
}

package com.collection.generic;
 
public class GenericDemo02 {
    public static void main(String[] args) {
 
        //创建学生对象
        Student s1 = new Student();
        s1.setName("张三");
 
        //创建老师对象
        Teacher t1 = new Teacher();
        t1.setAge(30);
 
        System.out.println(s1.getName());
        System.out.println(t1.getAge());
        System.out.println("=============");
 
        //创建泛型对象
        Generic<String> g1 = new Generic<>();
        g1.setT("张麻子");
        Generic<Integer> g2 = new Generic<>();
        g2.setT(32);
        Generic<Boolean> g3 = new Generic<>();
        g3.setT(true);
        System.out.println(g1.getT());
        System.out.println(g2.getT());
        System.out.println(g3.getT());
    }
}

3. 泛型方法

泛型方法的定义格式：

• 格式：修饰符 <类型> void show(T t){}
• 范例：public void show(T t){}
• 示例代码：

package com.collection.generic;
 
//public class Generic2<T> {
 
//    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);
//    }
 
    //泛型类改进
//    public void show (T t){
//        System.out.println(t);
//    }
 
    //泛型方法改进
public class Generic2{
    public <T> void show (T t){
        System.out.println(t);
    }
}

package com.collection.generic;
 
public class GenericDemo03 {
    public static void main(String[] args) {
 
//        //创建泛型对象
//        Generic2 g1 = new Generic2();
//        g1.show("String");
//        g1.show(100);
//        g1.show(false);
 
        //泛型类改进
//        Generic2<String> g1 = new Generic2<String>();
//        g1.show("String");
//        Generic2<Integer> g2 = new Generic2<Integer>();
//        g2.show(100);
//        Generic2<Boolean> g3 = new Generic2<Boolean>();
//        g3.show(false);
 
        //泛型方法改进
        Generic2 g1 = new Generic2();
        g1.show("String");
        Generic2 g2 = new Generic2();
        g2.show(100);
        Generic2 g3 = new Generic2();
        g2.show(false);
 
    }
}

4. 泛型接口

泛型接口的定义格式：

• 格式：修饰符 interface 接口名<类型>{}
• 范例：public interface Generic{}
• 示例代码：

package com.collection.generic;
 
public interface Generic3<T> {
    void show(T t);
}
 

package com.collection.generic;
 
public class GenericImpl<T> implements Generic3<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

package com.collection.generic;
 
public class GenericDemo04 {
    public static void main(String[] args) {
 
        GenericImpl<String> g1 = new GenericImpl<>();
        GenericImpl<Integer> g2 = new GenericImpl<>();
        GenericImpl<Boolean> g3 = new GenericImpl<>();
        g1.show("String");
        g2.show(100);
        g3.show(false);
    }
}

5. 类型通配符

为了表现各种泛型List的父类，可以使用类型通配符

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

如果我们不希望List<?>时任何泛型List的父类，只希望它代表某一类泛型List的父亲，可以使用类型通配符的上限

• 类型通配符上限：<? extends 类型>
• ：它表示的类型是**Number或者其子类型**

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符下限：<? super 类型>
• List<? super Number>：它表示的类型是Number或者其父类型

示例代码：

package com.collection.generic;
 
import java.util.ArrayList;
import java.util.List;
 
public class GenericDemo05 {
 
    public static void main(String[] args) {
 
        //类型通配符: <?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        
        //类型通配符上限：<? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list4 = new ArrayList<Integer>();
        
        //类型通配符下限：<? super 类型>
        //List<? super Number> list5 = new ArrayList<Integer>();
        List<? super Number> list5 = new ArrayList<Object>();
    }
}

6. 可变参数的使用

可变参数在前面的java方法中已经学过一部分

Arrays工具类中有一个静态方法：

• public static List asList(T... a)：返回由指定数组支持的固定大小的列表

//下面都是JDK9才新增的，我目前是JDK8，我说怎么一直报错，原来我没有。。。

List接口中有一个静态方法：

• public static List of(E... elements)：返回包含任意数量元素的不可变列表

Set接口中有一个静态方法：

• public static Set of(E... elements)：返回一个包含任意数量元素的不可变集合

五、Map集合

1.Map集合概述和使用

概述：

• Interface Map<K,V> k：键的类型 V：值的类型
• 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
• 举例：学生的学号和姓名
  • zj001 张三
  • zj002 李四
  • zj003 王麻子
• 示例代码：

package com.collection.map;
 
import java.util.HashMap;
import java.util.Map;
 
public class MapDemo01 {
    public static void main(String[] args) {
 
        //创建Map对象
        Map<String, String> map = new HashMap<>();
 
        //添加元素
        map.put("zj001","张三");
        map.put("zj002","李四");
        map.put("zj003","王麻子");
        //第二次出现的键是用来修改元素
        map.put("zj003","钱七");
 
        System.out.println(map);
    }
}

2. Mapj集合的基本功能

• V put(K key, V value)：添加元素
• V remove(K key)：根据键删除键值对应元素
• boolean containsKey(K key)：判断集合是否包含指定的键
• boolean containsValue(V value)：判断集合是否包含指定的值
• int size()：集合的长度，即集合中键值对的个数
• void clear()：清除集合内所有元素
• boolean isEmpty()：判断集合是否为空

示例代码：

package com.collection.map;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
 
public class MapDemo02 {
    public static void main(String[] args) {
 
        //创建集合对象
        Map<String, String> map = new HashMap<>();
 
        //添加集合元素
        //V put(K key, V value)
        map.put("林丹","李宗伟");
        map.put("谌龙","安赛龙");
        map.put("石宇奇","桃田贤斗");
 
        System.out.println(map);
        System.out.println("================");
 
        //移除元素
        //V remove(K key)
        System.out.println(map.remove("石宇奇"));//返回键对应的值
        System.out.println(map.remove("金庭"));
        System.out.println(map);
        System.out.println("================");
 
        //判断键是否存在
        //boolean containsKey(K key)
        System.out.println(map.containsKey("谌龙"));
        System.out.println("================");
 
        //判断值是否存在
        //boolean containsValue(V value)
        System.out.println(map.containsValue("安赛龙"));
        System.out.println("================");
 
        //集合的长度
        //int size()
        System.out.println(map.size());
        System.out.println("================");
 
        //清除所有元素
        //void clear()
        map.clear();
        System.out.println(map);
        System.out.println("================");
 
        //判断集合是否为空
        //boolean isEmpty()
        System.out.println(map.isEmpty());
 
    }
}

3. Map集合的获取功能

• V get(Object key)：根据键获取值

• Set<K> keySet()：获取所有键的集合

• Collection<V> Values()：获取所有值的集合

• 示例代码：

package com.collection.map;
 
import java.util.*;
 
public class MapDemo03 {
 
    public static void main(String[] args) {
 
        //创建集合元素
        Map<String,String> map = new HashMap<String,String>();
 
        //添加元素
        map.put("林丹","李宗伟");
        map.put("谌龙","安赛龙");
        map.put("石宇奇","桃田贤斗");
 
        //V get(Object key)：根据键获取值
        System.out.println(map.get("林丹"));
        System.out.println(map.get("谌龙"));
        System.out.println(map.get("石宇奇"));
        System.out.println("=================");
 
        //Set<K> keySet()：获取所有键的集合
        Set<String> set = map.keySet();
        for (String s : set){
            System.out.println(s);
        }
        System.out.println("==================");
 
        //Collection<V> Values()：获取所有值的集合
        Collection<String> co = map.values();
        for (String s : co){
            System.out.println(s);
        }
    }
}

4. Map集合的遍历

1. 方式一：

   1. 先获取所有的键 Set
   2. 再通过键寻找值 get
   3. 示例代码：

   package com.collection.map;
    
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Set;
    
   public class MapDemo04_1 {
       public static void main(String[] args) {
    
           //创建集合元素
           Map<String,String> map = new HashMap<String,String>();
    
           //添加元素
           map.put("林丹","李宗伟");
           map.put("谌龙","安赛龙");
           map.put("石宇奇","桃田贤斗");
    
           //先获取键的Set集合
           Set<String> set = map.keySet();
    
           //再用增强for遍历键的Set集合
           for (String s1 : set){
    
               //找出每个键对应的值get
               String s2 = map.get(s1);
               System.out.println(s1 + "," +s2);
           }//无序
       }
   }

2. 方式二

   1. 获取所有键值对对象的集合
      • Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
   2. 遍历键值对对象的集合，得到每一个键值对对象
      • 用增强for实现，得到每一个Map.Entry
   3. 示例代码

   package com.collection.map;
    
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Set;
    
   public class MapDemo04_2 {
    
       public static void main(String[] args) {
    
           //创建集合元素
           Map<String,String> map = new HashMap<String,String>();
    
           //添加元素
           map.put("林丹","李宗伟");
           map.put("谌龙","安赛龙");
           map.put("石宇奇","桃田贤斗");
    
           //获取所有键值对对象的集合
           Set<Map.Entry<String,String>> set = map.entrySet();
    
           //遍历键值对对象的集合
           for (Map.Entry<String,String> e : set){
               String s1 = e.getKey();
               String s2 = e.getValue();
               System.out.println(s1+"，"+s2);
           }
       }
   }

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

1. 需求：创建一个HashMap集合，键是学号（String），值使学生对象（Student）。存储三个键值对元素，并遍历。
   • 示例代码

package com.collection.map;
 
public class Student {
 
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
 
    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;
    }
}
 

package com.collection.map;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
 
public class MapDemo05 {
 
    public static void main(String[] args) {
 
 
        //创建Map集合，键为学号(String)，值为学生类
        Map<String,Student> map = new HashMap<String,Student>();
 
        //创建学生对象
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王麻子", 25);
 
        //添加元素
        map.put("113",s1);
        map.put("114",s2);
        map.put("115",s3);
 
        //遍历：键值对方式
        //获取键值对
        Set<Map.Entry<String, Student>> en = map.entrySet();
 
        //遍历键值对
        for (Map.Entry<String, Student> e : en){
            Student s = e.getValue();
            String name = s.getName();
            int age = s.getAge();
            String num = e.getKey();
 
            System.out.println("学号为：" + num + "\t" +
                    "姓名：" +name + "\t" +
                    "年龄：" + age);
        }
        System.out.println("====================");
 
        //直接获取键
        //获取键的set集合
        Set<String> set = map.keySet();
        for (String num : set){
 
            //通过键获得值
            Student s = map.get(num);
            String name = s.getName();
            int age = s.getAge();
 
            System.out.println("学号为：" + num + "\t" +
                    "姓名：" +name + "\t" +
                    "年龄：" + age);
        }
    }
}

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

   • 注意：要在上述学生类中重写hashCode() 和equals()

   示例代码：

package com.collection.map;
 
import java.util.Objects;
 
public class Student {
 
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
 
    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;
        return age == student.age && Objects.equals(name, student.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package com.collection.map;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class MapDemo05_2 {
 
    public static void main(String[] args) {
 
        //创建Map集合对象
        Map<Student, String> map = new HashMap<>();
 
        //创建学生对象
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王麻子", 25);
        Student s4 = new Student("王麻子", 25);
 
        //添加元素
        map.put(s1,"北京");
        map.put(s2,"上海");
        map.put(s3,"广州");
        map.put(s4,"南京");
 
        //键值对遍历
        Set<Map.Entry<Student, String>> en = map.entrySet();
        for (Map.Entry<Student,String> e : en){
            Student s = e.getKey();
            String address = e.getValue();
            String name = s.getName();
            int age = s.getAge();
 
            System.out.println("姓名：" +name + "\t" +
                    "年龄：" + age + "\t" +
                    "住址：" + address);
        }
    }
}

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

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

示例代码：

package com.collection.map;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class MapDemo06 {
    public static void main(String[] args) {
 
        //创建ArrayList集合
        ArrayList<HashMap<String,String>> al = new ArrayList<HashMap<String,String>>();
 
        //创建HashMap集合
        HashMap<String, String> h1 = new HashMap<>();
        HashMap<String, String> h2 = new HashMap<>();
        HashMap<String, String> h3 = new HashMap<>();
 
        //添加HashMap中的元素
        h1.put("陈雨菲","山口茜");
        h1.put("何冰娇","马琳");
        h1.put("昆拉武特","奈良冈");
        h2.put("石宇奇","桃田");
        h2.put("林丹","李宗伟");
        h2.put("骆建佑","李梓嘉");
        h3.put("强贪壶","交闪");
        h3.put("陨石","霍普");
        h3.put("灰","G");
 
        //添加ArrayList中的元素
        al.add(h1);
        al.add(h2);
        al.add(h3);
 
        //遍历ArrayList集合
        for (HashMap<String,String> h : al){
 
            //遍历HashMap集合
            Set<Map.Entry<String, String>> en = h.entrySet();
            for (Map.Entry<String,String> e : en){
                String key = e.getKey();
                String value = e.getValue();
                System.out.println(key + "，" + value);
            }
            System.out.println("=================");
        }
    }
}

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

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

示例代码：

package com.collection.map;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
 
public class MapDemo07 {
 
    public static void main(String[] args) {
 
        //创建HashMap集合对象
        HashMap<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();
 
        //创建ArrayList集合对象
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
 
        //添加ArrayList的元素
        array1.add("天地玄黄");
        array1.add("宇宙洪荒");
        array2.add("上善若水");
        array2.add("善利万物而不争");
        array3.add("天行健");
        array3.add("君子以自强不息");
 
        //添加HashMap的元素
        map.put("《千字文》",array1);
        map.put("《道德经》",array2);
        map.put("《周易》",array3);
 
        //遍历
        Set<String> key = map.keySet();
        for (String s : key){
            System.out.println(s);
            for (String s1 : map.get(s) ){
                System.out.println(s1);
            }
            System.out.println();
        }
    }
}

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

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。

举例：键盘录入”aababcabcdabcde“ 在控制台输出：”a(5)b(4)c(3)d(2)e(1)“

示例代码：

package com.collection.map;
 
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
 
public class MapDemo08 {
 
    public static void main(String[] args) {
 
        //创建HashMap集合对象
        HashMap<Character, Integer> map = new HashMap<>();
 
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = scanner.nextLine();
 
        //遍历字符串
        for (int i = 0 ; i < s.length() ; i ++ ){
 
            char c = s.charAt(i);
 
/*            //遍历HashMap集合
            Set<Character> characters = map.keySet();
            for (char key : characters ){
 
                if (key == c){
 
                    //键相等则值加一
                    int value = map.get(key) + 1;
                    map.put(c,value);
                    flag = false;
                    break;
                }
            }*/
 
            //可以直接寻找
 
            Integer v = map.get(c);
 
            if (v == null){
 
                //没有相同的则添加
                int value = 1;
                map.put(c,value);
            } else {
 
                //有相同的加1
                Integer value = map.get(c) + 1;
                map.put(c,value);
            }
        }
        System.out.println(map);
 
        //拼接用StringBuilder
        StringBuilder sb = new StringBuilder();
 
        //遍历HashMap集合
        Set<Character> keySet = map.keySet();
        for (Character key : keySet){
            Integer value = map.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
 
        System.out.println(sb);
    }
}

• 注意：如果想要让键进行自然排序可以使用TreeMap集合

六、Collections

1.Collections概述和使用

1. 概述

   • 是针对集合操作的工具类

2. 常用方法

   • public static <T extends Comparable <? super T>> void sort(List <T> List)：将指定的列表按升序排列

   • public static void reverse(List<?> list)：反转指定列表中元素的顺序

   • public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表

3. 示例代码

package com.collection.collections;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class CollectionsDemo01 {
    public static void main(String[] args) {
 
        //创建集合对象
        ArrayList<Integer> list = new ArrayList<>();
 
        //添加元素
        list.add(12);
        list.add(201);
        list.add(32);
        list.add(-1);
        list.add(100);
 
        //输出
        System.out.println(list);
        System.out.println("=================");
 
        //排序
        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("==================");
 
    }
}

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

需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

示例代码：

package com.collection.collections;
 
public class Student {
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Student() {
    }
 
    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;
    }
 
}

package com.collection.collections;
 
import java.sql.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
 
public class CollectionsDemo02 {
 
    public static void main(String[] args) {
 
        //创建集合对象
        ArrayList<Student> list = new ArrayList<>();
 
        //创建学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangmazi", 25);
        Student s4 = new Student("liulu", 23);
 
        //添加集合元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
 
        //排序
        Collections.sort(list , new Comparator<Student>(){
 
            //使用比较器
            @Override
            public int compare(Student s1, Student s2) {
 
                //让年龄升序排列
                int sum = s1.getAge()-s2.getAge();
 
                //年龄相同则按照姓名首字母排序
                int num = sum == 0 ? s1.getName().compareTo(s2.getName()): sum;
                return num;
            }
        });
 
        //遍历
        for (Student s : list ){
            System.out.println("姓名：" + s.getName() + "\t" +
                    "年龄：" + s.getAge());
        }
    }
}

注意在Student中继承Comparable或者在sort中重写比较器compareTo()

3. 案例：模拟斗地主

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

示例代码

package com.collection.collections;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class PokerDemo {
 
    public static void main(String[] args) {
 
        //创建一个牌盒
        ArrayList<String> pokers = new ArrayList<>();
 
        /*
        往盒子里装牌
        方片2 - A
        黑桃2 - A
        红桃2 - A
        梅花2 - A
         */
 
        //定义花色数组
        String[] color = {"♦","♣","♥","♠"};
 
        //定义点数数组
        String[] num = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
 
        //拼接
        for (String s1 : color){
            for (String s2 : num){
                pokers.add(s1+s2);
            }
        }
        pokers.add("小王");
        pokers.add("大王");
 
        //洗牌
        Collections.shuffle(pokers);
 
        //创建玩家牌库
        ArrayList<String> zsPokers = new ArrayList<>();//张三
        ArrayList<String> lsPokers = new ArrayList<>();//李四
        ArrayList<String> wmzPokers = new ArrayList<>();//王麻子
        ArrayList<String> dpPokers = new ArrayList<String>();//底牌
 
        //发牌
        for (int i = 0; i < pokers.size(); i++) {
            String poker  = pokers.get(i);
 
            if (pokers.size() - i <= 3){
                dpPokers.add(poker);
            } else if (i % 3 == 0){
                zsPokers.add(poker);
            } else if (i % 3 == 1){
                lsPokers.add(poker);
            } else if (i % 3 == 2){
                wmzPokers.add(poker);
            }
        }
 
        //看牌
 
        System.out.println("牌库：" + pokers);
 
        look("张三",zsPokers);
        look("李四",lsPokers);
        look("王麻子",wmzPokers);
        System.out.println("底牌是：" + dpPokers);
    }
 
    //看牌
    public static void look(String name , ArrayList<String> list){
 
        System.out.println(name + "的手牌是：");
        for (String poker : list){
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

4. 案例：模拟斗地主升级版

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

使用了HashMap存牌库，用ArrayList存索引，用TreeSet存手牌

package com.collection.collections;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
 
public class PokerExDemo {
 
    public static void main(String[] args) {
 
        //定义一个HashMap集合对象用作牌库
        HashMap<Integer, String> map = new HashMap<>();
 
        //定义一个ArrayList集合对象存储索引
        ArrayList<Integer> keys = new ArrayList<>();
 
        //定义TreeSet用于存储玩家手牌
        TreeSet<Integer> zsPokers = new TreeSet<>();
        TreeSet<Integer> lsPokers = new TreeSet<>();
        TreeSet<Integer> wmzPokers = new TreeSet<>();
        TreeSet<Integer> dpPokers = new TreeSet<>();
 
        //定义花色数组
        String[] color = {"♦","♣","♥","♠"};
 
        //定义点数数组
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
 
        //拼接
        Integer i = 0;
        for (String s1 : num){
            for (String s2 : color){
                map.put(i,s2 + s1);
                keys.add(i);
                i ++;
            }
        }
        //小王大王
        map.put(52,"小王");
        map.put(53,"大王");
        keys.add(52);
        keys.add(53);
 
        //洗牌 :  洗索引
        Collections.shuffle(keys);
 
        //抽牌
        for (int j = 0; j < keys.size(); j++) {
            Integer poker = keys.get(j);
            if (keys.size() - j <= 3){
                dpPokers.add(poker);
            } else if (j % 3 == 0){
                zsPokers.add(poker);
            } else if (j % 3 == 1){
                lsPokers.add(poker);
            } else if (j % 3 == 2){
                wmzPokers.add(poker);
            }
        }
 
        //看牌
        look("张三", zsPokers , map );
        look("李四", lsPokers , map );
        look("王麻子", wmzPokers , map );
        look("底牌", dpPokers , map );
 
//        System.out.println(map);
//        System.out.println(keys);
 
    }
 
    //看牌方法
    public static void look(String name , TreeSet<Integer> set, HashMap<Integer,String> map){
        System.out.println(name + "的牌是：");
        for (Integer i : set){
            System.out.print(map.get(i) + " ");
        }
        System.out.println();
    }
}