java.utils.Collections
是 Java 提供的一个操作 Set
、List
和 Map
等集合的工具类。Collections 类提供了许多操作集合的静态方法,借助这些静态方法可以实现集合元素的排序、查找替换和复制 等操作。
排序(正向和逆向)
Collections 提供了如下方法用于对 List 集合元素进行排序。
void reverse(List list):
对指定 List 集合元素进行逆向排序。
void shuffle(List list):
对 List 集合元素进行随机排序(shuffle 方法模拟了“洗牌”动作)。
void sort(List list):
根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
void sort(List list, Comparator c):
根据指定 Comparator 产生的顺序对 List 集合元素进行排序。
void swap(List list, int i, int j):
将指定 List 集合中的 i 处元素和 j 处元素进行交换。
void rotate(List list, int distance):
当 distance 为正数时,将 list 集合的后 distance 个元素“整体”移到前面;当 distance 为负数时,
将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。
import java.util.ArrayList;
import java.util.Collections;
public class test{
public static void main(String []args)
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(13);
list.add(2);
list.add(35);
list.add(24);
System.out.println(list);
//对指定 List 集合元素进行逆向排序。
Collections.reverse(list);
System.out.println(list);
//对 List 集合元素进行随机排序(shuffle 方法模拟了“洗牌”动作)
Collections.shuffle(list);
System.out.println(list);
//根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
Collections.sort(list);
System.out.println(list);
//将指定 List 集合中的 i 处元素和 j 处元素进行交换。
Collections.swap(list, 2, 3);
System.out.println(list);
//将集合后2个元素移到前面
Collections.rotate(list, 2);
System.out.println(list);
//将集合前3个元素移到后面
Collections.rotate(list, -3);
System.out.println(list);
}
}
[13, 2, 35, 24]
[24, 35, 2, 13]
[2, 13, 35, 24]
[2, 13, 24, 35]
[2, 13, 35, 24]
[35, 24, 2, 13]
[13, 35, 24, 2]
查找、替换
Collections 还提供了如下常用的用于查找、替换集合元素的方法。
int binarySearch(List list, Object key):
使用二分搜索法搜索指定的 List 集合,以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作,则必须保证 List 中的元素已经处于有序状态。
Object max(Collection coll):
根据元素的自然顺序,返回给定集合中的最大元素。
Object max(Collection coll, Comparator comp):
根据 Comparator 指定的顺序,返回给定集合中的最大元素。
Object min(Collection coll):
根据元素的自然顺序,返回给定集合中的最小元素。
Object min(Collection coll, Comparator comp):
根据 Comparator 指定的顺序,返回给定集合中的最小元素。
void fill(List list, Object obj):
使用指定元素 obj 替换指定 List 集合中的所有元素。
int frequency(Collection c, Object o):
返回指定集合中指定元素的出现次数。
int indexOfSubList(List source, List target):
返回子 List 对象在父 List 对象中第一次出现的位置索引;如果父 List 中没有出现这样的子 List,则返回 -1。
int lastIndexOfSubList(List source, List target):
返回子 List 对象在父 List 对象中最后一次出现的位置索引;如果父 List 中没有岀现这样的子 List,则返回 -1。
boolean replaceAll(List list, Object oldVal, Object newVal):
使用一个新值 newVal 替换 List 对象的所有旧值 oldVal。
import java.util.ArrayList;
import java.util.Collections;
public class test{
public static void main(String []args)
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(13);
list.add(2);
list.add(35);
list.add(24);
System.out.println(list);
//先按升序排序
Collections.sort(list);
System.out.println(list);
//用二分搜索法搜索24返回其索引
int index = Collections.binarySearch(list, 24);
System.out.println(index);
//返回集合中最大元素
int max = Collections.max(list);
System.out.println(max);
//使用38替换集合中的35
Collections.replaceAll(list, 35, 38);
System.out.println(list);
//返回24元素在集合中出现的次数
int num =Collections.frequency(list, 24);
System.out.println(num);
}
}
[13, 2, 35, 24]
[2, 13, 24, 35]
2
35
[2, 13, 24, 38]
1
对于JDK8而言,有三种实现对象比较的方法:
1、覆写Object类的equals()
方法;
2、继承Comparable接口
,并实现compareTo()
方法;
3、定义一个单独的对象比较器,继承自Comparator接口
,实现compare()
方法。
由于使用的排序方式的不同,具体选择哪种方法来实现对象的比较也会有所不同。
java.lang.Comparable
接口,是一个给排序方法使用的接口, 这是一个自比较器接口。用于指定一个对象如何去比较大小。
方法:
int compareTo(T obj) :比较当前对象与传入进来对象的大小
参数:obj 表示要比较的对象返回值:
*如果当前的对象大于obj,返回正整数。
*如果当前的对象等于obj,返回0
*如果当前对象小于obj,返回负整
当排序的sort()方法在对集合中的元素两两进行比较的时候会调用我们实现的compareTo(T obj)方法。
如果compareTo()返回正整数,则表示当前元素大于和它比较的元素;
如果返回负整数则表示当前元素小于和它比较的元素;
如果返回0,则表示两者相等。
例:创建一个员工类,存储到ArrayList集合中并根据员工的工资进行升序排序操作
import java.util.ArrayList;
import java.util.Collections;
class Employee implements Comparable<Employee> {
private int id;
private String name;
private int salary;
public Employee(int id,String name,int salary)
{
this.id=id;
this.name=name;
this.salary=salary;
}
@Override
public int compareTo(Employee o) {
//告诉sort()方法比较规则
return this.salary-o.salary;//工资升序
}
public String toString()
{
return "employee{" + "id='" + id+ '\'' + ", name=" + name + '\'' + ",salary="+salary+'}';
}
}
public class test{
public static void main(String[] args) {
ArrayList<Employee> list = new ArrayList<Employee>();
list.add(new Employee(1, "张三",7000));
list.add(new Employee(2, "李四",5000));
list.add(new Employee(3, "王五",6000));
System.out.println("排序前:");
for (Employee employee : list) {
System.out.println(employee);
}
//排序
//要求 该list中元素类型 必须实现比较器Comparable接口
Collections.sort(list);
System.out.println("排序后:");
for (Employee employee : list) {
System.out.println(employee);
}
}
}
java.util.Comparator
接口,创建一个比较器的接口,一个类实现这个接口,相当于指定了一个排序的规则。
Comparator接口中的方法
public int compare(String o1, String o2) :
比较o1和o2这两个对象如果:
obj1 > obj2,这个方法返回正整数
obj2 == obj1, 返回0
obj1 < obj2,这个方法返回负整数
例:创建一个员工类,存储到ArrayList集合中并分别写一个Id比较器接口根据Id升序排列
和一个Salary比较器根据Salary升序排列
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Employee implements Comparable<Employee> {
private int id;
private String name;
private int salary;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public Employee(int id,String name,int salary)
{
this.id=id;
this.name=name;
this.salary=salary;
}
@Override
public int compareTo(Employee o) {
//告诉sort()方法比较规则
return this.salary-o.salary;//工资升序
}
public String toString()
{
return "employee{" + "id='" + id+ '\'' + ", name=" + name + '\'' + ",salary="+salary+'}';
}
}
//Id比较器
class IdComparator implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getId()-o2.getId();//根据Id升序
}
}
//salary比较器
class SalaryComparator implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getSalary()-o2.getSalary();//根据salary升序
}
}
public class test{
public static void main(String[] args) {
ArrayList<Employee> list = new ArrayList<Employee>();
list.add(new Employee(1, "张三",7000));
list.add(new Employee(4, "李四",5000));
list.add(new Employee(3, "王五",6000));
list.add(new Employee(2, "谢六",3000));
System.out.println("排序前:");
for (Employee employee : list) {
System.out.println(employee);
}
//根据Id比较器排序
Collections.sort(list, new IdComparator());
System.out.println("根据Id排序后:");
for (Employee employee : list) {
System.out.println(employee);
}
//根据Salary比较器排序
Collections.sort(list, new SalaryComparator());
System.out.println("根据Salary排序后:");
for (Employee employee : list) {
System.out.println(employee);
}
}
}
排序前:
employee{
id='1', name=张三',salary=7000}
employee{
id='4', name=李四',salary=5000}
employee{
id='3', name=王五',salary=6000}
employee{
id='2', name=谢六',salary=3000}
根据Id排序后:
employee{
id='1', name=张三',salary=7000}
employee{
id='2', name=谢六',salary=3000}
employee{
id='3', name=王五',salary=6000}
employee{
id='4', name=李四',salary=5000}
根据Salary排序后:
employee{
id='2', name=谢六',salary=3000}
employee{
id='4', name=李四',salary=5000}
employee{
id='3', name=王五',salary=6000}
employee{
id='1', name=张三',salary=7000}
扩展:如果在使用的时候,想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor c)
方式,自己定义 规则:
比如上面的代码直接写成:
Collections.sort(list, new Comparator<Employee>()
{
@Override
public int compare(Employee o1, Employee o2)
{
return o1.getId()-o2.getId();//根据Id升序
}
});
Collections.sort(list, new Comparator<Employee>()
{
@Override
public int compare(Employee o1, Employee o2)
{
return o1.getSalary()-o2.getSalary();//根据salary升序
}
});
Comparable & Comparator 都是用来实现集合中的排序的,
只是 Comparable 是在对象内部定义的方法实现的排序,Comparator 是在集合外部实现的排序。
java.lang
下,Comparator位于包java.util
下。Comparable:强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序,类的compareTo方法 被称为它的自然比较方法。只能在类中实现compareTo()一次,不能经常修改类的代码实现自己想要的排序。实现 此接口的对象列表(和数组)可以通过
Collections.sort(和Arrays.sort)进行自动排序,对象可以用作有序映射中 的键或有序集合中的元素,无需指定比较器。 Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法(如Collections.sort或 Arrays.sort),从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构(如有序set或 有序映射)的顺序,或者为那些没有自然顺序的对象collection提供排序。
欢迎持续关注!
个人博客站:jQueryZk Blog