API文档 => java.util => List，Map，Set

概念：
Java中的集合是工具类，可以存储任意数量的具有共同属性的对象

场景：

  • 无法预测存储数据的数量
  • 同时存储具有一对一关系的数据
  • 需要进行数据的增删
  • 数据重复问题

集合框架的体系结构：
Collection：类的对象，Map：键值对
image.png

List（列表）

  • List是接口
  • List是元素有序并且可以重复的集合，称为序列
  • List可以精确的控制每个元素的插入位置，或删除某个元素的位置
  • List的两个主要实现类是ArrayList和LinkedList

ArrayList

由于ArrayList用的比较多，所以接下来主要说明ArrayLsit

  • ArrayList底层由数组实现
  • 动态增长，以满足应用程序的需求
  • 在列表尾部插入或删除数据非常有效
  • 更适合查找和更新元素
  • ArrayList中的元素可以为null

    在List中操作字符串

    ```java package com.song.test;

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

public class TryDemoOne {

  1. public static void main(String[] args) {
  2.     // 用ArrayList存储编程语言的名称，并输出
  3.     List list = new ArrayList();
  4.     list.add("Java");
  5.     list.add("C");
  6.     list.add("C++");
  7.     list.add("Go");
  8.     list.add("swift");
  10.     // 输出列表中元素的个数
  11.     System.out.println("列表中元素的个数为：" + list.size());
  13.     // 遍历输出所有的编程语言
  14.     for (int i = 0; i < list.size(); i++) {
  15.         System.out.print(list.get(i) + ",");
  16.     }
  17.     System.out.println();
  19.     // 移除列表中的C++
  20.     list.remove(2);
  21.     for (int i = 0; i < list.size(); i++) {
  22.         System.out.print(list.get(i) + ",");
  23.     }
  24.     System.out.println();
  26.     // 移除列表中的Go
  27.     list.remove("Go");
  28.     for (int i = 0; i < list.size(); i++) {
  29.         System.out.print(list.get(i) + ",");
  30.     }
  31.     System.out.println();
  33.     // 判断list中是否包含"Java"字符串
  34.     System.out.println(list.contains("Java"));
  35. }

}

  2. <a name="glXsn"></a>
  3. #### 在List中操作自定义对象
  4. Notice.java
  5. ```java
  6. package com.song.test;
  8. import java.util.Date;
  10. public class Notice {
  11.     private int id;
  12.     private String title;
  13.     private String creator;
  14.     private Date createTime;
  16.     public Notice(int id, String title, String creator, Date createTime) {
  17.         super();
  18.         this.id = id;
  19.         this.title = title;
  20.         this.creator = creator;
  21.         this.createTime = createTime;
  22.     }
  23.     ...get,set方法...
  24. }

NoticeTest.java

  1. package com.song.test;
  3. import java.util.ArrayList;
  4. import java.util.Date;
  6. public class NoticeTest {
  8.     public static void main(String[] args) {
  9.         // 创建Notice类的对象，生成三条公告
  10.         Notice notice1 = new Notice(1, "欢迎来到我的教室", "管理员", new Date());
  11.         Notice notice2 = new Notice(2, "请同学们按时提交作业", "老师", new Date());
  12.         Notice notice3 = new Notice(3, "考勤通知", "老师", new Date());
  14.         // 添加公告
  15.         ArrayList noticeList = new ArrayList();
  16.         noticeList.add(notice1);
  17.         noticeList.add(notice2);
  18.         noticeList.add(notice3);
  20.         // 显示公告
  21.         for (int i = 0; i < noticeList.size(); i++) {
  22.             System.out.println(i + 1 + ":" + ((Notice) noticeList.get(i)).getTitle());
  23.         }
  25.         // 在第一条公告后面添加一条新公告
  26.         Notice notice4 = new Notice(4, "在线编辑器可以使用啦！", "管理员", new Date());
  27.         noticeList.add(1, notice4);
  29.         System.out.println("*********************************");
  30.         for (int i = 0; i < noticeList.size(); i++) {
  31.             // 注意这里需要强制类型转换为Notice类，否则无法调用getTitle()
  32.             System.out.println(i + 1 + ":" + ((Notice) noticeList.get(i)).getTitle());
  33.         }
  35.         // 删除按时完成作业的公告
  36.         noticeList.remove(2);
  38.         System.out.println("*********************************");
  39.         for (int i = 0; i < noticeList.size(); i++) {
  40.             System.out.println(i + 1 + ":" + ((Notice) noticeList.get(i)).getTitle());
  41.         }
  43.         // 修改第二条公告的title
  44.         notice4.setTitle("Java在线编辑器可以使用了");
  46.         System.out.println("*********************************");
  47.         for (int i = 0; i < noticeList.size(); i++) {
  48.             System.out.println(i + 1 + ":" + ((Notice) noticeList.get(i)).getTitle());
  49.         }
  50.     }
  51. }

Set

Set是元素无序并且不可以重复的集合，称为集，Set是接口

HashSet

  • HashSet是Set的一个重要实现类，称为哈希集
  • HashSet的元素无序并且不可重复
  • HashSet中只允许一个null元素
  • 具有良好的存取和查找功能
  • HashSet是在HashMap的基础上实现的

Iterator（迭代器）

  • Iterator接口可以以统一的方式对各种几何元素进行遍历
  • hasNext()方法检测集合中是否还有下一个元素
  • next()方法返回集合中的下一个元素

哈希表

想象一下，有一个数组，其中有100个整数。要查找其中一个元素的话，需要全部遍历一遍，这个效率是很低的。
哈希表可以解决这个问题。

具体做法：

  • 在内存中开辟三个区域来存放正整数，什么数据放到哪个区域，是需要规则的，而这个规则就是HashCode

具体的HashCode如何得到，需要严格的算法，而对于简单需求，Eclipse中自动生成的HashCode就够用了

  • 比如设置HashCode = n % 3，也就是说1放到第二个区域，2放到第三个区域，0放到第一个区域，依次类推
  • 要查找一个整数，先判断在哪个区域，然后再在这个区域里查找，效率就会提高很多了

判断在哪个区域用的就是hashCode()方法，在这个区域里查找用的就是equals()方法

image.png

在HashSet中操作字符串

  1. package com.song.test;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. public class NoticeTest {
  9.     public static void main(String[] args) {
  10.         Set set = new HashSet();
  12.         // 向集合中添加元素
  13.         set.add("blue");
  14.         set.add("red");
  15.         set.add("black");
  16.         set.add("yellow");
  17.         set.add("white");
  19.         // 显示元素
  20.         Iterator it = set.iterator();
  21.         while (it.hasNext()) {
  22.             System.out.print(it.next() + " ");
  23.         }
  24.         System.out.println();
  26.         // 在集合中插入重复元素
  27.         // 结果：不会报错，但是也不会出错
  28.         set.add("red");
  29.         it = set.iterator();
  30.         while (it.hasNext()) {
  31.             System.out.print(it.next() + " ");
  32.         }
  33.     }
  34. }

在HashSet中操作自定义对象

Cat.java

  1. package com.set;
  3. public class Cat {
  4.     private String name;
  5.     private int month;
  6.     private String species;
  8.     // 构造方法
  9.     public Cat(String name, int month, String species) {
  10.         super();
  11.         this.name = name;
  12.         this.month = month;
  13.         this.species = species;
  14.     }
  16.     // getter与setter方法...省略...
  18.     // 方便显示输出自定义对象的内容
  19.     @Override
  20.     public String toString() {
  21.         return "[姓名：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
  22.     }
  24.     // 添加自定义对象需要重写hashCode()方法和equals()方法
  25.     @Override
  26.     public int hashCode() {
  27.         final int prime = 31;
  28.         int result = 1;
  29.         result = prime * result + month;
  30.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  31.         result = prime * result + ((species == null) ? 0 : species.hashCode());
  32.         return result;
  33.     }
  35.     @Override
  36.     public boolean equals(Object obj) {
  37.         // 判断对象是否相等，相等则返回true，不用继续比较属性了
  38.         if (this == obj) {
  39.             return true;
  40.         }
  41.         // 判断比较对象obj是否是Cat类对象
  42.         if (obj.getClass() == Cat.class) {
  43.             // 保存并强制类型装换比较对象
  44.             Cat cat = (Cat) obj;
  45.             // 只有比较对象和当前对象的所有属性都一致，才认为是相同的
  46.             // 所以需要比较name，month，species
  47.             return cat.getName().equals(name) && (cat.getMonth() == month) && cat.getSpecies().equals(species);
  48.         }
  49.         return false;
  50.     }
  51. }

CatTest.java - 1
#添加，查找宠物猫信息

  1. package com.set;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. public class CatTest {
  9.     public static void main(String[] args) {
  10.         // 定义宠物猫对象
  11.         Cat huahua = new Cat("花花", 12, "英国短毛猫");
  12.         Cat fanfan = new Cat("凡凡", 3, "中华田园猫");
  14.         // 将宠物猫对象放入HashSet中
  15.         Set set = new HashSet();
  16.         set.add(huahua);
  17.         set.add(fanfan);
  19.         // 显示宠物猫信息
  20.         Iterator it = set.iterator();
  21.         while (it.hasNext()) {
  22.             System.out.println(it.next()); // 自动调用toString()方法
  23.         }
  24.         System.out.println();
  26.         // 再添加一个与花花属性一样的猫
  27.         Cat huahua01 = new Cat("花花", 12, "英国短毛猫");
  28.         set.add(huahua01);
  29.         System.out.println("********* 添加重复数据后的宠物猫信息： **********");
  30.         it = set.iterator();
  31.         while (it.hasNext()) {
  32.             System.out.println(it.next()); // 自动调用toString()方法
  33.         }
  34.         System.out.println();
  36.         // 重新插入一个新宠物猫
  37.         Cat huahua02 = new Cat("花花二代", 2, "英国短毛猫");
  38.         set.add(huahua02);
  39.         System.out.println("********* 添加花花二代后的宠物猫信息： **********");
  40.         it = set.iterator();
  41.         while (it.hasNext()) {
  42.             System.out.println(it.next()); // 自动调用toString()方法
  43.         }
  44.         System.out.println();
  46.         // 在集合中查找花花的信息并输出
  47.         System.out.println("********* 查找花花的宠物猫信息： **********");
  48.         if (set.contains(huahua)) {
  49.             System.out.println("花花找到了");
  50.             System.out.println(huahua);
  51.         } else {
  52.             System.out.println("花花没找到！");
  53.         }
  54.         System.out.println();
  56.         // 在集合中使用名字查找花花的信息
  57.         System.out.println("********* 查找名字查找花花的信息： **********");
  58.         boolean flag = false;
  59.         Cat c = null;
  60.         it = set.iterator();
  61.         while (it.hasNext()) {
  62.             // next()方法返回的值是object类型的，所以需要强制类型转换
  63.             // 但是这里你必须知道next()方法取出的对象类型是Cat类型
  64.             // 否则，如果转换成其他类型的话，编译不会出错，但是运行的时候就会出错
  65.             // 所以存在安全隐患，最好是编译的时候就提示我们出错
  66.             // 解决方案请参照CatTest.java -1，使用泛型
  67.             c = (Cat) it.next();
  68.             if (c.getName().equals("花花")) {
  69.                 flag = true;
  70.                 break;
  71.             }
  72.         }
  74.         if (flag) {
  75.             System.out.println("花花找到了");
  76.             System.out.println(c);
  77.         } else {
  78.             System.out.println("花花没找到");
  79.         }
  80.     }
  81. }

[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 添加重复数据后的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 添加花花二代后的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]
[姓名：花花二代, 年龄：2, 品种：英国短毛猫]

* 查找花花的宠物猫信息： **
花花找到了
[姓名：花花, 年龄：12, 品种：英国短毛猫]

* 查找名字查找花花的信息： **
花花找到了
[姓名：花花, 年龄：12, 品种：英国短毛猫]

CatTest.java -2
#删除宠溺猫信息

  1. package com.set;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. public class CatTest {
  9.     public static void main(String[] args) {
  10.         // 定义宠物猫对象
  11.         Cat huahua = new Cat("花花", 12, "英国短毛猫");
  12.         Cat fanfan = new Cat("凡凡", 3, "中华田园猫");
  14.         // 将宠物猫对象放入HashSet中
  15.         // <Cat>的意思是：往集合中加入的对象类型，必须是Cat类的对象，其他都不允许加入
  16.         Set<Cat> set = new HashSet<Cat>();
  17.         set.add(huahua);
  18.         set.add(fanfan);
  20.         // 显示宠物猫信息
  21.         // 同理，这里<Cat>的意思是迭代器中的元素都是Cat类的对象
  22.         Iterator<Cat> it = set.iterator();
  23.         while (it.hasNext()) {
  24.             System.out.println(it.next()); // 自动调用toString()方法
  25.         }
  26.         System.out.println();
  28.         // 再添加一个与花花属性一样的猫
  29.         Cat huahua01 = new Cat("花花", 12, "英国短毛猫");
  30.         set.add(huahua01);
  31.         System.out.println("********* 添加重复数据后的宠物猫信息： **********");
  32.         it = set.iterator();
  33.         while (it.hasNext()) {
  34.             System.out.println(it.next()); // 自动调用toString()方法
  35.         }
  36.         System.out.println();
  38.         // 重新插入一个新宠物猫
  39.         Cat huahua02 = new Cat("花花二代", 2, "英国短毛猫");
  40.         set.add(huahua02);
  41.         System.out.println("********* 添加花花二代后的宠物猫信息： **********");
  42.         it = set.iterator();
  43.         while (it.hasNext()) {
  44.             System.out.println(it.next()); // 自动调用toString()方法
  45.         }
  46.         System.out.println();
  48.         // 在集合中查找花花的信息并输出
  49.         System.out.println("********* 查找花花的宠物猫信息： **********");
  50.         if (set.contains(huahua)) {
  51.             System.out.println("花花找到了");
  52.             System.out.println(huahua);
  53.         } else {
  54.             System.out.println("花花没找到！");
  55.         }
  56.         System.out.println();
  58.         // 在集合中使用名字查找花花的信息
  59.         System.out.println("********* 查找名字查找花花的信息： **********");
  60.         boolean flag = false;
  61.         Cat c = null;
  62.         it = set.iterator();
  63.         while (it.hasNext()) {
  64.             // 由于引入泛型约束，这里不需要强制类型转换，可以直接赋值
  65.             c = it.next();
  66.             if (c.getName().equals("花花")) {
  67.                 flag = true;
  68.                 break;
  69.             }
  70.         }
  72.         if (flag) {
  73.             System.out.println("花花找到了");
  74.             System.out.println(c);
  75.         } else {
  76.             System.out.println("花花没找到");
  77.         }
  78.         System.out.println();
  80.         // 删除花花二代的信息并重新输出
  81.         // 这里用到增强型for循环，意思是set中的元素依次放到cat对象中
  82.         System.out.println("********* 删除花花二代的信息： **********");
  83.         for (Cat cat : set) {
  84.             if (cat.getName().equals("花花二代")) {
  85.                 set.remove(cat);
  86.             }
  87.         }
  88.         for (Cat cat : set) {
  89.             System.out.println(cat);
  90.         }
  91.         System.out.println();
  93.         // 删除集合中所有的宠物猫信息
  94.         System.out.println("********* 删除所有的宠物猫信息： **********");
  95.         boolean isClear = set.removeAll(set);
  96.         if(isClear) {    // set.isEmpty()也是可以的
  97.             System.out.println("猫都不见了。。。");
  98.         }else {
  99.             System.out.println("猫还在");
  100.         }
  101.     }
  102. }

[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 添加重复数据后的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 添加花花二代后的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]
[姓名：花花二代, 年龄：2, 品种：英国短毛猫]

* 查找花花的宠物猫信息： **
花花找到了
[姓名：花花, 年龄：12, 品种：英国短毛猫]

* 查找名字查找花花的信息： **
花花找到了
[姓名：花花, 年龄：12, 品种：英国短毛猫]

* 删除花花二代的信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 删除所有的宠物猫信息： **
猫都不见了。。。

CatTest.java -3
#删除宠物猫信息过程中可能碰到的问题

  1. package com.set;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. public class CatTest {
  9.     public static void main(String[] args) {
  10.         // 定义宠物猫对象
  11.         Cat huahua = new Cat("花花", 12, "英国短毛猫");
  12.         Cat fanfan = new Cat("凡凡", 3, "中华田园猫");
  14.         // 将宠物猫对象放入HashSet中
  15.         // <Cat>的意思是：往集合中加入的对象类型，必须是Cat类的对象，其他都不允许加入
  16.         Set<Cat> set = new HashSet<Cat>();
  17.         set.add(huahua);
  18.         set.add(fanfan);
  20.         // 显示宠物猫信息
  21.         // 同理，这里<Cat>的意思是迭代器中的元素都是Cat类的对象
  22.         Iterator<Cat> it = set.iterator();
  23.         while (it.hasNext()) {
  24.             System.out.println(it.next()); // 自动调用toString()方法
  25.         }
  26.         System.out.println();
  28.         // 重新插入一个新宠物猫
  29.         Cat huahua02 = new Cat("花花二代", 2, "英国短毛猫");
  30.         set.add(huahua02);
  31.         System.out.println("********* 添加花花二代后的宠物猫信息： **********");
  32.         it = set.iterator();
  33.         while (it.hasNext()) {
  34.             System.out.println(it.next()); // 自动调用toString()方法
  35.         }
  36.         System.out.println();
  38.         // 删除花花的信息并重新输出
  39.         // 这里删除花花的信息时会出错的
  40.         // Java为了保持数据的一致性，在查找数据的过程中是不允许删除数据的
  41.         // 这里找到花花的时候，查找过程还在继续，所以就出错了
  42. //        System.out.println("********* 删除花花的信息： **********");
  43. //        for (Cat cat : set) {
  44. //            if (cat.getName().equals("花花")) {
  45. //                set.remove(cat);
  46. //            }
  47. //        }
  48. //        for (Cat cat : set) {
  49. //            System.out.println(cat);
  50. //        }
  51. //        System.out.println();
  53.         // 解决方案1：找到花花之后直接break，不再继续查找
  54.         // 适合只删除一个对象的情况
  55. //        System.out.println("********* 删除花花的信息： **********");
  56. //        for (Cat cat : set) {
  57. //            if (cat.getName().equals("花花")) {
  58. //                set.remove(cat);
  59. //                break;
  60. //            }
  61. //        }
  62. //        for (Cat cat : set) {
  63. //            System.out.println(cat);
  64. //        }
  65. //        System.out.println();
  67.         // 解决方案2：使用removeAll()方法
  68.         // 适合删除多个对象的情况
  69.         System.out.println("********* 删除月龄小于5的宠物猫信息： **********");
  70.         Set<Cat> set1 = new HashSet<Cat>();
  71.         for (Cat cat : set) {
  72.             if (cat.getMonth() < 5) {
  73.                 set1.add(cat);
  74.             }
  75.         }
  76.         set.removeAll(set1);
  78.         for (Cat cat : set) {
  79.             System.out.println(cat);
  80.         }
  81.         System.out.println();
  83.     }
  84. }

[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]

* 添加花花二代后的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]
[姓名：凡凡, 年龄：3, 品种：中华田园猫]
[姓名：花花二代, 年龄：2, 品种：英国短毛猫]

* 删除月龄小于5的宠物猫信息： **
[姓名：花花, 年龄：12, 品种：英国短毛猫]

Map

  • Map中的数据是以键值对(key-value)的形式存储的
  • key-value以Entry类型的对象实例存在
  • 可以公共key值快速的查找value
  • 一个映射不能包含重复的键
  • 每个键最多只能映射到一个值
  • Map是一个接口

HashMap

  • 基于哈希表的Map接口的实现
  • 允许使用null值和null键
  • key值不允许重复
  • HashMap中的Entry对象是无序排列的

案例1：字典管理

  1. package com.set;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.Map;
  6. import java.util.Map.Entry;
  7. import java.util.Scanner;
  8. import java.util.Set;
  10. public class DictionaryDemo {
  12.     public static void main(String[] args) {
  13.         Map<String, String> animal = new HashMap<String, String>();
  14.         System.out.println("请输入三组单词对应的注释，并存放到HashMap中");
  15.         Scanner console = new Scanner(System.in);
  17.         // 添加数据
  18.         int i = 0;
  19.         while (i < 3) {
  20.             System.out.println("请输入key值(单词)：");
  21.             String key = console.next();
  22.             System.out.println("请输入value值(注释)：");
  23.             String value = console.next();
  24.             animal.put(key, value);
  25.             i++;
  26.         }
  27.         System.out.println();
  28.         System.out.println("***********************************");
  30.         // 打印输出value的值(直接使用迭代器)
  31.         System.out.println("使用迭代器输出所有的value：");
  32.         Iterator<String> it = animal.values().iterator();
  33.         while (it.hasNext()) {
  34.             System.out.print(it.next() + " ");
  35.         }
  36.         System.out.println();
  37.         System.out.println("***********************************");
  39.         // 打印输出key 和 value 的值
  40.         // 通过entrySet方法
  41.         System.out.println("通过entrySet方法得到key - value");
  42.         // entrySet是一个集合(Set)，其中的每一个元素是Entry，Entry是有键值<String,String>对构成的
  43.         Set<Entry<String, String>> entrySet = animal.entrySet();
  44.         for (Entry<String, String> entry : entrySet) {
  45.             System.out.print(entry.getKey() + "-");
  46.             System.out.println(entry.getValue());
  47.         }
  48.         System.out.println();
  49.         System.out.println("***********************************");
  51.         // 通过单词找到注释并输出
  52.         // 使用keySet方法
  53.         System.out.println("请输入要查找的单词：");
  54.         String strSearch = console.next();
  55.         // 1,取得keyset
  56.         Set<String> keySet = animal.keySet();
  57.         // 2,遍历keyset
  58.         for (String key : keySet) {
  59.             if (key.equals(strSearch)) {
  60.                 System.out.println("找到了！" + "键值对为：" + key + "-" + animal.get(key));
  61.                 break;
  62.             }
  63.         }
  64.     }
  65. }

案例2：商品管理
#输入异常处理，重复key处理

  1. package com.set;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.Map;
  6. import java.util.Scanner;
  8. public class GoodsTest {
  10.     public static void main(String[] args) {
  11.         Scanner console = new Scanner(System.in);
  13.         // 定义HashMap对象
  14.         Map<String, Goods> goodsMap = new HashMap<String, Goods>();
  16.         int i = 0;
  17.         while (i < 3) {
  18.             System.out.println("请输入第" + (i + 1) + "条商品信息");
  20.             System.out.println("商品编号：");
  21.             String goodsId = console.next();
  22.             // 判断商品编号是否已存在
  23.             if (goodsMap.containsKey(goodsId)) {
  24.                 System.out.println("该商品编号已经存在！请重新输入！");
  25.                 continue;
  26.             }
  28.             System.out.println("商品名称：");
  29.             String goodsName = console.next();
  31.             System.out.println("商品价格：");
  32.             double goodsPrice = 0;
  34.             try {
  35.                 goodsPrice = console.nextDouble();
  36.             } catch (Exception e) {
  37.                 System.out.println("商品价格的格式不正确，请输入数值型数据");
  38.                 console.next();
  39.                 continue;
  40.             }
  42.             // 将商品信息添加到HashMap中
  43.             Goods goods = new Goods(goodsId, goodsName, goodsPrice);
  44.             goodsMap.put(goodsId, goods);
  46.             i++;
  47.         }
  49.         // 遍历Map，输出商品信息
  50.         System.out.println("商品的全部信息为：");
  51.         Iterator<Goods> itGoods = goodsMap.values().iterator();
  52.         while (itGoods.hasNext()) {
  53.             System.out.println(itGoods.next());
  54.         }
  55.     }
  56. }

排序

对基本数据类型进行排序

  1. package com.sort;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class IntSort {
  9.     public static void main(String[] args) {
  10.         // 对存储在List中的整型数据进行排序
  11.         // List中添加的都是对象，所以泛型只能写类的名字
  12.         // 由于Java中有包装器类的关系，在list中添加的时候会直接把整型封装成对象
  13.         List<Integer> list = new ArrayList<Integer>();
  14.         list.add(5);
  15.         list.add(9);
  16.         list.add(3);
  17.         list.add(1);
  19.         System.out.println("排序前");
  20.         for (int n : list) {
  21.             System.out.print(n + "  ");
  22.         }
  23.         System.out.println();
  25.         // 对List中的数据进行排序
  26.         Collections.sort(list);
  28.         System.out.println("排序后");
  29.         for (int n : list) {
  30.             System.out.print(n + "  ");
  31.         }
  32.         System.out.println();
  33.     }
  34. }

排序前
5 9 3 1
排序后
1 3 5 9

对字符串类型进行排序

  1. package com.sort;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class StringSort {
  9.     public static void main(String[] args) {
  10.         // 对存放在List中的字符串进行排序
  11.         List<String> list = new ArrayList<String>();
  13.         list.add("orange");
  14.         list.add("blue");
  15.         list.add("yellow");
  16.         list.add("gray");
  18.         System.out.println("排序前");
  19.         for (String n : list) {
  20.             System.out.print(n + "  ");
  21.         }
  22.         System.out.println();
  24.         // 对List中的数据进行排序
  25.         Collections.sort(list);
  27.         System.out.println("排序后");
  28.         for (String n : list) {
  29.             System.out.print(n + "  ");
  30.         }
  31.         System.out.println();
  32.     }
  33. }

排序前
orange blue yellow gray
排序后
blue gray orange yellow

Comparator接口

  • 强行对某个对象进行整体排序的比较函数
  • 可以将Comparator传递给sort方法（如Collecddtions.sort或Arrays.sort）
  • int compare(T o1, T o2) 比较用来排序的两个参数

前提o1>o2，想要升序排序，就返回正整数
前提o1>o2，想要降序排序，就返回负整数

Cat.java

  1. package com.sort;
  3. public class Cat {
  4.     private String name;
  5.     private int month;
  6.     private String species;
  8.     // 构造方法
  9.     public Cat(String name, int month, String species) {
  10.         super();
  11.         this.name = name;
  12.         this.month = month;
  13.         this.species = species;
  14.     }
  16.     // getter与setter方法
  17.     ...
  19.     // 方便显示输出自定义对象的内容
  20.     @Override
  21.     public String toString() {
  22.         return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
  23.     }
  25. }

NameComparator.java

  1. package com.sort;
  3. import java.util.Comparator;
  5. public class NameComparator implements Comparator<Cat> {
  7.     @Override
  8.     public int compare(Cat o1, Cat o2) {
  9.         // 按名字升序排序
  10.         String name1 = o1.getName();
  11.         String name2 = o2.getName();
  12.         // return name2.compareTo(name1);    // 降序
  13.         return name1.compareTo(name2);    // 升序
  14.     }
  15. }

AgeComparator

  1. package com.sort;
  3. import java.util.Comparator;
  5. public class AgeComparator implements Comparator<Cat> {
  7.     @Override
  8.     public int compare(Cat o1, Cat o2) {
  9.         // 按年龄降序排序
  10.         int age1 = o1.getMonth();
  11.         int age2 = o2.getMonth();
  12.         return age2 - age1;
  13.     }
  14. }

CatTest.java

  1. package com.sort;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class CatTest {
  9.     public static void main(String[] args) {
  10.         // 按名字升序排序
  11.         Cat huahua = new Cat("huahua", 4, "英国短毛猫");
  12.         Cat fanfan = new Cat("fanfan", 2, "中华田园猫");
  13.         Cat maomao = new Cat("maomao", 3, "中华田园猫");
  14.         List<Cat> catList = new ArrayList<Cat>();
  15.         catList.add(huahua);
  16.         catList.add(fanfan);
  17.         catList.add(maomao);
  19.         // 排序前
  20.         System.out.println("排序前：");
  21.         for (Cat cat : catList) {
  22.             System.out.println(cat);
  23.         }
  25.         // 按名字进行升序排序
  26.         Collections.sort(catList, new NameComparator());
  27.         System.out.println("按名字排序后：");
  28.         for (Cat cat : catList) {
  29.             System.out.println(cat);
  30.         }
  32.         // 按年龄进行降序排序
  33.         Collections.sort(catList, new AgeComparator());
  34.         System.out.println("按年龄降序后：");
  35.         for (Cat cat : catList) {
  36.             System.out.println(cat);
  37.         }
  38.     }
  39. }

排序前：
[名字：huahua, 年龄：4, 品种：英国短毛猫]
[名字：fanfan, 年龄：2, 品种：中华田园猫]
[名字：maomao, 年龄：3, 品种：中华田园猫]

按名字排序后：
[名字：fanfan, 年龄：2, 品种：中华田园猫]
[名字：huahua, 年龄：4, 品种：英国短毛猫]
[名字：maomao, 年龄：3, 品种：中华田园猫]

按年龄降序后：
[名字：huahua, 年龄：4, 品种：英国短毛猫]
[名字：maomao, 年龄：3, 品种：中华田园猫]
[名字：fanfan, 年龄：2, 品种：中华田园猫]

Comparable接口

  • 此接口强行对实现它的每个类的对象进行整体排序
  • 这种排序被成为类的自然排序，类的 compareTo 方法被成为它的自然比较方法
  • 对于集合，通过调用Collections.sort方法进行排序
  • 对于数组，通过调用Array.sort()方法进行排序
  • int compareTo(T o)方法

该对象小于，等于或大于指定对象，则分别返回负整数，零或正整数

Goods.java

  1. package com.sort;
  3. public class Goods implements Comparable<Goods> {
  4.     private String id;
  5.     private String name;
  6.     private double price;
  8.     // 构造方法
  9.     public Goods(String id, String name, double price) {
  10.         super();
  11.         this.id = id;
  12.         this.name = name;
  13.         this.price = price;
  14.     }
  16.     // getter和setter
  17.     ...
  19.     public String toString() {
  20.         return "商品编号：" + id + "，商品名称：" + name + "，商品价格：" + price;
  21.     }
  23.     @Override
  24.     public int compareTo(Goods o) {
  25.         // 取出商品价格
  26.         double price1 = this.getPrice();
  27.         double price2 = o.getPrice();
  29.         // 当price1和price2的差小于1时，返回结果为0，可以根据需求做进一步判断
  30.         // 这里只是掩饰compareTo，不再追求这种细节
  31.         return new Double(price2 - price1).intValue();
  32.     }
  34. }

GoodsTest.java

  1. package com.sort;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class GoodsTest {
  9.     public static void main(String[] args) {
  10.         Goods g1 = new Goods("s0001", "手机", 2000);
  11.         Goods g2 = new Goods("s0002", "冰箱", 5000);
  12.         Goods g3 = new Goods("s0003", "电视机", 3000);
  14.         List<Goods> goodsList = new ArrayList<Goods>();
  15.         goodsList.add(g1);
  16.         goodsList.add(g2);
  17.         goodsList.add(g3);
  19.         // 排序前
  20.         System.out.println("排序前：");
  21.         for (Goods goods : goodsList) {
  22.             System.out.println(goods);
  23.         }
  25.         // 排序后
  26.         Collections.sort(goodsList);
  27.         System.out.println("排序后：");
  28.         for (Goods goods : goodsList) {
  29.             System.out.println(goods);
  30.         }
  31.     }
  32. }

排序前：
商品编号：s0001，商品名称：手机，商品价格：2000.0
商品编号：s0002，商品名称：冰箱，商品价格：5000.0
商品编号：s0003，商品名称：电视机，商品价格：3000.0

排序后：
商品编号：s0002，商品名称：冰箱，商品价格：5000.0
商品编号：s0003，商品名称：电视机，商品价格：3000.0
商品编号：s0001，商品名称：手机，商品价格：2000.0

image.png
补充：Comparator可以实现多个比较方法，Comparable只能实现一个比较方法