自定义对象排序实现接口（自定义对象排序实现接口是什么）

本篇文章给大家谈谈自定义对象排序实现接口，以及自定义对象排序实现接口是什么对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。 今天给各位分享自定义对象排序实现接口的知识，其中也会对自定义对象排序实现接口是什么进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、集合框架中，要实现对集合里的元素进行自定义排序，要实现哪个接口
• 2、用JAVA排序接口实现
• 3、如何给一个对象排序
• 4、Java中，如果想要排序,实现Comparator接口 //与Comparable 的区别?
• 5、java 如何对对象进行排序

集合框架中，要实现对集合里的元素进行自定义排序，要实现哪个接口

有的集合已经自己实现排序了 第一种方案 直接用集合的工具类Collections.sort排序 第二种 选用本来就有顺序的集合 自己定义一些比较方式添加的时候实现对象的排序 对象必须实现可以比较的方法

用JAVA排序接口实现

日行一善当学习拉。好久没帮人做作业自定义对象排序实现接口了
首先是接口 compareForNumber.java
public interface compareForNumber {
public int compareTwoNumber(Object obj_1,Object obj_2);
public Object sortTowNumber(Object obj[]);
}
下面是实现接口的具体实现类Test_1.java
public class Test_1 implements compareForNumber{
@Override
public int compareTwoNumber(Object obj_1, Object obj_2) {
int value_1;
int value_2;
try {
value_1 = ((Integer) obj_1).intValue();
value_2 = ((Integer) obj_2).intValue();
if(value_1 value_2)
{
return value_1;
}else if(value_1 < value_2)
{
return value_2;
}else if(value_1 == value_2){
return 0;
}
} catch (Exception e) {
System.out.println("你输入不是int类型");
e.printStackTrace();
}
return 0;
}
@Override
public Object sortTowNumber(Object[] obj) {
int maxLength = 0;
String maxValues = "";
int maxLocal = 0;
for(int i =0;i<obj.length;i++)
{
try {
String values = String.valueOf(obj[i]);
if(values.length() maxLength)
{
maxLength = values.length();
maxValues = values;
maxLocal = i +1;
}
if(i == obj.length-1)
{
System.out.println("该字符串数组最长是" + maxValues + "长度是" + maxLength + "是数组的第" + maxLocal + "个");
}
} catch (Exception e) {
System.out.println("转型失败你输入可能不是字符串数组");
e.printStackTrace();
}
}
return "该字符串数组最长是" + maxValues + "长度是" + maxLength + "是数组的第" + maxLocal + "个";
}
public static void main(String[] args) {
System.out.println(new Test_1().compareTwoNumber(3, 2));//传入两个数字比较大小

String a[] = {"ni","nihao","woshizuichangde","nihaoa"};//传入字符串数组返回结果
new Test_1().sortTowNumber(a);
}
}

如何给一个对象排序

当我们排序的对象不止是简单的数据类型的时候

我们可以通过 实现Comparable 和Comparator 接口来完整对 对象的排序

Comparable和Compartor 的区别？

Comparable 是一个自身已经支持自比较的（如String Integer) 的接口

Comparator 可以说是一个 专用的比较器 当对象本身 不支持自排序和自比较函数的时候

我们可以通过实现Compartor 来比较两对象的大小

Comparable 是一个比较通用的接口 用户可以通过他实现 排序功能

而 Comparator 可以看作一种算法 一种设计模式 （可以看作是一个策略模式 就是不改变对象自身 而用一个策略对象改变对象行为）

Comparable 相对比较固定 与具体类绑定

Comparator 比较灵活 可以与任何需要实现功能的类 绑定

Comparable 可以说是 静态绑定

Comparator 可以说是动态绑定

Comparable

此接口强行对实现它的每个类的对象进行整体排序 此排序被称为该类的自然排序 类的 pareTo 方法被称为它的自然比较方法

实现此接口的对象列表（和数组）可以通过 Collections sort（和 Arrays sort）进行自动排序 实现此接口的对象可以用作有序映射表中的键或有序集合中的元素 无需指定比较器

对于类 C 的每一个 e 和 e 来说 当且仅当 (pareTo((Object)e ) == ) 与 e equals((Object)e ) 具有相同的布尔值时 类 C 的自然排序才叫做与 equals 一致 注意 null 不是任何类的实例 即使 e equals(null) 返回 false pareTo(null) 也会抛出 NullPointerException

强烈推荐（虽然不是必需的）使自然排序与 equals 一致 这是因为在使用其自然排序与 equals 不一致的元素（或键）时 没有显式比较器的有序集合（和有序映射表）行为表现 怪异 尤其是 这样的有序集合（或有序映射表）违背了根据 equals 方法定义的集合（或映射表）的常规协定

而 Comparator

比较函数强行对某些对象 collection 进行整体排序 可以将 Comparator 传递给 sort 方法（如 Collections sort） 从而允许在排序顺序上实现精确控制 还可以使用 Comparator 来控制某些数据结构（如 TreeSet 或 TreeMap）的顺序

当且仅当对于一组元素 S 中的每个 e 和 e 而言 (pare((Object)e (Object)e )== ) 与 e equals((Object)e ) 具有相等的布尔值时 Comparator c 强行对 S 进行的排序才叫做与等号一致 的排序

lishixinzhi/Article/program/Java/hx/201311/26524

Java中，如果想要排序,实现Comparator接口 //与Comparable 的区别?

comparator接口与Comparable接口的区别
1. Comparator 和 Comparable 相同的地方
他们都是java的一个接口, 并且是用来对自定义的class比较大小的,
什么是自定义class: 如 public class Person{ String name; int age }.
当我们有这么一个personList,里面包含了person1, person2, persion3....., 我们用Collections.sort( personList ), 是得不到预期的结果的. 这时肯定有人要问, 那为什么可以排序一个字符串list呢:
如 StringList{"hello1" , "hello3" , "hello2"}, Collections.sort( stringList ) 能够得到正确的排序, 那是因为 String 这个对象已经帮我们实现了 Comparable接口 , 所以我们的 Person 如果想排序, 也要实现一个比较器。

2. Comparator 和 Comparable 的区别
Comparable
Comparable 定义在 Person类的内部:
public class Persion implements Comparable {..比较Person的大小..},
因为已经实现了比较器,那么我们的Person现在是一个可以比较大小的对象了,它的比较功能和String完全一样,可以随时随地的拿来比较大小,因为Person现在自身就是有大小之分的。Collections.sort(personList)可以得到正确的结果。
Comparator
Comparator 是定义在Person的外部的, 此时我们的Person类的结构不需要有任何变化,如
public class Person{ String name; int age },
然后我们另外定义一个比较器:
public PersonComparator implements Comparator() {..比较Person的大小..},
在PersonComparator里面实现了怎么比较两个Person的大小. 所以,用这种方法,当我们要对一个 personList进行排序的时候, 我们除了了要传递personList过去, 还需要把PersonComparator传递过去,因为怎么比较Person的大小是在PersonComparator里面实现的, 如:
Collections.sort( personList , new PersonComparator() ).
3. Comparator 和 Comparable 的实例
Comparable:
实现Comparable接口要覆盖compareTo方法, 在compareTo方法里面实现比较：
public class Person implements Comparable {
String name;
int age
public int compareTo(Person another) {
int i = 0;
i = name.compareTo(another.name); // 使用字符串的比较
if(i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果
return age - another.age;
} else {
return i; // 名字不一样, 返回比较名字的结果.
}
}
}
这时我们可以直接用 Collections.sort( personList ) 对其排序了.
Comparator:
实现Comparator需要覆盖 compare 方法：
public class Person{
String name;
int age
}
class PersonComparator implements Comparator {
public int compare(Person one, Person another) {
int i = 0;
i = one.name.compareTo(another.name); // 使用字符串的比较
if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
return one.age - another.age;
} else {
return i; // 名字不一样, 返回比较名字的结果.
}
}
}
Collections.sort( personList , new PersonComparator()) 可以对其排序
4:总结
两种方法各有优劣, 用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。

java 如何对对象进行排序

纠正几点错误：
首先TreeSet就是一个二叉树排序容器，由用户定义对象比较规则，然后接口回调进行排序，也就是说当对象在add到容器后实际上已经按照你定义的排序规则排序完毕了，所以你也没有必要再单独写一个排序方法。
如果你想单独写一个排序算法，传送TreeSet()这样已经排序完毕的容器当然是多此一举的。 你可以用List保存你的对象，这样容器保存的就是原始的对象集合(按add()的先后顺序排序)，这样才能真正发挥排序方法的功能.
其次，你的冒泡排序算法是按照价格从小到大的，而你add对象的时候就是从小到大的，所以一直没有满足if(iArr[j].price iArr[j+1].price) { 这个条件，可以把号改成<号，或者打乱add的顺序，这样就能看出效果。
另外从容器内取元素应该用循环，而不应该写死。你应该知道，所以程序我也没修改~
下面的程序在原作上面稍微修改了一下，自己可以比较一下区别
package cn.com.csuinfo.Mycollec;
import java.util.ArrayList;
import java.util.List;
public class TestMySort {
public void BubbleSort(List<Car list) {
Car c1;
Car c2;
Car c3;
Car c4;
c1 = list.get(0);// 将set中的元素一个个取出来，再存入Car数组中
c2 = list.get(1);
c3 = list.get(2);
c4 = list.get(3);
Car[] iArr = { c1, c2, c3, c4 }; // 数组中存放了Car类型的四个对象
Car tmp = null;
int len = list.size();
for (int i = 0; i < len - 1; i++) {// 对数组中的对象按属性值price的大小进行排序
for (int j = 0; j < len - 1 - i; j++) {
if (iArr[j].price < iArr[j + 1].price) {
tmp = iArr[j];
iArr[j] = iArr[j + 1];
iArr[j + 1] = tmp;
System.out.println("change");// 测试之注意！：程序没执行到此来？？？
}
}
}
for (Car car : iArr) {
System.out.println(car);
}
}
public static void main(String[] args) {
List<Car list = new ArrayList<Car();
Car car1 = new Car("Ford", 164000);
Car car2 = new Car("Honda", 286000);
Car car3 = new Car("Toyota", 410000);
Car car4 = new Car("Benz", 850000);
list.add(car1);
list.add(car2);
list.add(car3);
list.add(car4);
System.out.println("***********************“");
new TestMySort().BubbleSort(list);
}
} 关于自定义对象排序实现接口和自定义对象排序实现接口是什么的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 自定义对象排序实现接口的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于自定义对象排序实现接口是什么、自定义对象排序实现接口的信息别忘了在本站进行查找喔。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。