精华内容
下载资源
问答
  • scala list排序

    千次阅读 2019-10-11 18:34:16
    现在有一个List,需要对其进行排序 val a = List(("a",2),("b",44),("c",20),("a",20)) 1、对int值进行排序 val d = a.sortBy(_._2).reverse println(d.mkString(" - ")) 结果: (b,44) - (a,20) - (c,20) - (a,2)...

    现在有一个List,需要对其进行排序

    val a = List(("a",2),("b",44),("c",20),("a",20))
    

    1、对int值进行排序

    val d = a.sortBy(_._2).reverse
    println(d.mkString(" - "))
    
    结果:
    (b,44) - (a,20) - (c,20) - (a,2)
    

    2、先对int值进行排序,再对string值 进行排序

    val c = a.sortBy(r=>(r._2,r._1))(Ordering.Tuple2(Ordering.Int.reverse,Ordering.String.reverse))
    println(c.mkString(" - "))
    
    结果:
    (b,44) - (c,20) - (a,20) - (a,2)
    
    展开全文
  • Python3 list 排序函数详解

    万次阅读 多人点赞 2018-05-28 18:55:03
    Python3 list 排序函数详解 一、列表的sort排序函数 函数原型: list.sort(key=None,reverse=False) 函数功能: 对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序...

    Python3 list 排序函数详解

    一、           列表的sort排序函数

    函数原型:

             list.sort(key=None,reverse=False)

    函数功能:

    对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序排序。

    函数参数:

    (1)     key: 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中。指定可迭代对象中的一个元素来进行排序指定排序时使用的单个元素或多个元素、lambda表达式;

    (2)     reverse:指字排序规则是升序还是降序,默认为升序排序;

    二、           排序示例

    1.      字符串排序

    def list_sort_string():
        list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]
        list.sort() #按字典顺序升序排列
        print("升序:",list)
    
        list.sort(reverse=True) #按降序排列
        print("降序:",list)

     

    排序结果࿱

    展开全文
  • java jdk8 list排序(项目实测)

    万次阅读 2021-02-03 11:56:01
    首先声明,排序的方法是通用的,但是这个方法是很有... * 字符串类型list排序 * author byH * data 2021/2/1 * @param list 需要排序的list */ public static void listStringSorted(List<String> list){

    首先声明,排序的方法是通用的,但是这个方法是很有针对性的,如果想要用,必须要自己改装;
    首先是最简单的Integer类型和String类型的排序(这个是通用的)

     /**
         * 字符串类型list排序
         * author byH
         * data 2021/2/1
         * @param list 需要排序的list
         */
        public static void listStringSorted(List<String> list){
              list.sort(String::compareTo);
        }
    
        /**
         * int类型list排序
         * author byH
         * data 2021/2/1
         * @param list 需要排序的list
         */
        public static void listIntegerSorted(List<Integer> list){
            list.sort(Integer::compareTo);
        }
    

    然后是稍微复杂一点点的,list里面包含了一个Integer或者String类型的list(基本算是通用的)

    /**
         * list包含int类型list的list排序
         * author byH
         * data 2021/2/1
         * @param list 需要排序的list
         * @param subscript 下标
         */
        public static void listListIntegerSorted(List<List<Integer>> list,int subscript){
            list.sort(Comparator.comparing(a -> a.get(subscript)));
        }
    
        /**
         * list包含字符串类型list的list排序
         * author byH
         * data 2021/2/1
         * @param list 需要排序的list
         * @param subscript 下标
         */
        public static void listListStringSorted(List<List<String>> list,int subscript){
            list.sort(Comparator.comparing(a -> Integer.parseInt(a.get(subscript))));
        }
    

    然后是最最复杂的,也是不通用的,可以借鉴改装,就是像这种类型:
    [[1, [0, 2, 3, 4]], [7, [2, 2, 3, 4]], [9, [5, 2, 3, 4]], [7, [8, 2, 3, 4]], [9, [9, 2, 3, 4]]]
    就是list里面包含了一个list,包含的list里面又包含了一个list,
    我现在要做的是按照最里面的list的第一个字符进行排序

            //生成测试list
            List<Object> list = new ArrayList<>();
            for(int i = 0 ; i < 5; i ++){
                List<Object> list2 = new ArrayList<>();
                List<String> list3 = new ArrayList<>();
                list2.add(String.valueOf((int) (Math.random() * 10)));
                list3.add(String.valueOf((int) (Math.random() * 10)));
                list3.add("2");
                list3.add("3");
                list3.add("4");
                list2.add(list3);
                list.add(list2);
            }
            System.out.println("排序前:"+list.toString());
            //用匿名内部类的方式排序
            Collections.sort(list, (o1, o2) -> {
                //获取第一层list
                List<Object> list1 = (List<Object>) o1;
                List<Object> list2 = (List<Object>) o2;
                //获取最里层list
                List<String> integerList1 = (List<String>) list1.get(1);
                List<String> integerList2 = (List<String>) list2.get(1);
                return Integer.parseInt(integerList1.get(0)) - Integer.parseInt(integerList2.get(0));
            });
            System.out.println("排序后:"+list.toString());
    

    结果:

    排序前:[[3, [6, 2, 3, 4]], [5, [0, 2, 3, 4]], [3, [8, 2, 3, 4]], [7, [3, 2, 3, 4]], [4, [6, 2, 3, 4]]]
    排序后:[[5, [0, 2, 3, 4]], [7, [3, 2, 3, 4]], [3, [6, 2, 3, 4]], [4, [6, 2, 3, 4]], [3, [8, 2, 3, 4]]]
    

    在这里插入图片描述
    当然了,如果你想按照第二层的list排序,只要获取第二层的第一个数据就可以了;

     //生成测试list
            List<Object> list = new ArrayList<>();
            for(int i = 0 ; i < 5; i ++){
                List<Object> list2 = new ArrayList<>();
                List<String> list3 = new ArrayList<>();
                list2.add(String.valueOf((int) (Math.random() * 10)));
                list3.add(String.valueOf((int) (Math.random() * 10)));
                list3.add("2");
                list3.add("3");
                list3.add("4");
                list2.add(list3);
                list.add(list2);
            }
            System.out.println("排序前:"+list.toString());
            //用匿名内部类的方式排序
            Collections.sort(list, (o1, o2) -> {
                //获取第一层list
                List<Object> list1 = (List<Object>) o1;
                List<Object> list2 = (List<Object>) o2;
                return Integer.parseInt(String.valueOf(list1.get(0))) - Integer.parseInt(String.valueOf(list2.get(0)));
            });
            System.out.println("排序后:"+list.toString());
    

    在这里插入图片描述

    展开全文
  • Java 8 中的List排序

    万次阅读 2019-06-13 16:50:36
    按字母顺序排序字符串列表 List<String> cities = Arrays.asList( "Milan", "london", "San Francisco", "Tokyo", "New Delhi" ); System.out.println(cities); //[Milan, london, S...
    • 按字母顺序排序字符串列表
    List<String> cities = Arrays.asList(
           "Milan",
           "london",
           "San Francisco",
           "Tokyo",
           "New Delhi"
    );
    System.out.println(cities);
    //[Milan, london, San Francisco, Tokyo, New Delhi]
    
    cities.sort(String.CASE_INSENSITIVE_ORDER);
    System.out.println(cities);
    //[london, Milan, New Delhi, San Francisco, Tokyo]
    
    cities.sort(Comparator.naturalOrder());
    System.out.println(cities);
    //[Milan, New Delhi, San Francisco, Tokyo, london]
    

    Java 7中,我们使用Collections.sort对List进行排序,Collections.sort方法参数为ListJava 8中新增了一个集合方法List.sort,方法接受参数Comparator

    • 排序整数集合
    List<Integer> numbers = Arrays.asList(6, 2, 1, 4, 9);
    System.out.println(numbers); //[6, 2, 1, 4, 9]
    
    numbers.sort(Comparator.naturalOrder());
    System.out.println(numbers); //[1, 2, 4, 6, 9]
    
    • 按某个字符串属性列排序
    List<Movie> movies = Arrays.asList(
            new Movie("Lord of the rings"),
            new Movie("Back to the future"),
            new Movie("Carlito's way"),
            new Movie("Pulp fiction"));
    
    movies.sort(Comparator.comparing(Movie::getTitle));
    
    movies.forEach(System.out::println);
    

    结果输出

    Movie{title='Back to the future'}
    Movie{title='Carlito's way'}
    Movie{title='Lord of the rings'}
    Movie{title='Pulp fiction'}
    

    我们注意到,给sort方法传递的并非Comparator类型,但结果仍然正确排序,原因就在于我们比较的属性列是String,而String已经实现了Comparable接口,查看Comparator.comparing()的定义实现,我们可以看到其其调用的就是比较关键字的compareTo方法

    return (Comparator<T> & Serializable)
                (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    
    • 按Double类型排序
    List<Movie> movies = Arrays.asList(
            new Movie("Lord of the rings", 8.8),
            new Movie("Back to the future", 8.5),
            new Movie("Carlito's way", 7.9),
            new Movie("Pulp fiction", 8.9));
    
    movies.sort(Comparator.comparingDouble(Movie::getRating)
                          .reversed());
    
    movies.forEach(System.out::println);
    

    本质上,Comparator.comparingDouble()调用的还是Double.compare()的方法,同样类似的还有comparingInt()comparingLong()方法

    • 自定义比较规则

    比如,对于我们之前提到的Movie,这里我们需要按星标排序,那么我们可以自定义Comparator实现类

    List<Movie> movies = Arrays.asList(
            new Movie("Lord of the rings", 8.8, true),
            new Movie("Back to the future", 8.5, false),
            new Movie("Carlito's way", 7.9, true),
            new Movie("Pulp fiction", 8.9, false));
    
    movies.sort(new Comparator<Movie>() {
        @Override
        public int compare(Movie m1, Movie m2) {
            if(m1.getStarred() == m2.getStarred()){
                return 0;
            }
            return m1.getStarred() ? -1 : 1;
         }
    });
    
    movies.forEach(System.out::println);
    

    得到输出结果如下:

    List<Movie> movies = Arrays.asList(
            new Movie("Lord of the rings", 8.8, true),
            new Movie("Back to the future", 8.5, false),
            new Movie("Carlito's way", 7.9, true),
            new Movie("Pulp fiction", 8.9, false));
    
    movies.sort(new Comparator<Movie>() {
        @Override
        public int compare(Movie m1, Movie m2) {
            if(m1.getStarred() == m2.getStarred()){
                return 0;
            }
            return m1.getStarred() ? -1 : 1;
         }
    });
    
    movies.forEach(System.out::println);
    

    当然,我们也可以Lambda表达式以匿名类简写如下:

    movies.sort((m1, m2) -> {
        if(m1.getStarred() == m2.getStarred()){
            return 0;
        }
        return m1.getStarred() ? -1 : 1;
    });
    

    或者通过Comparator.comparing()方法

    movies.sort(Comparator.comparing(Movie::getStarred, (star1, star2) -> {
        if(star1 == star2){
             return 0;
        }
        return star1 ? -1 : 1;
    }));
    
    • chain of Comparator排序集合

    还是上面的例子,如果我们需要首先按电影星标,然后再按评分高低排序,那么我们可以通过如下方式实现。

    List<Movie> movies = Arrays.asList(
            new Movie("Lord of the rings", 8.8, true),
            new Movie("Back to the future", 8.5, false),
            new Movie("Carlito's way", 7.9, true),
            new Movie("Pulp fiction", 8.9, false));
    
    movies.sort(Comparator.comparing(Movie::getStarred)
                          .reversed()
                          .thenComparing(Comparator.comparing(Movie::getRating)
                          .reversed())
    );
    
    movies.forEach(System.out::println);
    

    我们可以得到排序结果如下:

    Movie{starred=true, title='Lord of the rings', rating=8.8}
    Movie{starred=true, title='Carlito's way', rating=7.9}
    Movie{starred=false, title='Pulp fiction', rating=8.9}
    Movie{starred=false, title='Back to the future', rating=8.5}
    

    原文链接:

    https://reversecoding.net/java-8-comparator-how-to-sort-a-list/

    展开全文
  • JDK 8 之 List排序

    千次阅读 2019-11-04 01:36:47
    1、自然序排序一个listlist.stream().sorted().collect(Collectors.toList()); 2、自然序逆序元素,使用Comparator 提供的reverseOrder() 方法: list.stream().sorted(Comparator.reverseOrder())....
  • list排序的几种方法

    万次阅读 2019-06-11 10:52:05
    List<Integer> list = new ArrayList<>(); list.add(3); list.add(5); list.add(1); Collections工具类,升序排: Collections.sort(list); System.out.println(list); Console: [1, 3, 5] ...
  • flutter dart list 排序

    千次阅读 2020-01-06 12:52:07
    工作中经常用到,商品或者聊天会话排序 List list=new List(); list.add(new Form("AAAA",1)); list.add(new Form("BBBB",2)); list.add(new Form("CCCCC",3)); list.sort((left,right)=>left.age.compare...
  • Unity的List排序

    千次阅读 2019-03-21 11:32:56
    默认List排序是升序排序,如果要降序排序,也很简单,只需要在前面加一个负号即可。 List<int> m_temp = new List<int>(){6,1,3,5,4}; // 升序 m_temp.Sort((x, y) => x.CompareTo(y)); // ...
  • Kotlin中的List排序

    千次阅读 2020-09-04 17:35:59
    在Java中,对List进行排序可以使用Collections.sort()方法,在Kotlin中有更简单的语法糖,所以这里记录一下,开发中尽量用简单的方式,方便维护。 一段未排序的示例代码如下: data class User(val name: String, ...
  • Java的List排序

    万次阅读 多人点赞 2019-06-08 21:32:44
    开发工具与关键技术:MyEclipse 10、Java语法 作者:邓婵 撰写时间:2019年6 月 5日 集合和数组的不同点: 数组:只能存储固定大小同一类型的元素。...Collection和map属于同一系统集合,list接口和set接口继...
  • JAVA8 - Lambda之List排序

    千次阅读 2019-03-12 14:31:44
    JAVA8之前的List排序操作 在Java8之前,对集合排序只能创建一个匿名内部类 new Comparator() { @Override public int compare(Human h1, Human h2) { return h1.getName().compareTo(h2.getName()); } }...
  • JDK1.8 list 排序

    万次阅读 2018-08-14 18:08:48
    首先用泛型为String的list和泛型为AuditBO对象的list进行排序 List&lt;String&gt; list = new ArrayList&lt;&gt;(); list.add("2"); list.add("1"); list.add("4&...
  • Python3 list 排序字符串排序

    万次阅读 2018-12-18 11:37:45
     list.sort(key=None,reverse=False) 函数功能: 对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序排序。 函数参数: (1) key: 主要是用来进行比较的元素,只有一...
  • lambda表达式对list排序

    千次阅读 2019-06-26 22:08:54
    对一个对象list排序排序字段是对象的sortNum,排序前剔除掉sortNum为null的对象 定义待排序的bean public class TestBean { private Integer id; private String name; private Integer sortNum; } 2...
  • java字符串list排序

    千次阅读 2019-10-27 17:13:10
    @Test public void test2() ... List<String> list = new ArrayList<String>(); list.add("abce"); list.add("a"); list.add("110"); list.add("1"); list.add("abcd"); Collections.sort...
  • 嵌套List排序,java8 Stream流排序

    千次阅读 2019-10-04 22:04:12
    如图类型数据格式,现在要进行排序。根据java8的写法可为: List<B> dtoList=list<A>.getData(); List<B> bList=dtoList.stream() .sorted(Comparator.comparing(o -> o.getListc(...
  • .NET中List排序总结

    千次阅读 2018-08-02 15:58:28
    对于基本类型的普通排序 直接调用Sort()方法 List&lt;int&gt;...基础类型排序前(List&lt;int&gt;):"); foreach (var item in listBase) { Console.Write($"{ite...
  • lambda表达式 list排序

    千次阅读 2019-03-12 17:13:14
    升序降序比较,默认List排序是升序排序 如果要降序排序,也很简单,只需要在前面加一个负号 List<int> tmp = new List<int>(){5,1,22,11,4}; // 升序 tmp.Sort((x, y) => x.CompareTo(y)); // 降...
  • Stream流处理list排序

    千次阅读 2019-09-21 14:22:59
    代码:List<...//list中放入数据集后根据每一笔map中的order_no字段进行冒泡排序 list.sort((Map<String,Object> h1,Map<String,Object> h2) -> ((String) h1.get("order_no...
  • Python中的list排序

    千次阅读 2018-01-04 21:15:04
    尽量使用sorted进行排序,保持代码的统一性 一、基本形式 sorted(iterable[, cmp[, key...(1)iterable指定要排序list或者iterable,不用多说; (2)cmp为函数,指定排序时进行比较的函数,可以指定一个函数或
  • list排序的问题

    万次阅读 2018-09-03 10:02:06
    list如何按照自定义排序 方法: 一:list有序列表 输出按照放入先后排序 二:使用Collections.sort()排序 三:创建对象 四: 发现,代码直接报错了: Bound mismatch: The generic method sort...
  • Dart: List排序

    千次阅读 2019-06-15 21:44:00
    var list = <Item>[ Item(title: "item 1", isTopping: true), Item(title: "item 2"), Item(title: "item 3", isTopping: true), Item(title: "item 4"), ]; main(List<String> arguments) as...
  • List<T> listSorted = list.stream().sorted(Comparator<? super T> comparator).collect(Collectors.toList()); 具体代码⤵️ package com . demo . jdk8 . comparator ; import com . google . common ...
  • java8实现List排序

    千次阅读 2019-06-20 08:23:03
    数值集合排序 List<Integer> list = Lists.newArrayList(3, 1, 2, -1); // 正序 list.sort(Integer::compareTo); list.forEach((i) -> System.out.println(i)); // 倒叙 list.sort(Comparator.reverseOrder...
  • python3 对list排序 sort

    千次阅读 2018-02-20 14:27:52
    对字符按ASCII码从小到大排序: l = ['a','Z','w','C','Q','b','t'] l.sort() print(l) 从大到小: l = ['a','Z','w','C','A','b','t'] l.sort(reverse=True) print(l) 按字母顺序从小到大排序: l = ['a','...
  • Java8集合List排序、筛选1. List1.1 ArrayList1.2 LinkedList1.3 ArrayList和LinkedList比较1.4 List过滤指定元素1.4.1 准备待测试的List1.4.2 使用Iterator遍历List1.4.2 使用Java8对List过滤筛选1.5 使用Java8对...
  • >>> list1 = [3,2,4,1, 1] >>> list2 = ['three', 'two', 'four', 'one', 'one2'] ... list1, list2 = zip(*sorted(zip(list1, list2))) >>> list1 (1, 1, 2, 3, 4) >>&g...
  • flutter - sort List排序

    千次阅读 2019-10-18 16:28:07
    dart中,对List结构数据进行排序 注意 sort方法 会直接改变原List数组结构 List<Map> myList = [ { 'name' : 'ifredom',age:23}, { 'name' : 'JackMa',age:61}, { 'name' : 'zhazhahui',age:48}, ]; ...
  • Java8中List排序--让代码更加优雅的排序方法

    万次阅读 热门讨论 2018-08-13 22:28:24
    在做wab项目中不免会做后台管理,后台最常见的就是表格了,这时候按照一般规则都会按照某个属性进行排序,像这种List<实体>类型的甚为常见。下面给大家分享三种按照属性中的某一个字段排序的例子,有用到的...
  • 现有两个 list:A, B,其中A中保存日期,B中保存该日期下的产量,要求按照产量排序,并使日期列表随之排序。 二、解法 1. 将A,B两个 list 变成 list of tuple,使用 zip() 函数 zipped = zip(A,B) # print...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 689,455
精华内容 275,782
关键字:

list排序