Java学习-Collections工具类和Java常见的几种比较器

最新推荐文章于 2024-04-19 21:14:00 发布

jQueryZK

最新推荐文章于 2024-04-19 21:14:00 发布

阅读量3.3k

点赞数 1

分类专栏： java学习文章标签： java Java比较器 Collections

本文链接：https://blog.csdn.net/weixin_44279178/article/details/108511537

版权

java学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、Collections集合工具类

1.1基本介绍

java.utils.Collections 是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制 等操作。

1.2Collections常用方法

排序（正向和逆向）
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

2、Java的比较器

2.1常用比较方法介绍

对于JDK8而言，有三种实现对象比较的方法：
1、覆写Object类的equals（）方法；
2、继承Comparable接口，并实现compareTo（）方法；
3、定义一个单独的对象比较器，继承自Comparator接口，实现compare（）方法。
由于使用的排序方式的不同，具体选择哪种方法来实现对象的比较也会有所不同。

2.2Comparable比较器

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);
        }
    }
}

2.3Comparator比较器

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升序
  	}
});

2.4Comparable和Comparator的区别

Comparable & Comparator 都是用来实现集合中的排序的，
只是 Comparable 是在对象内部定义的方法实现的排序，Comparator 是在集合外部实现的排序。

Comparable位于包java.lang下，Comparator位于包java.util下。
Comparable接口将比较代码嵌入自身类中，而Comparator在一个独立的类中实现比较。
如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，
可以通过Comparator 来实现比较算法进行排序。
Comparator为了使用不同的排序规则做准备。比如：升序、降序或按不同的属性进行排序。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过

Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。 Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

欢迎持续关注！
我的CSDN主页
个人博客站：jQueryZK Blog

jQueryZK

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java学习-Collections工具类和Java常见的几种比较器

1、Collections集合工具类1.1基本介绍java.utils.Collections 是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制等操作。1.2Collections常用方法排序（正向和逆向）Collections 提供了如下方法用于对 List 集合元素进行排序。void reverse(List list)：对指定 List 集合元素进行
复制链接

扫一扫