`

Comparable接口与Comparator接口的对比

    博客分类:
  • j2ee
 
阅读更多
1. Comparable接口与Comparator接口的对比
   comparable指定了比较方法在待比较的类中,直接利用Collections.sort()或Arrays.sort()排序就可以了。
   comparator则是指定了比较的行为,可以作为Collections.sort()或Arrays.sort()方法的参数

2.代码:
Comparable

public class Person implements Comparable<Person>
{
	private Integer id;
	private String name;
	private Integer age;
	public Person()
	{
	}
	
	public Person(Integer id, String name, Integer age)
	{
		this.id = id;
		this.name = name;
		this.age = age;
	}
	
	public Integer getId()
	{
		return id;
	}
	public void setId( Integer id )
	{
		this.id = id;
	}
	public String getName()
	{
		return name;
	}
	public void setName( String name )
	{
		this.name = name;
	}
	public Integer getAge()
	{
		return age;
	}
	public void setAge( Integer age )
	{
		this.age = age;
	}
	@Override
	public int compareTo( Person o )
	{
		return this.getAge().compareTo( o.getAge() );
	}
	
	
}


Comparator

import java.util.Comparator;

public class PersonComparetor implements Comparator<Person>
{

	@Override
	public int compare( Person o1, Person o2 )
	{
		return o1.getAge().compareTo( o2.getAge() );
	}


}



Datas

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

public class PersonsSingle
{
	private static List<Person> persons = null;
	private PersonsSingle()
	{
	}
	
	public static List<Person> getPersons(){
		persons = new ArrayList<Person>();
		persons.add( new Person( 1, "张三",26 ) );
		persons.add( new Person( 2, "王五",20 ) );
		persons.add( new Person( 3, "赵六",29 ) );
		persons.add( new Person( 4, "李四",26 ) );
		persons.add( new Person( 5, "周公",50 ) );
		return persons;
	}
}



Test

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

public class CollectionsTest
{
	public void sort(){
		double array[] = {112, 111, 23, 456, 231 }; 
		List list = new ArrayList();
		for (int i = 0; i < array.length; i++) { 
		list.add(new Double(array[i])); 
		} 
		Collections.sort(list); 
		for (int i = 0; i < array.length; i++) { 
		   System.out.println(list.get(i)); 
		}  
		System.out.println();
	}
	
	public void sortOne(){
		List<Person> list = PersonsSingle.getPersons();
		Collections.sort(list); 
		for (Person p: list) { 
		   System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		}  
		System.out.println();
	}
	
	public void sortTwo(){
		List<Person> list = PersonsSingle.getPersons();
		Collections.sort(list, new PersonComparetor()); 
		for (Person p: list) { 
		   System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		}  
		System.out.println();
	}
	
	public void shuffling(){
		List<Person> list = PersonsSingle.getPersons();
		//Collections.shuffling(list);
		Collections.shuffle(list); 
		for (Person p: list) { 
		   System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		}  
		System.out.println();
	}
	
	public void reverse(){
		List<Person> list = PersonsSingle.getPersons();
		Collections.reverse( list );
		for (Person p: list) { 
		   System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		}  
		System.out.println();
	}
	
	public void fill(){
		List<Person> list = PersonsSingle.getPersons();
		Collections.fill( list, new Person(6,"傻根", 34) ); 
		for (Person p: list) { 
		   System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		}  
		System.out.println();
	}
	
	public void minOne(){
		List<Person> list = PersonsSingle.getPersons();
		Person p = Collections.min( list );
		System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		System.out.println();
	}
	
	public void minTwo(){
		List<Person> list = PersonsSingle.getPersons();
		Person p = Collections.min( list, new PersonComparetor() );
		System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		System.out.println();
	}
	
	public void maxOne(){
		List<Person> list = PersonsSingle.getPersons();
		Person p = Collections.max( list );
		System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		System.out.println();
	}
	
	
	public void maxTwo(){
		List<Person> list = PersonsSingle.getPersons();
		Person p = Collections.max( list, new PersonComparetor() );
		System.out.println(p.getId() + "\t" + p.getName() + "\t" + p.getAge()); 
		System.out.println();
	}
	
	public void lastIndexOfSubList(){
		//int count = Collections.lastIndexOfSubList(list,li); 
		double array[] = {112, 111, 23, 456, 231 }; 
		List list = new ArrayList(); 
		List li = new ArrayList(); 
		for (int i = 0; i < array.length; i++) { 
			list.add(new Double(array[i])); 
		} 
		double arr[] = {111}; 
		String str[] = {"dd","aa","bb","cc","ee"}; 
		for(int j=0;j<arr.length;j++){ 
			li.add(new Double(arr[j])); 
		} 
		int locations = Collections.lastIndexOfSubList (list,li); 
		System.out.println("====="+ locations); 
	}
	
	public void indexOfSubList(){
		//int count = Collections.indexOfSubList(list,li); 
		double array[] = {112, 111, 23, 456, 231 }; 
		List list = new ArrayList(); 
		List li = new ArrayList(); 
		for (int i = 0; i < array.length; i++) { 
		list.add(new Double(array[i])); 
		} 
		double arr[] = {111}; 
		String str[] = {"dd","aa","bb","cc","ee"}; 
		for(int j=0;j<arr.length;j++){ 
		li.add(new Double(arr[j])); 
		} 
		int locations = Collections.indexOfSubList(list,li); 
		System.out.println("====="+ locations); 
	}
	
	public void rotate(){
		double array[] = {112, 111, 23, 456, 231 }; 
		List list = new ArrayList(); 
		for (int i = 0; i < array.length; i++) { 
			list.add(new Double(array[i])); 
		} 
		Collections.rotate(list,-1); 
		for (int i = 0; i <list.size(); i++) { 
			System.out.println("list[" + i + "]=" + list.get(i)); 
		} 
	}
	/**
	 * @desc 
	 * @param args
	 */
	public static void main( String[] args )
	{
		// TODO Auto-generated method stub
		CollectionsTest test = new CollectionsTest();
		//排序
		test.sort();
		test.sortOne();
		test.sortTwo();
		
		//混排
		test.shuffling();
		
		
		//反转
		test.reverse();
		
		//填充
		test.fill();
		
		//最小
		test.minOne();
		test.minTwo();
		
		//最大
		test.maxOne();
		test.maxTwo();
		
		//
		test.lastIndexOfSubList();
		
		//
		test.indexOfSubList();
		
		//
		test.rotate();
	}

}

分享到:
评论

相关推荐

    对比Java中的Comparable排序接口和Comparator比较器接口

    泛型化的Comparable接口允许你指定对象可以与哪种类型进行比较,通常是与它自身类型比较。 在某些情况下,你可能需要对不支持自然排序的类或者需要自定义排序规则的情况进行排序,这时Comparator接口就派上了用场。...

    Java Comparable和Comparator对比详解

    在实现 Comparable 接口时,需要重写 compareTo 方法,该方法用于比较当前对象与其他对象的大小,返回一个整数值,表示当前对象与其他对象的大小关系。如果返回值小于 0,表示当前对象小于其他对象;如果返回值大于 ...

    详解Java中Comparable和Comparator接口的区别

    * 一个类实现了Comparable接口,就意味着“该类本身支持排序”,它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。 * (02) "Comparator" * 它是一个比较器接口,包括两个函数:compare() 和 equals...

    Java集合框架[汇编].pdf

    8. **Comparable接口和Comparator接口** - **Comparable**:实现了Comparable接口的类可以进行自然排序,例如Integer、String等类。 - **Comparator**:Comparator接口用于自定义比较规则,可以在不修改源类的情况...

    javawiki源码-java_source_cn:Java1.8源码学习,详情见Wiki

    java wiki源码 ...Java1.8.0_91源码学习 Java源码学习1:java.lang.Void类 Java源码学习2:java.lang.Number抽象类 下面开始学习Number类的派生类。...Comparable接口和Comparator接口是相似接口,需要对比下。

    JavaEE技术问题汇总.docx

    Comparable接口用于对象自身定义自然排序,实现compareTo()方法。Comparator接口则用于外部定义对象排序规则,实现compare()方法。 【垃圾回收机制】 Java的垃圾回收机制自动管理内存,通过可达性分析判断对象是否...

    java集合三种比较器(详解)

    本文将深入探讨三种比较器的实现方式,分别是:实现`Comparable`接口和实现`Comparator`接口。 首先,我们来看实现`Comparable`接口的方式。`Comparable`接口适用于那些需要自定义排序逻辑的类。例如,假设我们有一...

    [计算机软件及应用]Java高级程序设计实验指导.doc

    实验步骤可能包括创建集合、添加元素、遍历集合、查找元素、删除元素等操作,同时涉及泛型、迭代器、Comparable和Comparator接口的使用。 实验结果与分析部分,学生需要展示代码实现,并分析不同集合类型在性能和...

    Java基础知识点 - 内容比较全面

    10. **Java中Comparable和Comparator实现对象比较**:Comparable接口用于定义对象的自然排序,而Comparator接口可以自定义比较规则,两者常用于集合排序。 11. **Java中的JNDI (Java Naming and Directory ...

    Java类集操作精心总结

    - **定义**:对于自定义类,可以通过实现 `Comparable` 接口或使用 `Comparator` 来实现排序。 - **示例代码**: ```java public class Person implements Comparable&lt;Person&gt; { private String name; private ...

    12道java经典上机测试题含答案

    12. **集合框架的高级用法**:TreeSet、TreeMap的排序原理,Comparator和Comparable接口的实现,以及集合的遍历方式(迭代器与增强for循环)。 以上知识点涵盖了Java编程的基础到进阶内容,通过解答这些题目,初学...

    java语言程序设计(第八版)复习题答案

    14. **集合高级特性**:包括TreeSet、TreeMap的使用,以及Comparator和Comparable接口的作用。 15. **枚举与注解**:枚举类型提供了更安全的常量表示,注解则为代码添加元信息。复习题可能涉及它们的定义和应用。 ...

    详解Java中Collections.sort排序

    如果列表中的元素没有实现`Comparable`接口或者想要根据不同的规则进行排序,这时就需要使用`Comparator`接口。`Comparator`提供了一个`compare()`方法,可以自定义两个对象的比较逻辑: ```java public interface ...

    019SetsLab2

    3. 理解并应用Comparable接口或者Comparator类在TreeSet中的排序逻辑。 4. 操作LinkedHashSet,观察并理解元素的插入顺序是如何影响遍历结果的。 通过这些练习,你将能更好地理解Java集合框架中Set接口的不同实现,...

    JAVA经典教材笔记

    - Comparable接口的作用:定义对象的自然排序规则。 - Comparator接口的用途:定义自定义排序规则。 - **观察者设计模式** - 观察者模式的概念:定义对象之间的一对多依赖关系。 - 观察者模式的实现:使用...

    String类下compareTo()与compare()方法比较

    例如,在MapReduce中,Map函数和Reduce函数处理的 ,value&gt; 需要根据key对键值对进行排序,因此key实现了WritableComparable接口,该接口是Writable接口和Comparable接口的组合。WritableComparable接口用于序列化和...

    Java集合排序及java集合类详解.pdf

    - **定制排序**:使用Comparator接口来定义元素之间的比较规则。 排序功能在处理大量数据时非常有用,特别是在需要按特定顺序展示数据的情况下。 #### 八、总结: 集合框架中常用类比较 在实际开发过程中,根据...

    SimpleJava.pdf

    - **Comparable接口**:定义了对象自身可以参与自然排序的方法。 - **Comparator接口**:提供了外部比较器,允许按任意标准对对象进行排序。 - **使用场景**:根据实际需求选择合适的排序策略。 #### 13. Java中的...

    java学习文档

    - **排序方式**:默认情况下,`TreeSet` 会按元素的自然顺序排序(如果元素实现了 `Comparable` 接口)或者按照构造函数提供的 `Comparator` 进行排序。 - **元素顺序**:总是保持元素的排序顺序,这对于需要维护...

    List中保存对象,按对象中某一属性排序【含程序源码】

    要按对象的特定属性(如`score`)排序,首先需要确保这个属性是可比较的,即它是一个基本数据类型(如整数或字符串)或者实现了Comparable接口(对于Java)。对于Python,可以使用`lambda`表达式或自定义排序函数。...

Global site tag (gtag.js) - Google Analytics