java list sort（Java的List怎么排序啊）

本文目录

• Java的List怎么排序啊
• java 怎么将List里面数据排序
• java arraylist 的sort怎么用
• JAVA中list排序问题
• java list 排序
• java怎么对list进行排序
• Java里面List排序
• Java List提供的默认排序方法sort()用的是什么排序策略

Java的List怎么排序啊

用Collections.sort就可以排序，
里面的排序是默认的按自然顺序排列
也就是1,2,3,4这种
参数要求实现了Comparable的数据才能排序，
如果你自己写的类，你就要实现Comparable接口，然后在接口里面自动生成的方法里面
指定排序方法，一般的String Inteneger类都是实现了这个接口的 不用自己操作的。
你可以取看源代码

java 怎么将List里面数据排序

学生实体类，包含姓名和年龄属性，

比较时先按姓名升序排序，如果姓名相同则按年龄升序排序。

第一种：实体类自己实现比较

（实现comparable接口：public interface Comparable《T》 ，里面就一个方法声明：public int compareTo(T o); ）

然后利用List类的sort(Comparator《? super E》 c)方法或java.util.Collections工具类的sort(List《T》 list) （其实里面就一句：list.sort(null); ）进行排序：

结果：

第二种：借助比较器进行排序。

示例代码：

比较器java.util.Comparator类是一个接口（public interface Comparator《T》 )，包含int compare(T o1, T o2);等方法：

我们的比较器要实现该接口并实现compare方法：

比较的时候可以利用List的sort(Comparator《? super E》 c)方法（或者java.util.Collections工具类的sort(List《T》 list, Comparator《? super T》 c)方法）进行排序。

结果跟第一种方法一样：

java arraylist 的sort怎么用

在排序中,最重要的是自己实现自己的比较的行数,即是implements Comparator
实现方法 public int compare(Object o1, Object o2) 最为重要..
举个例子:
package book.arrayset;
import java.util.Comparator;
/**
* 整数比较器，将整数按降序排列
*/
class MyIntComparator implements Comparator{
/**
* o1比o2大，返回-1；o1比o2小，返回1。
*/
public int compare(Object o1, Object o2) {
int i1 = ((Integer)o1).intValue();
int i2 = ((Integer)o2).intValue();
if (i1 《 i2){
return 1;
}
if (i1 》 i2){
return -1;
}
return 0;
}
}
//上面的为比较的函数实现,下面真正的添加数据,
//通过调用上面的比较函数实现自定义排序的功能
package book.arrayset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 对List中的元素排序
*/
public class SortList {
public static void output(List list){
if (list == null){
return;
}
for (int i=0; i《list.size(); i++){
System.out.print(list.get(i).toString() + “ “);
}
System.out.println();
}
public static void main(String args) {
List list = new ArrayList();
list.add(new Integer(5));
list.add(new Integer(8));
list.add(new Integer(1));
list.add(new Integer(3));
list.add(new Integer(2));
list.add(new Double(3.1));
System.out.println(“list开始状态“);
SortList.output(list);
//Collections.sort方法将用默认比较器排列list的元素
Collections.sort(list);
System.out.println(“list被默认比较器排序后的状态“);
SortList.output(list);
//下面将list的元素按降序排列
Collections.sort(list, new MyIntComparator());
System.out.println(“list被自定义比较器排序后的状态“);
SortList.output(list);
//因此，对于任意自定义类的对象，当保存在集合类容器中后，如果需要对它们进行排序，
//需要自己提供适应于自定义类的比较器，自定义比较器必须实现Comparator接口。
//然后采用Collections.sort(list, comparator);方法对容器进行排序。
}
}

JAVA中list排序问题

分不多，不过正好我研究了这里，也算给自己做个总结：
我为了方便解释、写了一个测试类
/** test for reflex */
public class Model {
private String name;
private String content;

public Model(){
this.name = “my name“;
this.content = “a long text“;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public String getContent() {
return content;
}
//测试
public void test() throws Exception{
Model model = new Model();
Method m1 = model.getClass().getMethod(“getName“, null);
System.out.println(m1.invoke(model, null));
}
public static void main(String args){
try {
new Model().test(“getName“);
} catch (Exception e) {
e.printStackTrace();
}
}
}
首先调用test，传递一个method过去；
通过反射机制(这里用到了getMethod、invoke，我比较喜欢getField)、获取到m1对象的getName方法，getMethod第一个参数为方法名、第二个是给这个method的参数的类型，
If parameterTypes is null, it is treated as if it were an empty array，如果为null，表示没有参数；(即 getName()方法)；
然后在通过 invoke 注入参数；第一个是相应对象的引用、第二个是参数值（刚刚的是类型，现在才是值）；
If the underlying method is static, then the specified obj argument is ignored. It may be null，也就是说static的方法第一个参数是null；
我们要调用的是getName(),那么就是 m1.invoke(model,null)了；
执行结果为：my name ；相当于调用了getName()方法.
绕了一圈也就是 model.getName() == model.getClass().getMethod(“getName“,null).invoke(model,null);
对于有参数的，调整为
public void test(String method) throws Exception{
Model model = new Model();
Method m1 = model.getClass().getMethod(method, String.class);
m1.invoke(model, “can you“);
System.out.println(model.getName());
}
结果:can you
接下来上边的题目就简单了，
public void Sort(List《E》 list, final String method, final String sort){
这里给出了method，接下来是一个内部类的处理；自定义一个comparator，
Method m1 = ((E) a).getClass().getMethod(method, null);
这里就是获取method方法，他没有参数。
m1.invoke(((E)a), null).toString()
这里是得到对象a调用方法method之后的返回值。
ret = m1.invoke(((E)a), null).toString().compareTo(m2.invoke(((E)b), null).toString());
而这里就是比较两个对象method方法的返回值
将ret交给sort进行排序；
就像3楼说的、真正排序的是sort方法，下面的只是对一个类中某个方法的返回值进行比较

java list 排序

import java.util.ArrayList;
import java.util.List;
public class App {
public static void main(String args) {

List《Integer》 list = new ArrayList《》();
list.add(85);
list.add(35);
list.add(20);
list.add(60);
list.add(54);

list.sort((x, y) -》 Integer.compare(x, y));

list.forEach(System.out::println);
}
}

java怎么对list进行排序

1,使用Comparator 接口
Student类 结构如下:(省略getter,setter方法)
public class Student {
/***
* 姓名
*/
private String name;
private int age;
private String address;
/***
* 考试得分
*/
private int score;
//省略getter,setter方法
@Override
public String toString() {
return “Student [name=“ + name + “, age=“ + age + “, score=“ + score
+ “]“;
}
}
测试方法:
@Test
public void test_ListComparator(){
List《Student》students=new ArrayList《Student》();
Student stu=null;
stu=new Student();
stu.setName(“whuang“);
stu.setAge(12);
stu.setScore(80);
students.add(stu);
stu=new Student();
stu.setName(“rong“);
stu.setAge(11);
stu.setScore(90);
students.add(stu);
stu=new Student();
stu.setName(“zhu“);
stu.setAge(15);
stu.setScore(100);
students.add(stu);
Collections.sort(students,new SystemHWUtil. ListComparator(true,“age“));
System.out.println(students);
}
运行结果:
[Student [name=rong, age=11, score=90], Student [name=whuang, age=12, score=80], Student [name=zhu, age=15, score=100]]
核心类:
public static class ListComparator implements Comparator{
/***
* 是否转化为Int之后再比较
*/
private boolean isConvertInteger;
/***
* 对哪个列进行排序
*/
private String comparedProperty;
public ListComparator(boolean isConvertInteger,String comparedProperty) {
super();
this.isConvertInteger = isConvertInteger;
this.comparedProperty=comparedProperty;
}
public int compare(Object o1, Object o2) {
if(null!=o1&&null!=o2)
{
try {
Object obj1=ReflectHWUtils.getObjectValue(o1, comparedProperty);
Object obj2=ReflectHWUtils.getObjectValue(o2, comparedProperty);
if(isConvertInteger){
int num1;
int num2;
if(obj1 instanceof Integer){
num1=(Integer)obj1;
num2=(Integer)obj2;
}else{
num1=Integer.parseInt(obj1.toString());
num2=Integer.parseInt(obj2.toString());
}
if(num1》num2){
return 1;
}else if(num1《num2){
return -1;
}else{
return 0;
}
}else{
return obj1.toString().compareTo(obj2.toString());
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return 0/*等于*/;
}
}
2,可以指定是升序还是降序
实例:
@Test
public void test_ListComparator(){
List《Student》students=new ArrayList《Student》();
Student stu=null;
stu=new Student();
stu.setName(“whuang“);
stu.setAge(12);
stu.setScore(80);
students.add(stu);
stu=new Student();
stu.setName(“rong“);
stu.setAge(11);
stu.setScore(90);
students.add(stu);
stu=new Student();
stu.setName(“zhu“);
stu.setAge(15);
stu.setScore(100);
students.add(stu);
SortList《Student》 sortList = new SortList《Student》();
sortList.Sort(students, “getAge“, “asc“);
System.out.println(students);
}
注意:sortList.Sort 的第二个参数是方法名,不是成员变量名.
核心代码
package com.common.util;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortList《E》 {
public void Sort(List《E》 list, final String method, final String sort) {
Collections.sort(list, new Comparator() {
public int compare(Object a, Object b) {
int ret = 0;
try {
Method m1 = ((E) a).getClass().getMethod(method, null);
Method m2 = ((E) b).getClass().getMethod(method, null);
if (sort != null && “desc“.equals(sort))// 倒序
ret = m2.invoke(((E) b), null).toString()
.compareTo(m1.invoke(((E) a), null).toString());
else
// 正序
ret = m1.invoke(((E) a), null).toString()
.compareTo(m2.invoke(((E) b), null).toString());
} catch (NoSuchMethodException ne) {
System.out.println(ne);
} catch (IllegalAccessException ie) {
System.out.println(ie);
} catch (InvocationTargetException it) {
System.out.println(it);
}
return ret;
}
});
}
}

Java里面List排序

摘自：http://www.blogjava.net/zygcs/archive/2008/01/17/176032.html
//一个POJO例子
class User {
String name;
String age;

public User(String name,String age){
this.name=name;
this.age=age;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//具体的比较类，实现Comparator接口
import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class ComparatorUser implements Comparator{
public int compare(Object arg0, Object arg1) {
User user0=(User)arg0;
User user1=(User)arg1;
//首先比较年龄，如果年龄相同，则比较名字
int flag=user0.getAge().compareTo(user1.getAge());
if(flag==0){
return user0.getName().compareTo(user1.getName());
}else{
return flag;
}
}

}
//测试类
public class SortTest {

public static void main(String args){
List userlist=new ArrayList();
userlist.add(new User(“dd“,“4“));
userlist.add(new User(“aa“,“1“));
userlist.add(new User(“ee“,“5“));
userlist.add(new User(“bb“,“2“));
userlist.add(new User(“ff“,“5“));
userlist.add(new User(“cc“,“3“));
userlist.add(new User(“gg“,“6“));

ComparatorUser comparator=new ComparatorUser();
Collections.sort(userlist, comparator);

for (int i=0;i《userlist.size();i++){
User user_temp=(User)userlist.get(i);
System.out.println(user_temp.getAge()+“,“+user_temp.getName());
}

}
}
//首先年龄排序，如果年龄相同，则按名字排序
结果:
1, aa
2, bb
3, cc
4, dd
5, ee //注意:同样是5岁的人，则比较名字(ee,ff)，然后排序
5, ff
6, gg

Java List提供的默认排序方法sort()用的是什么排序策略

你好，很高兴回答你的问题。
List只是个接口，sort方法具体是怎么排序的是在具体的实现类中的。
不同的实现类排序实现是不一样的。有的同一个实现类在java的不同版本中排序的实现也可能是有差别的。
如果有帮助到你，请点击采纳。