LOADING

从入门到精通学习工具类Collections完整指南

从入门到精通学习工具Collections完整指南

电报联系方式

介绍

Collections是一个用于处理Set、List、Map等集合的工具类,它包含了一系列静态方法,可用于对集合元素进行排序、查询、修改等操作。此外,它还提供了方法,可以将集合对象设置为不可变的,以及实现对集合对象的同步控制。

常用功能

挑选几个常用的功能,为大家演示一下使用:

public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
● public static <T> void sort(List<T> list):根据元素的自然顺序 对指定列表按升序进行排序
● public static <T> void sort(List<T> list,Comparator<? super T> ): 根据指定比较器产生的顺序对指定列表进行排序。

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

class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return “Person{” +
“name='” + name + ‘\” +
“, age=” + age +
‘}’;
}
}

public class Demo1Collections {

public static void main(String[] args) {

//创建一个List 集合
List<Integer> numbers = new ArrayList<>();
//在这里咱们顺便使用下Collections的addAll()方法
Collections.addAll(numbers, 3,34,345,66,22,1);

System.out.println(“原集合” + numbers);
//使用排序算法
Collections.sort(numbers);
System.out.println(“排序之后”+numbers);

Collections.shuffle(numbers);
System.out.println(“乱序之后” + numbers);

//创建一个字符串List 集合
List<String> stringDemo = new ArrayList<>();
stringDemo.add(“nihao”);
stringDemo.add(“hello”);
stringDemo.add(“wolrd”);
stringDemo.add(“all”);
System.out.println(“原集合” + stringDemo);
//使用排序算法
Collections.sort(stringDemo);
System.out.println(“排序之后”+stringDemo);

List<Person> people = new ArrayList<>();
people.add(new Person(“秋香”, 15));
people.add(new Person(“石榴姐”, 19));
people.add(new Person(“唐伯虎”, 12));
System.out.println(“–” + people);

//如果Person类中,这里报错了,为什么呢? 在这里埋个伏笔,且看下文
Collections.sort(people);

System.out.println(“—-” + people);

}
}

Comparable 和 Comparator

Comparable 接口实现 集合排序

在我们之前的代码示例中,当我们尝试使用自定义类型进行排序时,出现了错误。这是因为在排序操作中,Collections类使用了元素的自然顺序,并要求所有元素必须实现Comparable接口。而Comparable接口中只定义了一个方法compareTo(T o),用于比较对象的顺序。

相比之下,整型包装类和字符串类型已经实现了Comparable接口,因此它们可以直接参与排序操作。这是因为这些类已经定义了如何比较它们之间顺序的方法,而我们的自定义类型需要手动实现Comparable接口来告诉排序方法如何比较对象的顺序。

简单说就是我们使用自定义类型,进行集合排序的时候,需要实现这个Comparable接口,并且重写 compareTo(T o)。

public class Person2 implements Comparable<Person2>{
private String name;
private int age;

public Person2(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return “Person2{” +
“name='” + name + ‘\” +
“, 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 int compareTo(Person2 o) {
//重写方法如何写呢?
// return 0; //默认元素都是相同的
//自定义规则 我们通过person 的年龄进行比较 this 代表本身,而 o 代表传参的person对象
//这里的比较规则
// ==》 升序 自己 – 别人
// ==》 降序 别人 – 自己
// return this.getAge() – o.getAge(); //升
return o.getAge() – this.getAge(); //降

}
}

public class Demo2Comparable {

public static void main(String[] args) {
List<Person2> people2 = new ArrayList<>();
people2.add(new Person2(“秋香”, 15));
people2.add(new Person2(“石榴姐”, 19));
people2.add(new Person2(“唐伯虎”, 12));
System.out.println(“–” + people2);

//这里报错了,为什么呢?
Collections.sort(people2);

System.out.println(“—-” + people2);
}
}

Comparator 实现排序

通过实现Comparable接口进行排序有一些局限性,特别是对于那些偶尔需要排序的自定义类而言,这可能有些繁琐。为了提供更灵活的排序方式,工具类还为我们提供了另一种种类选择:使用Comparator接口。

Comparator修改接口允许我们在需要排序的时候,提供一个独立的逻辑,而消耗自定义类本身。我们可以创建一个实现Comparator接口的类,然后在排序时比较器传递给排序方法。这种方式使得排序逻辑更加灵活,可以根据需要随时定制不同的比较规则,而不必修改原始类的代码。

public static <T> void sort(List<T> list, Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。我们通过案例来看看该方法的使用

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

public Person(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 “Person{” +
“name='” + name + ‘\” +
“, age=” + age +
‘}’;
}
}

public class Demo3Comparator {
public static void main(String[] args) {

List<Person> people = new ArrayList<>();
people.add(new Person(“秋香”, 15));
people.add(new Person(“石榴姐”, 19));
people.add(new Person(“唐伯虎”, 12));
System.out.println(“–” + people);

//第二个参数 采用匿名内部类的方式传参 – 可以复习之前有关内部类的使用
Collections.sort(people, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
//这里怎么用呢 自定义按年龄排序
// return 0;
// return o1.getAge() – o2.getAge(); //升序
return o2.getAge() – o1.getAge(); //降序

//结论: 前者 -后者 升序 反之,降序
//这种方式 我们优先使用
}
});
System.out.println(“排序后—-” + people);
}
}

Comparable 和 Comparator

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

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

小结

在Java中,Collections是一种用于处理集合的工具类,它提供了一系列静态方法,用于对集合进行排序、查找等操作。需要注意的是,Map是一种特殊的集合,用于存储键值对数据。虽然Collections类的一些方法可以直接操作Map的键或值的集合视图,但不能直接对整个Map进行操作。

Collections 类提供了一些静态方法来对 Map 的键或值集合视图进行操作,比如排序、查找最大值、查找最小值等。例如,Collections.sort 方法可以对 List 类型的集合进行排序,而 List 类型的 map.keySet() 和 map.values() 返回的集合都可以使用这个方法进行排序。同样地,Collections.max 和 Collections.min 也可以用于获取集合中的最大值和最小值。

对于整个Map的操作,直接使用Map接口提供的方法即可,如put、get、remove等。如果需要对整个Map进行操作,通常直接调用Map接口提供的方法更加方便和欣赏。

综上所述,Collections类主要用于处理集合类(如List、Set),而对于Map类型的操作,通常直接使用Map接口提供的方法即可。

开发联系:DEXDAO

 

 

© 版权声明

相关文章

暂无评论

暂无评论...