Java基础(十八)——Comparator比较器、Comparable接口和Map集合

2023-08-08 09:26:37

Comparator接口比较器 

1 Collections工具及其中的sort()
2 public static <T> void sort(List<T> list)
3 public static <T> void sort(List<T> list,Comparator<? T> c）

　　Comparator接口在java.util包下面，排序是Comparator需要实现的功能之一，该接口代表的是一个比较器，比较器具有可比性，可以做排序的，本质其实是比较两个对象谁排在前边谁排在后面。那么比较的方法是：

1 public int compare(Object o1,Object o2),比较两个参数的顺序
2     两个对象比较的结果有三种，大于，等于，小于
3     如果要安装升序排序，则o1小于o2返回(负数),相等返回0，o1大于o2返回(正数)
4     如果要按照降序排序，则o1小于o2返回(正数),相等返回0，o1大于o2返回(负数)
5     简化操作
6         升序排序：o1-o2
7         降序排序：o2-o1

实例代码如下：

 1 public static void main(String[] args){
 2     //排序规则，按照字符串的第一个字母降序排序
 3     //public static <T> void sort(List<T> list)
 4     ArrayList<String> list = new ArrayList<>();
 5     list.add("abC");
 6     list.add("cba");
 7     list.add("bca");
 8     list.add("sba");
 9     list.add("nba");
10     //排序规则，按照字符串的第一个字母降序排序
11     //使用接口中的方法，
12     //public static <T> void sort(List<T> list,Comparator<? super T>  c) 
13     //public int compare(Object o1,Object o2),比较两个参数的顺序
14     Collections.sort(list,new Comparator(){
15         @Override
16         public int compara(String o1,String o2){
17             return o2.charAt(0) - o1.charAt(0);
18         }
19     });
20     System.out.println(list);
21 }
22 //控制台结果
23 [sba,nba,cba,bca,abc]

Comparable和Comparator两个接口的区别

　　Comparable:强行对实现它的每个类对象进行整体排序。这种排序我们一般把它称为自然排序，类的compareTo方法称为它的自然比较方法。只能在类中实现compareTo方法一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表(和数组)可以通过Collection.sort()(和Arrays.sort())进行自动排序，对象可以用作有序映射中的键或者有序集合中的元素，无须指定比较器。

　　Comparator：强行对某个对象进行整体排序。可以将Comparator传递给sort()方法(如Collection.sort()后者Arrays.sort())，从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构(有序的set或者是有序的映射)的顺序，或者为那些没有自然顺序的对象Collection提供排序。

 1 public class Student { 
 2     private String name;
 3     private int age;
 4     //get和set方法
 5     //toString方法
 6     //无参构造和全参构造
 7 }
 8 public class CollectionsDemo01 {
 9     public static void main(String[] args) {
10         ArrayList<Student> list = new ArrayList<>();
11         list.add(new Student("tom",18));
12         list.add(new Student("lily",26));
13         list.add(new Student("jack",21));
14         list.add(new Student("rose",40));
15         list.add(new Student("lucy",21));
16         //按照年龄升序排序
17         //如果年龄相同的，按照姓名排序，按照姓名的首字母降序排序
18         //嵌套比较
19         //o1 - o2 升序
20         //o2 - o1 降序
21         Collections.sort(list, new Comparator<Student>() {
22             @Override
23             public int compare(Student o1, Student o2) {
24                 return o1.getAge()== o2.getAge() ?
25                         o2.getName().charAt(0) - o1.getName().charAt(0) :
26                         o1.getAge() - o2.getAge();
27             }
28         });
29         System.out.println(list);
30     }
31 }

Map集合

　　概述

　　　　现实生活中，我们常常会看到这样一种集合：IP地址和主机名，身份证号和个人，系统用户名与系统用户对象等，这种是一一对应的关系，我们把它称之为映射。Java当中提供了专门的集合类用来存放这种映射关系的对象。即java.util.Map接口。

　　　　通过如下图发现Collection接口集合和Map接口集合存储数据的方式不一样。

    • 　Collection中的集合，元素是孤立存在的(单身)，向集合中存储元素采用一个一个元素存储的方式进行存储。
    •  Map中的集合，元素是成对存在的(夫妻），每个元素由键和值两部分组成。通过键可以找到对应的值。
    •  Collectiom中的集合被称之为单列集合，Map中的集合被称之为双列集合
    •  注意：Map中的集合不能包含重复的键，值可以重复，每个键对应唯一一个值。

Java基础(十八)——Comparator比较器、Comparable接口和Map集合

 

 

 

　　Map中的常用子类

　　　　通过查看API帮助文档可以发现Map接口有很多的子类，主要的是HashMap集合、LinkedMap集合、HashTable集合

  • 　HashMap：存储数据采用的是哈希表结构，元素的存取顺序可能不一致，由于要保证键的唯一性，不重复，需要重写简单hashCode和equals方法。
  •  LinkedHashMap: HashMap下面有个子类LinkedHashMap，存储数据的方式是采用哈希表和链表结构，可以通过链表结构保证元素的存取顺序一致；通过哈希表结构保证键的唯一不重复，需要重写键的hashCode方法和equals方法。

　　备注：Map接口当中，含有两个泛型变量，在使用是，要为两个泛型变量赋予数据类型，两个泛型变量的数据类型可以相同，也可以不同。

　　Map接口当中的常用API方法Map<K,V>

　　java.util.HashMap<K,V> implements Map<K,V>

　　HashMap集合的特点：

　　　　1.HashMap集合底层是哈希表，查询速度非常快

　　　　　　　　JDK1.8之前：数组+链表

　　　　　　　　JDK1.8之后：数组+链表/红黑树（当链表长度超过8）：提高查询性能

　　　　2.HashMap集合是一个无序集合，存取顺序可能不一致

　　　java.util.LinkedHashMap<K,V>extends HashMap<K,V>

　　　LinkedHashMap集合特点：

　　　　　1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)

　　　　　2.LinkedHashMap集合是一个有序的集合，存取元素的顺序是一致的。

　　常用方法如下： 

  • public V put(K key, V value)：把指定的键与指定的值添加到map集合当中

  • public V remove(Object key)：把指定的键所对应的键值对元素从Map集合当中删除，返回被删除的元素的值

  • public V get(Object key)：根据指定的键获得在Map集合当中对应的值

  • public Set<K> kesSet()：获取Map集合当中的所有的key值，存储到Set集合当中

  • public Set<Map,Entry<K,V>> entrySet()：获取到Map集合当中的所有的键值对对象的集合(Set集合

代码演示：

　　

 1  /*
 2     public V put(K key, V value)：把指定的键与指定的值添加到map集合当中
 3      返回值是V
 4         存储键值对的时候，key不重复，返回值V是null
 5         存储键值对的时候，key重复，会使用新的value值替换掉Map集合中原来的value值，返回的是被替换掉的value值
 6 
 7      */
 8 public static void show01() {
 9         //使用多态
10         Map<String, String> map = new HashMap<>();
11         String v01 = map.put("小孙", "小丽");
12         System.out.println(v01);//null
13         String v02 = map.put("小孙", "小花");
14         System.out.println(v02);//小丽
15         System.out.println(map);//{小孙=小花}
16         map.put("小王", "小丽");
17         map.put("小赵", "小美");
18         map.put("小刘", "小芳");
19         System.out.println("---------------------");
20         System.out.println(map);//{小孙=小花, 小刘=小芳, 小王=小丽, 小赵=小美}
21     }
22 
23  /*
24         public V remove(Object key)：把指定的键所对应的键值对元素从Map集合当中删除，返回被删除的元素的值
25             返回值V
26                 key存在，返回的是删除的对应的value值
27                 key不存在，返回null
28     */
29     public static void show02() {
30         //使用多态
31         Map<String, Integer> map = new HashMap<>();
32         map.put("小孙", 30);
33         map.put("小王", 25);
34         map.put("小赵", 18);
35         map.put("小刘", 19);
36         System.out.println("---------------------------");
37         System.out.println(map);//{小孙=30, 小刘=19, 小王=25, 小赵=18}
38         int v01 = map.remove("小孙");
39         System.out.println(v01);//30
40         System.out.println(map);//{小刘=19, 小王=25, 小赵=18}
41 
42         Integer v02 = map.remove("小李");
43         //int i = v02.intValue();//null java.lang.NullPointerException
44         //建议使用包装类   整数 浮点数 字符 布尔
45         System.out.println(v02);
46         System.out.println(map);//{小刘=19, 小王=25, 小赵=18}
47     }
48 
49 /*
50   - public V get(Object key)：根据指定的键获得在Map集合当中对应的值
51     key存在，返回value值
52     key不存在，返回null
53     */
54     public static void show03(){
55         //使用多态
56         Map<String, Integer> map = new HashMap<>();
57         map.put("小孙", 30);
58         map.put("小王", 25);
59         map.put("小赵", 18);
60         map.put("小刘", 19);
61         System.out.println("---------------------------");
62         System.out.println(map);//{小孙=30, 小刘=19, 小王=25, 小赵=18}
63         Integer v1 = map.get("小孙");
64         System.out.println(v1);//30
65         Integer v2 = map.get("老王");
66         System.out.println(v2);//null
67 
68     }
 1  /* 
 2     Map集合中的第一种遍历方式，通过键找值的方式
 3         public Set<K> kesSet()：获取Map集合当中的所有的key值，存储到Set集合当中
 4     实现步骤：
 5         1.使用Map集合当中的KeySet方法，把Map集合当中的所有key值，存储到Set集合当中
 6         2.遍历Set集合，获取Map集合当中的每一个Key值
 7         3.通过Map集合当中的方法get(Key),通过Key找到value 
 8 */
 9 
10 public static void main(String[] args) {
11         //创建map集合对象
12         Map<String, Integer> map = new HashMap<>();
13         map.put("迪丽热巴", 178);
14         map.put("古力娜扎", 164);
15         map.put("马尔扎哈", 162);
16         map.put("撒由那拉", 150);
17         //使用Map集合当中的keySet方法，把Map集合当中的所有的key值，存储到Set集合当中
18         Set<String> sets = map.keySet();
19         //遍历Set集合 采用迭代器或者增强for循环
20         Iterator<String> iterator = sets.iterator();
21         while (iterator.hasNext()) {
22             String key = iterator.next();
23             Integer value = map.get(key);
24             System.out.println(key + " = " + value);
25            /* 撒由那拉 = 150
26             迪丽热巴 = 178
27             古力娜扎 = 164
28             马尔扎哈 = 162*/
29         }
30         System.out.println("-------------------------");
31         for (String key : sets) {
32             System.out.println(key + " = " + map.get(key));
33         }
34         System.out.println("-------------------------");
35         for (String key : map.keySet()) {
36             Integer value = map.get(key);
37             System.out.println(key + " = " + value);
38         }
39     }
 1 /*
 2     Map集合遍历的第二种方式：使用Entry对象遍历
 3     Map集合中的方法：
 4         public Set<Map,Entry<K,V>> entrySet()：获取到Map集合当中的所有的键值对对象的集合(Set集合)
 5     实现步骤：
 6         1.使用Map集合中的方法entrySet，把Map集合当中的多个对象取出来，存储到一个Set集合当中
 7         2.遍历Set集合，获取每一个Entry对象
 8         3.使用Entry对象中的方法getKey()和getValue()分别获取Map集合当中的键与值 
 9     Map.Entry<K,V>；在Map接口中有一个内部接口Entry
10     作用：当Map接口集合一创建，紧接着就会在Map集合中创建一个Entry对象，用来记录Map中的键与值(
11     键值对对象，键与值是映射关系)
12 
13 */
14 public static void main(String[] args) {
15         Map<String, Integer> map = new HashMap<>();
16         map.put("孙大圣", 150);
17         map.put("孙行者", 160);
18         map.put("者行孙", 170);
19         map.put("行者孙", 175);
20         //1.使用Map集合中的方法entrySet，把Map集合当中的多个对象取出来，存储到一个Set集合当中
21         Set<Map.Entry<String, Integer>> set = map.entrySet();
22         //2.遍历Set集合，获取每一个Entry对象
23         //使用迭代器遍历Set集合
24         Iterator<Map.Entry<String, Integer>> iterator = set.iterator();
25         while (iterator.hasNext()) {
26             //取出下一个元素
27             Map.Entry<String, Integer> entry = iterator.next();
28             //3.使用Entry对象中的方法getKey()和getValue()分别获取Map集合当中的键与值
29             String key = entry.getKey();
30             Integer value = entry.getValue();
31             System.out.println(key + " = " + value);
32         }

 

上一篇：输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。


下一篇：数据结构（）：排序算法