[转]java List 排序 Collections.sort

java List 排序 Collections.sort

用Collections.sort方法对list排序有两种方法
第一种是list中的对象实现Comparable接口,如下:

代码:
Java代码
  1. /**
  2. * 根据order对User排序
  3. */  
  4. public class User implements Comparable<User>{   
  5.     private String name;   
  6.     private Integer order;   
  7.     public String getName() {   
  8.         return name;   
  9.      }   
  10.     public void setName(String name) {   
  11.         this.name = name;   
  12.      }   
  13.     public Integer getOrder() {   
  14.         return order;   
  15.      }   
  16.     public void setOrder(Integer order) {   
  17.         this.order = order;   
  18.      }   
  19.     public int compareTo(User arg0) {   
  20.         return this.getOrder().compareTo(arg0.getOrder());   
  21.      }   
  22. }   
  23.   
  24.   
  25.   
  26. public class Test{   
  27.     public static void main(String[] args) {   
  28.           User user1 = new User();   
  29.           user1.setName("a"); user1.setOrder(1);   
  30.           User user2 = new User(); user2.setName("b");   
  31.           user2.setOrder(2);   
  32.           List<User> list = new ArrayList<User>();   
  33.         //此处add user2再add user1   
  34.          list.add(user2); list.add(user1);   
  35.          Collections.sort(list);   
  36.         for(User u : list){   
  37.              System.out.println(u.getName());   
  38.          }   
  39.      }   
  40. }  
/**
* 根据order对User排序
*/
public class User implements Comparable<User>{
    private String name;
    private Integer order;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getOrder() {
        return order;
    }
    public void setOrder(Integer order) {
        this.order = order;
    }
    public int compareTo(User arg0) {
        return this.getOrder().compareTo(arg0.getOrder());
    }
}

public class Test{
    public static void main(String[] args) {
         User user1 = new User();
         user1.setName("a"); user1.setOrder(1); 
         User user2 = new User(); user2.setName("b");
         user2.setOrder(2); 
         List<User> list = new ArrayList<User>(); 
        //此处add user2再add user1 
        list.add(user2); list.add(user1); 
        Collections.sort(list); 
        for(User u : list){ 
            System.out.println(u.getName()); 
        } 
    } 
}


输出结果如下
a
b
第二种方法是根据Collections.sort重载方法来实现,例如:

代码:
Java代码
  1. /**
  2. * 根据order对User排序 */   
  3. public class User {   
  4. //此处无需实现Comparable接口   
  5.     private String name;   
  6.     private Integer order;   
  7.     public String getName() {   
  8.          return name;   
  9.      }   
  10.     public void setName(String name) {   
  11.         this.name = name;   
  12.      }   
  13.     public Integer getOrder() {   
  14.         return order;   
  15.      }   
  16.     public void setOrder(Integer order) {   
  17.        this.order = order;   
  18.      }   
  19. }   
  20.   
  21.   
  22.   
  23.   
  24. public class Test{   
  25.     public static void main(String[] args) {   
  26.         User user1 = new User();   
  27.         user1.setName("a");   
  28.         user1.setOrder(1);   
  29.         User user2 = new User();   
  30.         user2.setName("b");   
  31.         user2.setOrder(2);   
  32.         List<User> list = new ArrayList<User>();   
  33.         list.add(user2);   
  34.         list.add(user1);   
  35.         Collections.sort(list,new Comparator<User>(){   
  36.            public int compare(User arg0, User arg1) {   
  37.                return arg0.getOrder().compareTo(arg1.getOrder());   
  38.             }   
  39.         });   
  40.        for(User u : list){   
  41.            System.out.println(u.getName());   
  42.         }   
  43.      }   
  44. }  
最简单的就是上面红色的字。。。。。。。。。。。

默认为升序,将。return arg0.getOrder().compareTo(arg1.getOrder());    改为:

return arg1.getOrder().compareTo(arg0.getOrder());   

就成倒序的了。。

基于数据驱动的 Koopman 算子的递归神经网络模型线性化,用于纳米定位系统的预测控制研究(Matlab代码实现)内容概要:本文围绕“基于数据驱动的Koopman算子的递归神经网络模型线性化”展开,旨在研究纳米定位系统的预测控制问题,并提供完整的Matlab代码实现。文章结合数据驱动方法与Koopman算子理论,利用递归神经网络(RNN)对非线性系统进行建模与线性化处理,从而提升纳米级定位系统的精度与动态响应性能。该方法通过提取系统隐含动态特征,构建近似线性模型,便于后续模型预测控制(MPC)的设计与优化,适用于高精度自动化控制场景。文中还展示了相关实验验证与仿真结果,证明了该方法的有效性和先进性。; 适合人群:具备一定控制理论基础和Matlab编程能力,从事精密控制、智能制造、自动化或相关领域研究的研究生、科研人员及工程技术人员。; 使用场景及目标:①应用于纳米级精密定位系统(如原子力显微镜、半导体制造设备)中的高性能控制设计;②为非线性系统建模与线性化提供一种结合深度学习与现代控制理论的新思路;③帮助读者掌握Koopman算子、RNN建模与模型预测控制的综合应用。; 阅读建议:建议读者结合提供的Matlab代码逐段理解算法实现流程,重点关注数据预处理、RNN结构设计、Koopman观测矩阵构建及MPC控制器集成等关键环节,并可通过更换实际系统数据进行迁移验证,深化对方法泛化能力的理解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值