16.集合

Java中的集合

Java中的集合类可以分为两大类：一类是实现Collection接口（单列集合）；另一类是实现Map接口（双列集合）。

集合和数组的区别：

数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。

1. Collection集合

1.1 Collection体系概述

Collection 表示一组对象，这些对象也称为 collection 的元素。Collection有两个重要的子接口List和Set。

file

List：有序集合（也称为序列，存储和获取的顺序保持一致）。List中的每个元素都有索引，使用此接口能够准确的控制每个元素插入的位置。用户也能够使用索引来访问List中的元素。

有序有索引允许重复元素

Set：不包含重复元素的集合。确切的讲，set中不能包含满足e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个null元素。

无序无索引不允许重复

1.2 Collection集合常用方法

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

// 删除所有元素 清空  
void clear()

// 删除指定的元素 -- 根据equals比较进行匹配，只删除第一个匹配
boolean remove(Object o)

// 根据条件删除元素 -- 符合条件的全部删除
default boolean removeIf(Predicate<? super E> filter)

// 判断是否包含指定的元素
boolean contains(Object o)

// 判断集合是否为空（即集合长度为0）
boolean isEmpty()

// 获取集合的长度（即元素的个数）
int size()

// 将集合转换为Obejct数组
Object[] toArray()

// 将集合转换为指定数据类型的数组
<T> T[] toArray(T[] a)

// 获取此集合中元素的迭代器
Iterator<E> iterator()

1.3 Collection集合的遍历

迭代器介绍
- 迭代器，指的是Iterator<E>接口，用于遍历集合中的元素。
- Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
Iterator中的常用方法

boolean hasNext(): 判断当前位置是否有元素可以被取出
E next(): 获取当前位置的元素，将迭代器对象移向下一个索引位置

Collection集合的遍历

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

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

      //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
      Iterator<String> it = c.iterator();

      //用while循环实现元素的判断和获取
      while (it.hasNext()) {
          String s = it.next();
          System.out.println(s);
      }
  }
}

迭代器中删除的方法

void remove(): 删除迭代器对象当前指向的元素

public class IteratorDemo2 {
  public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
      list.add("a");
      list.add("b");
      list.add("b");
      list.add("c");
      list.add("d");

      Iterator<String> it = list.iterator();
      while(it.hasNext()){
          String s = it.next();
          if("b".equals(s)){
              //指向谁,那么此时就删除谁.
              it.remove();
          }
      }
      System.out.println(list);
  }
}

1.4 增强for循环

介绍
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
- 实现Iterable接口的类才可以使用迭代器和增强for
- 简化数组和Collection集合的遍历

格式

for (集合或者数组中元素的数据类型 变量名 : 集合或者数组名) {
// 直接使用变量即可，依次代表集合或者数组中的每个元素
}

代码

public class MyCollectonDemo1 {
  public static void main(String[] args) {
      ArrayList<String> list =  new ArrayList<>();
      list.add("a");
      list.add("b");
      list.add("c");
      list.add("d");
      list.add("e");
      list.add("f");

      //1,数据类型一定是集合或者数组中元素的类型
      //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
      //3,list就是要遍历的集合或者数组
      for (String str : list){
          System.out.println(str);
      }
  }
}

2. List集合

2.1 List集合的特点

List集合的概述

有序集合，这里的有序指的是存取顺序
用户可以精确控制列表中每个元素的插入位置，用户可以通过索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素

List集合的常用实现类为ArrayList和LinkedList

2.2 List集合的特有方法

方法介绍

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

示例代码

public class MyListDemo {
  public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      list.add("aaa");
      list.add("bbb");
      list.add("ccc");
      //method1(list);
      //method2(list);
      //method3(list);
      //method4(list);
  }

  private static void method4(List<String> list) {
      //        E get(int index)        返回指定索引处的元素
      String s = list.get(0);
      System.out.println(s);
  }

  private static void method3(List<String> list) {
      //        E set(int index,E element)  修改指定索引处的元素，返回被修改的元素
      //被替换的那个元素,在集合中就不存在了.
      String result = list.set(0, "qqq");
      System.out.println(result);
      System.out.println(list);
  }

  private static void method2(List<String> list) {
      //        E remove(int index)     删除指定索引处的元素，返回被删除的元素
      //在List集合中有两个删除的方法
      //第一个 删除指定的元素,返回值表示当前元素是否删除成功
      //第二个 删除指定索引的元素,返回值表示实际删除的元素
      String s = list.remove(0);
      System.out.println(s);
      System.out.println(list);
  }

  private static void method1(List<String> list) {
      //        void add(int index,E element)   在此集合中的指定位置插入指定的元素
      //原来位置上的元素往后挪一个索引.
      list.add(0,"qqq");
      System.out.println(list);
  }
}

2.3 List集合的实现类

2.3.1 List集合子类的特点

ArrayList 集合

底层是数组结构实现，查询快、增删慢
LinkedList 集合

底层是链表结构实现，查询慢、增删快

2.3.2 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 MyLinkedListDemo4 {
  public static void main(String[] args) {
      LinkedList<String> list = new LinkedList<>();
      list.add("aaa");
      list.add("bbb");
      list.add("ccc");
//        public void addFirst(E e)   在该列表开头插入指定的元素
      //method1(list);

//        public void addLast(E e)    将指定的元素追加到此列表的末尾
      //method2(list);

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

//        public E removeFirst()      从此列表中删除并返回第一个元素
//        public E removeLast()       从此列表中删除并返回最后一个元素
      //method4(list);

  }

  private static void method4(LinkedList<String> list) {
      String first = list.removeFirst();
      System.out.println(first);

      String last = list.removeLast();
      System.out.println(last);

      System.out.println(list);
  }

  private static void method3(LinkedList<String> list) {
      String first = list.getFirst();
      String last = list.getLast();
      System.out.println(first);
      System.out.println(last);
  }

  private static void method2(LinkedList<String> list) {
      list.addLast("www");
      System.out.println(list);
  }

  private static void method1(LinkedList<String> list) {
      list.addFirst("qqq");
      System.out.println(list);
  }
}

3. Set集合

3.1 Set集合的特点

不可以存储重复元素
没有索引，不能使用普通for循环遍历
Set集合常用的实现类有HashSet和TreeSet

3.2 Set集合的使用

存储字符串并遍历

public class MySet1 {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new TreeSet<>();
        //添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");

//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }

        //遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

3.3 HashSet集合

3.3.1 HashSet集合基本使用

存储字符串并遍历

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

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

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

3.3.2 哈希码

HashSet集合基于哈希表实现。

哈希码（HashCode），并不是完全唯一的，它是一种算法，让同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同。

Java中几种常用的哈希码的算法：

Object类：hashCode根据对象的内存地址值计算，由于每个对象的地址值都不一样，所以哈希吗不一样。

String类：重写hashCode方法，根据字符串的内容计算，只要字符串所在的堆空间相同，返回的哈希码也相同。

Integer类：重写hashCode方法，返回的哈希码就是Integer对象里所包含的那个整数的数值。

3.3.3 HashSet集合保证元素唯一的原理

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

代码实现

学生类

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

 // 此处省略构造 和 get set

  @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;
  }
}

测试类

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

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

      Student s4 = new Student("王祖贤", 33);

      //把学生添加到集合
      hs.add(s1);
      hs.add(s2);
      hs.add(s3);
      hs.add(s4);

      //遍历集合(增强for)
      for (Student s : hs) {
          System.out.println(s.getName() + "," + s.getAge());
      }
  }
}

总结

HashSet集合存储自定义类型元素，要想实现元素的唯一，要求必须重写hashCode方法和equals方法。

判断流程：
1. 新元素与集合中已经存在的元素，先比较哈希值，如果不同，则直接存储；
2. 如果哈希值相同，继续调用equals方法比较，如果返回false，说明元素不重复，存储；
3. 如果哈希值相同，equals方法也返回true，说明元素重复，则不存储。

3.4 TreeSet集合

3.4.1 TreeSet集合的特点

TreeSet基于红黑树实现
可以将元素按照规则进行排序
- TreeSet()：根据其元素的自然排序进行排序
- TreeSet(Comparator comparator) ：根据指定的比较器进行排序

3.4.2 TreeSet集合基本使用

存储Integer类型的整数并遍历

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

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

        ts.add(30);

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

3.4.3 自然排序Comparable的使用

案例需求
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
1. 使用空参构造创建TreeSet集合
  - 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
2. 自定义的Student类实现Comparable接口
  - 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
3. 重写接口中的compareTo方法
  - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现

学生类

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 o) {
      //按照对象的年龄进行排序
      //主要判断条件: 按照年龄从小到大排序
      int result = this.age - o.age;
      //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
      result = result == 0 ? this.name.compareTo(o.getName()) : result;
      return result;
  }
}

测试类

public class MyTreeSet2 {
  public static void main(String[] args) {
      //创建集合对象
      TreeSet<Student> ts = new TreeSet<>();
    //创建学生对象
      Student s1 = new Student("zhangsan",28);
      Student s2 = new Student("lisi",27);
      Student s3 = new Student("wangwu",29);
      Student s4 = new Student("zhaoliu",28);
      Student s5 = new Student("qianqi",30);
    //把学生添加到集合
      ts.add(s1);
      ts.add(s2);
      ts.add(s3);
      ts.add(s4);
      ts.add(s5);
    //遍历集合
      for (Student student : ts) {
          System.out.println(student);
      }
  }
}

3.4.4 比较器排序Comparator的使用

案例需求
- 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现

老师类

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

  public Teacher() {
  }

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

测试类

public class MyTreeSet4 {
  public static void main(String[] args) {
        //创建集合对象
      TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
          @Override
          public int compare(Teacher o1, Teacher o2) {
              //o1表示现在要存入的那个元素
              //o2表示已经存入到集合中的元素

              //主要条件
              int result = o1.getAge() - o2.getAge();
              //次要条件
              result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
              return result;
          }
      });
    //创建老师对象
      Teacher t1 = new Teacher("zhangsan",23);
      Teacher t2 = new Teacher("lisi",22);
      Teacher t3 = new Teacher("wangwu",24);
      Teacher t4 = new Teacher("zhaoliu",24);
    //把老师添加到集合
      ts.add(t1);
      ts.add(t2);
      ts.add(t3);
      ts.add(t4);
    //遍历集合
      for (Teacher teacher : ts) {
          System.out.println(teacher);
      }
  }
}

3.4.5 两种比较方式总结

两种比较方式小结
- 自然排序: 自定义类实现Comparable接口，重写compareTo方法,根据返回值进行排序
- 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序
- 在使用的时候，默认使用自然排序，当自然排序不满足现在的需求时，必须使用比较器排序
两种方式中关于返回值的规则
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边

4. Map集合

4.1 Map集合概述和特点

Map集合概述

interface Map<K,V>  K：键key的类型；V：值value的类型

Map接口的常用实现类为HashMap和TreeMap

file

Map集合的特点
- Map提供键（key）到值（value）的映射
- 一个Map中不能包含相同的键
- 每个键只能映射一个值

Map集合的基本使用

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

      //V put(K key, V value) 将指定的值与该映射中的指定键相关联
      map.put("xuehao001","Tony");
      map.put("xuehao002","John");
      map.put("xuehao003","Bob");
      map.put("xuehao004","Tom");

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

4.2 Map集合的基本功能

方法介绍

方法名	说明
V put(K key,V value)	添加元素或者修改元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

示例代码

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

      //V put(K key,V value)：添加元素
      map.put("张无忌","赵敏");
      map.put("郭靖","黄蓉");
      map.put("杨过","小龙女");

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

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

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

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

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

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

4.3 Map集合的获取功能

方法介绍

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

示例代码

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("张三丰"));

      //Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

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

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

遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
- 把所有的丈夫给集中起来
- 遍历丈夫的集合，获取到每一个丈夫
- 根据丈夫去找对应的妻子
步骤分析
- 获取所有键的集合。用keySet()方法实现
- 遍历键的集合，获取到每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现

代码实现

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

      //添加元素
      map.put("张无忌", "赵敏");
      map.put("郭靖", "黄蓉");
      map.put("杨过", "小龙女");

      //获取所有键的集合。用keySet()方法实现
      Set<String> keySet = map.keySet();
      //遍历键的集合，获取到每一个键。用增强for实现
      for (String key : keySet) {
          //根据键去找值。用get(Object key)方法实现
          String value = map.get(key);
          System.out.println(key + "," + value);
      }
  }
}

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

遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
- 获取所有结婚证的集合
- 遍历结婚证的集合，得到每一个结婚证
- 根据结婚证获取丈夫和妻子
步骤分析
- 获取所有键值对对象的集合
- Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
- 遍历键值对对象的集合，得到每一个键值对对象
- 用增强for实现，得到每一个Map.Entry
- 根据键值对对象获取键和值
- 用getKey()得到键
- 用getValue()得到值

代码实现

public class MapDemo02 {
  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>> entrySet = map.entrySet();
      //遍历键值对对象的集合，得到每一个键值对对象
      for (Map.Entry<String, String> me : entrySet) {
          //根据键值对对象获取键和值
          String key = me.getKey();
          String value = me.getValue();
          System.out.println(key + "," + value);
      }
  }
}

4.6 HashMap集合

4.6.1 HashMap集合概述和特点

HashMap底层是哈希表结构的
依赖hashCode方法和equals方法保证键的唯一
如果键要存储的是自定义对象，需要重写hashCode和equals方法

4.6.2 HashMap集合应用案例

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

代码实现

学生类

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;
  }
}

测试类

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

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

      //把学生添加到集合
      hm.put(s1, "西安");
      hm.put(s2, "武汉");
      hm.put(s3, "郑州");
      hm.put(s4, "北京");

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

4.7 TreeMap集合

4.7.1 TreeMap集合概述和特点

TreeMap底层是红黑树结构
依赖自然排序或者比较器排序，对键进行排序
如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

4.7.2 TreeMap集合应用案例

案例需求
- 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
- 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序

代码实现

学生类

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 o) {
      //按照年龄进行排序
      int result = o.getAge() - this.getAge();
      //次要条件，按照姓名排序。
      result = result == 0 ? o.getName().compareTo(this.getName()) : result;
      return result;
  }
}

测试类

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

    // 创建学生对象
      Student s1 = new Student("xiaohei",23);
      Student s2 = new Student("dapang",22);
      Student s3 = new Student("xiaomei",22);

    // 将学生对象添加到TreeMap集合中
      tm.put(s1,"上海");
      tm.put(s2,"北京");
      tm.put(s3,"天津");

    // 遍历TreeMap集合,打印每个学生的信息
      tm.forEach(
              (Student key, String value)->{
                  System.out.println(key + "---" + value);
              }
      );
  }
}

1. Collection集合

1.1 Collection体系概述

1.2 Collection集合常用方法

1.3 Collection集合的遍历

1.4 增强for循环

2. List集合

2.1 List集合的特点

2.2 List集合的特有方法

2.3 List集合的实现类

2.3.1 List集合子类的特点

2.3.2 LinkedList集合的特有功能

3. Set集合

3.1 Set集合的特点

3.2 Set集合的使用

3.3 HashSet集合

3.3.1 HashSet集合基本使用

3.3.2 哈希码

3.3.3 HashSet集合保证元素唯一的原理

3.4 TreeSet集合

3.4.1 TreeSet集合的特点

3.4.2 TreeSet集合基本使用

3.4.3 自然排序Comparable的使用

3.4.4 比较器排序Comparator的使用

3.4.5 两种比较方式总结

4. Map集合

4.1 Map集合概述和特点

4.2 Map集合的基本功能

4.3 Map集合的获取功能

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

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

4.6 HashMap集合

4.6.1 HashMap集合概述和特点

4.6.2 HashMap集合应用案例

4.7 TreeMap集合

4.7.1 TreeMap集合概述和特点

4.7.2 TreeMap集合应用案例

添加附言

作者：阿布都的都

阿布都的都 的其他话题

分类下其他主题

随机推荐话题

阿布都的都的其他话题