精华内容
下载资源
问答
  • 2021-12-14 09:55:29

    在C#开发中,如果一个List集合需要进行重新排序,直接Orderby即可,但是在Java中,思路一样,但是写法不一样,特记录,方便各位码友学习使用。

    自己使用版本

    List<UserInfo> userInfoList = new ArrayList<UserInfo>();
    
    //降序
     userInfoList.sort(Comparator.comparing(UserInfo::getCreateTime).reversed());
    
    //升序
    userInfoList.sort(Comparator.comparing(UserInfo::getCreateTime));

    看其他码友使用版本

    List<UserInfo> userInfoList = new ArrayList<UserInfo>();
    
    //仅仅能用于升序
    Collections.sort(userInfoList);
    
    
    //未实验版本
    Collections.sort(userInfoList,new SystemHWUtil. ListComparator(true,"age"));

    如果有不对的地方,或是有更好的方式,欢迎留言讨论。

    更多相关内容
  • NULL 博文链接:https://xuedong.iteye.com/blog/1147254
  • 主要介绍了java List 排序之冒泡排序实例代码的相关资料,需要的朋友可以参考下
  • java list(java list排序sort升序、降序)

    千次阅读 2021-03-08 04:34:58
    javalistList是Java中比较常用的调集类,关于List接口有许多完成类,本文就来简略介绍下其间几个重点的完成ArrayList、LinkedList和Vector之间的联系和差异。List是一个接口,它承继于Collection的接口。它代表着...

    javalist

    List是Java中比较常用的调集类,关于List接口有许多完成类,本文就来简略介绍下其间几个重点的完成ArrayList、LinkedList和Vector之间的联系和差异。

    List是一个接口,它承继于Collection的接口。它代表着有序的队列。当我们讨论List的时分,一般都和Set作比较。

    List中元素能够重复,并且是有序的(这儿的有序指的是依照放入的次序进行存储。如依照次序把1,2,3存入List,那么,从List中遍历出来的次序也是1,2,3)。

    Set中的元素不能够重复,并且是无序的(从set中遍历出来的数据和放入次序没有联系)。

    下面是Java中的调集类的联系图。从中能够大致了解调集类之间的联系

    ArrayList、LinkedList和Vector之间的差异

    从上图能够看出,ArrayList、LinkedList和Vector都完成了List接口,是List的三种完成,所以在用法上十分相似。他们之间的首要差异体现在不同操作的功能上。后面会详细分析。

    ArrayList

    ArrayList底层是用数组完成的,能够以为ArrayList是一个可改动巨细的数组。跟着越来越多的元素被添加到ArrayList中,其规划是动态添加的。

    LinkedList

    LinkedList底层是经过双向链表完成的。所以,LinkedList和ArrayList之前的差异首要就是数组和链表的差异。

    数组中查询和赋值比较快,由于能够直接经过数组下标访问指定方位。

    链表中删除和添加比较快,由于能够直接经过修正链表的指针(Java中并无指针,这儿能够简略理解为指针。其实是经过Node节点中的变量指定)进行元素的增删。

    所以,LinkedList和ArrayList比较,增删的速度较快。可是查询和修正值的速度较慢。同时,LinkedList还完成了Queue接口,所以他还供给了offer(),peek(),poll()等办法。cb188e1fe5c209ced0554eba859eb37d.png

    Vector

    Vector和ArrayList相同,都是经过数组完成的,可是Vector是线程安全的。和ArrayList比较,其间的许多办法都经过同步(synchronized)处理来保证线程安全。

    假如你的程序不涉及到线程安全问题,那么运用ArrayList是更好的挑选(由于Vector运用synchronized,必然会影响功率)。

    二者之间还有一个差异,就是扩容策略不相同。在List被第一次创立的时分,会有一个初始巨细,跟着不断向List中添加元素,当List以为容量不行的时分就会进行扩容。Vector缺省情况下主动增加原来一倍的数组长度,ArrayList增加原来的50%。

    ArrayList和LinkedList的功能比照

    运用以下代码对ArrayList和LinkedList中的几种首要操作所用时刻进行比照:

    ArrayListarrayList=newArrayList();

    LinkedListlinkedList=newLinkedList();

    //ArrayListadd

    longstartTime=System.nanoTime();

    for(inti=0;i<100000;i++){

    arrayList.add(i);

    }

    longendTime=System.nanoTime();

    longduration=endTime-startTime;

    System.out.println(“ArrayListadd:”+duration);

    //LinkedListadd

    startTime=System.nanoTime();

    for(inti=0;i<100000;i++){

    linkedList.add(i);

    }

    endTime=System.nanoTime();

    duration=endTime-startTime;

    System.out.println(“LinkedListadd:”+duration);

    //ArrayListget

    startTime=System.nanoTime();

    for(inti=0;i<10000;i++){

    arrayList.get(i);

    }

    endTime=System.nanoTime();

    duration=endTime-startTime;

    System.out.println(“ArrayListget:”+duration);

    //LinkedListget

    startTime=System.nanoTime();

    for(inti=0;i<10000;i++){

    linkedList.get(i);

    }

    endTime=System.nanoTime();

    duration=endTime-startTime;

    System.out.println(“LinkedListget:”+duration);

    //ArrayListremove

    startTime=System.nanoTime();

    for(inti=9999;i>=0;i–){

    arrayList.remove(i);

    }

    endTime=System.nanoTime();

    duration=endTime-startTime;

    System.out.println(“ArrayListremove:”+duration);

    //LinkedListremove

    startTime=System.nanoTime();

    for(inti=9999;i>=0;i–){

    linkedList.remove(i);

    }

    endTime=System.nanoTime();

    duration=endTime-startTime;

    System.out.println(“LinkedListremove:”+duration);

    成果:

    ArrayListadd:13265642

    LinkedListadd:9550057

    ArrayListget:1543352

    LinkedListget:85085551

    ArrayListremove:199961301

    LinkedListremove:85768810

    他们的表现的差异是显而易见的。在添加和删除操作上LinkedList更快,但在查询速度较慢。

    如何挑选

    假如涉及到多线程,那么就挑选Vector(当然,你也能够运用ArrayList并自己完成同步)。

    假如不涉及到多线程就从LinkedList、ArrayList中选。LinkedList更适合从中间刺进或者删除(链表的特性)。ArrayList更适合检索和在末尾刺进或删除(数组的特性)。05372d26033df2c68af96ff9e0708633.png

    javalist排序sort升序、降序

    首要实体类需求完成Comparable接口

    完成compareTo()办法

    下面是降序如果需求升序则把位置交换一下就好了

    然后调用Collections.sort(list);

    publicstaticvoidmain(String[]args){

    Listlist=newArrayList();

    list.add(newStudent(“张三”,”WN001″,88));

    list.add(newStudent(“李四”,”WN002″,75));

    list.add(newStudent(“王五”,”WN003″,99));

    list.add(newStudent(“赵六”,”WN004″,58));

    list.add(newStudent(“田七”,”WN005″,67));

    list.add(newStudent(“小八”,”WN006″,58));

    list.add(newStudent(“唐七”,”WN007″,35));

    list.add(newStudent(“商十”,”WN008″,78));

    Collections.sort(list);

    for(inti=0;i

    System.out.println(list.get(i).toString());

    }

    }

    publicclassStudentimplementsComparable{

    privateStringname;

    privateStringid;

    privateintscore;

    //…………省略结构函数和GETSET办法

    @Override

    publicintcompareTo(Studento){

    returno.getScore()-this.score;

    }

    展开全文
  • Java List排序的几种方式整理

    千次阅读 2021-04-21 09:48:49
    在有的时候我们会需要对List进行排序,在Java中如何实现呢?本文记录一下Java中对List的几种排序方式,希望本文对你有所帮助。

    目录

    一、前言

    二、正文

    1、方案一

    2、方案二

    3、方案三

    4、方案四

    三、总结

    四、结尾


    一、前言

    在有的时候我们会需要对List进行排序,在Java中如何实现呢?本文记录一下Java中对List的几种排序方式,希望本文对你有所帮助。

    二、正文

    1、方案一

    1.1、简单的排序方法,如以下代码

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    public class sort {
      public static void main(String[] args) {
          List<Integer> list = new ArrayList<Integer>();
          list.add(new Integer(3));
          list.add(new Integer(14));
          list.add(new Integer(6));
          list.add(new Integer(10));
           // 简单的int类似数据,可以使用Collections的sort方法即可完成排序
          Collections.sort(list);
          System.out.println(list.toString());
      }
    }

    输出结果为:

    [3,6,10,14]

    这种简单的排序会直接按自然数据输出。

    2、方案二

    2.1、参数相对复杂的排序方式,参数为对象的情况

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    public class sort {
      public static void main(String[] args) {
          List<User> list = new ArrayList<User>();
          list.add(new User("张三", 5));
          list.add(new User("李四", 30));
          list.add(new User("王五", 19));
          list.add(new User("王麻子", 17));
           // 按年龄排序
          Collections.sort(list); 
          System.out.println(list.toString());
      }
    }
    
    
    class User implements Comparable<User>{
    
      private String name; //姓名
      private int age; // 年龄
    
      public User(String name, int age) {
        this.name = name;
        this.age = age;
      }
      // getter && setter
      public String getName() {
        return name;
      }
      public void setName(String name) {
        this.name = name;
      }
      public int getAge() {
        return age;
      }
      public void setAge(int age) {
      this.age = age;
      }
      @Override
      public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
      }
    
      @Override
      public int compareTo(User user) {           
          // 重写Comparable接口的compareTo方法,根据年龄升序排列,降序修改相减顺序即可
        return this.age - user.getAge();
      }
    }

    程序运行结果:按年龄升序排序

    [User [name=张三, age=5], User [name=王麻子, age=17], User [name=王五, age=19], User [name=李四, age=30]]

    3、方案三

    3.1、使用匿名内部类实现排序

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    public class sort {
      public static void main(String[] args) {
          List<User> list = new ArrayList<User>();
          list.add(new User("张三", 5));
          list.add(new User("李四", 30));
          list.add(new User("王五", 19));
          list.add(new User("王麻子", 17));
          Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User u1, User u2) {
              int diff = u1.getAge() - u2.getAge();
              if (diff > 0) {
                return 1;
              }else if (diff < 0) {
                return -1;
              }
              return 0; //相等为0
            }
          }); // 按年龄排序
          System.out.println(list.toString());
      }
    }

    运行结果为:

    [User [name=张三, age=5], User [name=王麻子, age=17], User [name=王五, age=19], User [name=李四, age=30]]

    4、方案四

    4.1、也是最简介的方案,博主推荐使用,一行代码即可搞定

    import java.util.Collections;
    import java.util.List;
    public class sort {
        public static void main(String[] args) {
          List<User> list = new ArrayList<User>();
          list.add(new User("张三", 5));
          list.add(new User("李四", 30));
          list.add(new User("王五", 19));
          list.add(new User("王麻子", 17));
           // 这一行代码即可完成排序
          list.sort(Comparator.comparing(User::getAge));
          System.out.println(list.toString());
      }
    }
    

    输出结果为:

    [User [name=张三, age=5], User [name=王麻子, age=17], User [name=王五, age=19], User [name=李四, age=30]]

    三、总结

    以上就是list排序经常用的几种方法,前两种方法都是通过实体实现Comparable接口并重写compareTo方法,第一种方式之所以没实现接口并实现compareTo方法,通过查看Interger类源码可以看到,java已经帮我们实现好了,所以不用再次写

    第三种方法通过匿名内部类实现Comparator接口实现compare方法,通过自定义比较器来实现排序。

    四、结尾

    如果觉得本文对你有帮助,不妨点赞收藏起来把,说不定下次要用就找不到了呢。

    展开全文
  • 主要介绍了JAVA像SQL一样对List对象集合进行排序的实现方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • Java List排序详解

    千次阅读 2020-04-25 21:25:11
    一)List基本类型排序 方式一:使用Collections类中sort默认升序排序方式 方式二:使用Collections类中sort默认排序方式,并继承Comparator接口自定义升序or降序 package com.oysept.list; import java.util....

    一)List基本类型排序

    方式一:使用Collections类中sort默认升序排序方式

    方式二:使用Collections类中sort默认排序方式,并继承Comparator接口自定义升序or降序

    package com.oysept.list;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class ListSort {
    
        public static void main(String[] args) {
            List<String> list1 = new ArrayList<String>();
            list1.add("dddaaa");
            list1.add("bbb");
            list1.add("ccc");
    		
            // 第一种排序方式, 默认升序
            Collections.sort(list1);
            System.out.println("第一种排序方式, 默认升序结果: " + list1);
    
            // 第二种排序方式, 自定义升序or降序
            Collections.sort(list1, new Comparator<String>() {
                public int compare(String o1, String o2) {
                    //return o1.compareTo(o2); // 升序
                    return o2.compareTo(o1); // 降序
                }
            });
            System.out.println("\n第二种排序方式, 自定义升序or降序结果: " + list1);
    		
            // 第三种排序方式, 升序or降序
            Collections.sort(list1, (String o1, String o2) -> o1.compareTo(o2)); // 升序
            System.out.println("\n第三种排序方式, 升序结果: " + list1);
            Collections.sort(list1, (String o1, String o2) -> o2.compareTo(o1)); // 降序
            System.out.println("\n第三种排序方式, 降序结果: " + list1);
        }
    }

    控制台效果图打印:

     

    二)List对象类型排序

    先创建一个Book对象,并继承Comparable接口,并重写compareTo方法

    package com.oysept.list;
    
    public class Book implements Comparable<Book> {
    
        private String title;
        private Integer number;
    	
        public Book() {}
        public Book(String title, Integer number) {
            this.title = title;
            this.number = number;
        }
    	
        public String getTitle() {return title;}
        public void setTitle(String title) {this.title = title;}
    	
        public Integer getNumber() {return number;}
        public void setNumber(Integer number) {this.number = number;}
    	
        @Override
        public String toString() {
            return "[title=" + title + ", number=" + number + "]";
        }
    	
        @Override
        public int compareTo(Book o) {
            return this.number - o.number; // 只根据number升序排序
        }
    }

    测试源码:

    package com.oysept.list;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class ListSort {
    
        public static void main(String[] args) {
            List<Book> bookList = new ArrayList<Book>();
            bookList.add(new Book("AAA", 555));
            bookList.add(new Book("DDD", 333));
            bookList.add(new Book("CCC", 666));
            bookList.add(new Book("BBB", 222));
    		
            // 第一种排序方式, 默认升序
            Collections.sort(bookList);
            System.out.println("第一种排序方式, 默认升序结果: \n" + bookList);
    		
            // 第二种排序方式, 自定义升序or降序结果
            Collections.sort(bookList, new Comparator<Book>() {
                public int compare(Book o1, Book o2) {
                    //return o1.compareTo(o2); // 升序, 根据Book类中的number升序
                    return o2.compareTo(o1); // 降序, 根据Book类中的number升序
                }
            });
            System.out.println("\n第二种排序方式, 自定义升序or降序结果: \n" + bookList);
    		
            // 第三种排序方式, Lamda表达式, 升序or降序
            Collections.sort(bookList, Comparator.comparing(Book::getNumber).thenComparing(Book::getTitle).reversed());
            System.out.println("\n第三种排序方式, Lamda表达式, 升序or降序: \n" + bookList);
        }
    }

    控制台效果图打印:

     

    识别二维码关注个人微信公众号

    本章完结,待续,欢迎转载!
     
    本文说明:该文章属于原创,如需转载,请标明文章转载来源!

    展开全文
  • 主要介绍了Java List集合排序实现方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JAVA SortList 通用排序类 从网上搜到一个javaList 排序的工具,自己改了下 支持 整数 和 浮点数 比较后排序,浮点数小数部分的有点问题,期待大牛帮忙优化。
  • Java List 排序方法sort的使用详解

    万次阅读 2018-09-07 09:50:18
    对数组的排序: 1 2 3 4 5 6 7 8 //对数组排序 public void arraySort(){  int[] arr = {1,4,6,333,8,2};...//使用java.util.Arrays对象的sort方法 ...
  • NULL 博文链接:https://singhoo.iteye.com/blog/1717722
  • 主要介绍了javaList按照date排序的实现的相关资料,需要的朋友可以参考下
  • JavaList排序的3种方法!

    千次阅读 2021-12-21 00:52:21
    作者 | 王磊来源 | Java中文社群(ID:javacn666)转载请联系授权(微信ID:GG_Stone)在某些特殊的场景下,我们需要在 Java 程序中对 List 集合进行排序操...
  • Java List排序,分组等操作

    千次阅读 2021-03-05 21:16:06
    假定有一列实体类对像List list = UserServer.getList();去重,去除重复对象(每个属性的值都一样的),需要注意的是要先重写对象User的equals和hashCode方法List ...排序,按id升续排列,如果要降续则改成:(a, b) ...
  • 天才之作:通过泛型,对List中对象多属性排序,支持设置各属性排序方式(动态属性),看了之后绝对让你震撼!
  • JavaList集合排序

    千次阅读 2021-06-08 10:38:30
    1.单属性变量集合排序,如LIst<Integer> List<Integer> intList = new ArrayList<>(); intList.add(54); intList.add(7674); intList.add(636); intList.add(4325); intList.add(21); ...
  • 主要介绍了java list集合排序按某一属性排序操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • JavaList排序的3种方法

    千次阅读 2021-12-21 13:28:26
    在某些特殊的场景下,我们需要在 Java 程序中对 List 集合进行排序操作。比如从第三方接口中获取所有用户的列表,但列表默认是以用户编号从小到大进行排序的,而我们的系统需要按照用户的年龄从大到小进行排序,这个...
  • 主要介绍了Java8 用Lambda表达式给List集合排序的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Javalist排序

    千次阅读 2021-09-26 14:53:51
    1.Collections排序 1)基本类型的元素 List demo_list = new ArrayList<>(); Collections.sort(demo_list ); 2)实体类元素的排序:通过某个成员变量的值做比较 方式一:Collections.sort(demo_list , (Bean b1, ...
  • 主要介绍了Java Collections.sort()实现List排序的默认方法和自定义方法,需要的朋友可以参考下
  • List<String> location=new ArrayList(); 一行代码轻松搞定混合排序问题 Collections.sort(location, new SortUtils(true));
  • java list Comparator排序

    千次阅读 2019-01-06 15:26:04
    //此时list已经排序,直接可以使用 Collections.sort(list,(PubMsgClassAuditReportItem item1,PubMsgClassAuditReportItem item2) -> item1.getTotalScore() - item2.getTotalScore()); //此方法需要level>6 ...
  • java list集合元素根据某些字段排序

    千次阅读 2021-03-17 03:52:46
    一、jdk1.6的环境下新建ComparatorSort类,并实现Comparator接口,重写compare方法降序排序:o1的元素>o2的元素,并返回-1;o1的元素小于o2的元素,并返回1升序排序...import java.util.Comparator;import app.com...
  • 他现在有这样的一个需求:想要对苹果库存里面的所有苹果,按照苹果的重量weight排序。这里咱们简单的使用List集合作为我们的仓库,快来看看如何一步一步的实现的更加简洁吧。 先来一个Apple类 public class Apple { ...
  • 下面小编就为大家分享一篇java根据List内对象的属性排序方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • JavaList排序

    万次阅读 多人点赞 2019-06-08 21:32:44
    开发工具与关键技术:MyEclipse 10、Java语法 作者:邓婵 撰写时间:2019年6 月 5日 集合和数组的不同点: 数组:只能存储固定大小同一类型的元素。数组元素可以是基本数据类型的值,也可以是对象。 集合:可用于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 331,340
精华内容 132,536
关键字:

javalist排序

java 订阅