理解Collections.sortL() 方法

官方Java文档只是简要描述此方法的作用,并未进行详细的介绍,本文将深入解析此方法。
1. 简单示例

sort方法的使用非常的简单明了,下面的例子中,先定义一个比较Dog大小的Comparator,然后将其实例对象作为参数传给sort方法,通过此示例,你应该能够快速掌握Arrays.sort()的使用方法。

[java]  view plain copy
  1. import java.util.Arrays;  
  2. import java.util.Comparator;  
  3.    
  4. class Dog{  
  5.     int size;     
  6.     public Dog(int s){  
  7.         size = s;  
  8.     }  
  9. }  
  10.    
  11. class DogSizeComparator implements Comparator<Dog>{  
  12.    
  13.     @Override  
  14.     public int compare(Dog o1, Dog o2) {  
  15.         return o1.size - o2.size;  
  16.     }  
  17. }  
  18.    
  19. public class ArraySort {  
  20.    
  21.     public static void main(String[] args) {  
  22.         Dog d1 = new Dog(2);  
  23.         Dog d2 = new Dog(1);  
  24.         Dog d3 = new Dog(3);  
  25.    
  26.         Dog[] dogArray = {d1, d2, d3};  
  27.         printDogs(dogArray);  
  28.    
  29.         Arrays.sort(dogArray, new DogSizeComparator());   
  30.         printDogs(dogArray);  
  31.     }  
  32.    
  33.     public static void printDogs(Dog[] dogs){  
  34.         for(Dog d: dogs)  
  35.             System.out.print(d.size + " " );  
  36.    
  37.         System.out.println();  
  38.     }  
  39. }  
输出为:
[plain]  view plain copy
  1. 2 1 3  
  2. 1 2 3  

2. 使用策略模式
这是策略模式(Strategy pattern)的一个完美又简洁的示例,值得一提的是为什么这种场景下适合使用策略模式.
总体来说,策略模式允许在程序执行时选择不同的算法.比如在排序时,传入不同的比较器(Comparator),就采用不同的算法.
根据上面的例子,假设你想要根据Dog的重量来进行排序,可以像下面这样,创建一个新的比较器来进行排序:

[java]  view plain copy
  1. class Dog{  
  2.     int size;  
  3.     int weight;  
  4.    
  5.     public Dog(int s, int w){  
  6.         size = s;  
  7.         weight = w;   
  8.     }  
  9. }  
  10.    
  11. class DogSizeComparator implements Comparator<Dog>{  
  12.    
  13.     @Override  
  14.     public int compare(Dog o1, Dog o2) {  
  15.         return o1.size - o2.size;  
  16.     }  
  17. }  
  18.    
  19. class DogWeightComparator implements Comparator<Dog>{  
  20.    
  21.     @Override  
  22.     public int compare(Dog o1, Dog o2) {  
  23.         return o1.weight - o2.weight;  
  24.     }  
  25. }  
  26.    
  27. public class ArraySort {  
  28.    
  29.     public static void main(String[] args) {  
  30.         Dog d1 = new Dog(250);  
  31.         Dog d2 = new Dog(130);  
  32.         Dog d3 = new Dog(340);  
  33.    
  34.         Dog[] dogArray = {d1, d2, d3};  
  35.         printDogs(dogArray);  
  36.    
  37.         Arrays.sort(dogArray, new DogSizeComparator());   
  38.         printDogs(dogArray);  
  39.    
  40.         Arrays.sort(dogArray, new DogWeightComparator());     
  41.         printDogs(dogArray);  
  42.     }  
  43.    
  44.     public static void printDogs(Dog[] dogs){  
  45.         for(Dog d: dogs)  
  46.             System.out.print("size="+d.size + " weight=" + d.weight + " ");  
  47.    
  48.         System.out.println();  
  49.     }  
  50. }  
执行结果:
[plain]  view plain copy
  1. size=2 weight=50 size=1 weight=30 size=3 weight=40  
  2. size=1 weight=30 size=2 weight=50 size=3 weight=40  
  3. size=1 weight=30 size=3 weight=40 size=2 weight=50  
Comparator 是一个接口,所以sort方法中可以传入任意实现了此接口的类的实例,这就是策略模式的主要思想.

3. 为何使用"super"
如果使用 "Comparator < T > c" 那是很简单易懂的,但是sort的第2个参数里面的 < ? super T > 意味着比较器所接受的类型可以是T或者它的超类. 为什么是超类呢? 答案是: 这允许使用同一个比较器对不同的子类对象进行比较.在下面的示例中很明显地演示了这一点:
[java]  view plain copy
  1. import java.util.Arrays;  
  2. import java.util.Comparator;  
  3.    
  4. class Animal{  
  5.     int size;  
  6. }  
  7.    
  8. class Dog extends Animal{  
  9.     public Dog(int s){  
  10.         size = s;  
  11.     }  
  12. }  
  13.    
  14. class Cat extends Animal{  
  15.     public Cat(int s){  
  16.         size  = s;  
  17.     }  
  18. }  
  19.    
  20. class AnimalSizeComparator implements Comparator<Animal>{  
  21.    
  22.     @Override  
  23.     public int compare(Animal o1, Animal o2) {  
  24.         return o1.size - o2.size;  
  25.     }  
  26.     //in this way, all sub classes of Animal can use this comparator.  
  27. }  
  28.    
  29. public class ArraySort {  
  30.    
  31.     public static void main(String[] args) {  
  32.         Dog d1 = new Dog(2);  
  33.         Dog d2 = new Dog(1);  
  34.         Dog d3 = new Dog(3);  
  35.    
  36.         Dog[] dogArray = {d1, d2, d3};  
  37.         printDogs(dogArray);  
  38.    
  39.         Arrays.sort(dogArray, new AnimalSizeComparator());    
  40.         printDogs(dogArray);  
  41.    
  42.         System.out.println();  
  43.    
  44.         //when you have an array of Cat, same Comparator can be used.   
  45.         Cat c1 = new Cat(2);  
  46.         Cat c2 = new Cat(1);  
  47.         Cat c3 = new Cat(3);  
  48.    
  49.         Cat[] catArray = {c1, c2, c3};  
  50.         printDogs(catArray);  
  51.    
  52.         Arrays.sort(catArray, new AnimalSizeComparator());    
  53.         printDogs(catArray);  
  54.     }  
  55.    
  56.     public static void printDogs(Animal[] animals){  
  57.         for(Animal a: animals)  
  58.             System.out.print("size="+a.size + " ");  
  59.    
  60.         System.out.println();  
  61.     }  
  62. }  
输出结果:
[plain]  view plain copy
  1. size=2 size=1 size=3  
  2. size=1 size=2 size=3  
  3. size=2 size=1 size=3  
  4. size=1 size=2 size=3  

4. 小结
与Collections.sort()相关的信息总结如下:
  1. 通用: super 类
  2. 策略设计模式(strategy pattern);
  3. 归并排序(merge sort): 时间复杂度 n*log(n);
  4. Java.util.Collections#sort(List < T > list, Comparator < ? super T > c)与Arrays.sort 使用类似的思想

### 回答1: 可以用来获取一个 Map 对象中所有的 value 值,你可以通过以下代码实现: ``` Map<String, Integer> map = new HashMap<>(); map.put("key1", 1); map.put("key2", 2); map.put("key3", 3); Collection<Integer> values = map.values(); System.out.println(values); // 输出 [1, 2, 3] ``` ### 回答2: Collections.values 方法是Java集合框架中的一个方法,用于获取一个集合中所有值的集合。 该方法的作用是返回给定集合中的所有值视图。它返回一个Collection对象,该对象包含了给定集合中所有的值,无论是否有重复值。 在使用该方法时,需要将需要获取值的集合作为参数传入。 该方法的返回值是一个Collection对象,可以通过迭代器或者foreach循环来遍历其中的元素。这个Collection对象中包含了给定集合中所有的值,可以用于进一步的操作。 与该方法类似的还有Collections.keys方法,用于获取一个集合中所有的键的集合。在使用这两个方法时,可以方便地将集合中的键和值进行分离操作,以便更加灵活地进行处理。 使用Collections.values方法可以方便地获取集合中的所有值,特别适合在不需要考虑键的情况下,只需要操作值的场景。通过该方法,可以简化代码,提高效率。同时,由于该方法返回一个视图,而不是新的集合对象,所以不需要额外的内存空间来存储值,也可以节省资源。 总之,Collections.values方法是一个方便获取给定集合中所有值的方法,通过返回一个Collection对象,可以方便地操作和处理集合中的所有值。 ### 回答3: Collections.values 方法是Java集合框架中的一个静态方法,用于获取一个集合中所有值的集合。该方法接收一个Map类型的参数,并返回一个包含该Map中所有值的Collection集合。 使用Collections.values方法可以方便地获取Map中所有的值,无需使用遍历或键值对的方式来获取。具体使用方法如下: 1. 导入java.util.Collections和java.util.Map类。 2. 创建一个Map对象,例如:Map<String, Integer> map = new HashMap<>(); 3. 在Map对象中添加键值对,例如:map.put("A", 1); 4. 使用Collections.values方法获取该Map中所有值的集合,例如:Collection<Integer> values = Collections.values(map); 5. 可以通过遍历输出该集合的所有值,例如:for(Integer value : values) { System.out.println(value); } 通过以上步骤,就可以使用Collections.values方法获取Map中所有值,并将其存储在一个新的Collection集合中。这样做的好处是,可以更方便地操作和处理所有的值,而无需对键值对进行处理。 需要注意的是,返回的集合是一个视图,即它与原始的Map对象是关联的,对其中一个的操作会影响到另一个。如果需要使用一个独立的集合,可以将其复制到一个新的集合对象中。 总结来说,Collections.values方法是用于获取一个Map集合中所有值的方法,它简化了对值的获取操作,使得处理集合中的值更加方便。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值