精华内容
下载资源
问答
  • JAVA中对集合排序

    千次阅读 2021-03-21 23:49:12
    JAVA中对集合排序 1.集合排序的基本概念 集合排序,它可以使用集合的工具类java.util.Collections 其定义了很多静态方法,用于操作集合,其中sort方法是对list集合进行自然排序(从小到大)。 public class ...

    JAVA中对集合排序

    1.集合排序的基本概念

    集合排序,它可以使用集合的工具类java.util.Collections

    其定义了很多静态方法,用于操作集合,其中sort方法是对list集合进行自然排序(从小到大)。

    public class Collections_sort {
    	public static void main(String[] args) {
    		//随机生成生成10个100内的整数存储在list集合中
    		List<Integer> list=new ArrayList<Integer>();
    		for(int i=0;i<10;i++){
    			int a=(int)(Math.random()*100);
    			list.add(a);
    		}
    		System.out.println(list);
    		
    		//进行集合排序
    		Collections.sort(list);
    		System.out.println("排序后的"+list);
    	}
    
    }
    
    执行结果:

    [25, 41, 87, 9, 33, 43, 94, 78, 92, 32]
    排序后的[9, 25, 32, 33, 41, 43, 78, 87, 92, 94]

    2.对对象进行排序

    sort方法要求集合元素必须实现Comparable接口,
    Collections的sort方法具有侵入性,所谓侵入性是指当我们使用某个功能时,该功能要求我们修改代码,修改的越多侵入性越强,一旦不需要该功能,这个改动就没有意思了,在实际并发中是不推荐使用的。

    1.首先对自定义的类实现comparable接口

    实现comparable接口,要求必须重写该方法,那么他的意思是定义当前对象与参数。

    • 对象的大小关系:
    • 返回值不关注当前的取值,只关注取值的范围
    • 当返回值>0,当前对象this大于参数对象
    • 当返回值<0,当前对象this小于参数对象
    • 当返回值=0,当前对象this等于参数对象
    public class Pointer implements Comparable<Pointer>{
    	private int x;
    	private int y;
    	public int getX() {
    		return x;
    	}
    	public void setX(int x) {
    		this.x = x;
    	}
    	public int getY() {
    		return y;
    	}
    	public void setY(int y) {
    		this.y = y;
    	}
    	@Override
    	public String toString() {
    		return "Pointer [x=" + x + ", y=" + y + "]";
    	}
    	public Pointer(int x, int y) {
    		super();
    		this.x = x;
    		this.y = y;
    	}
    	
    	public int compareTo(Pointer o) {
    		int len=this.x*this.x+this.y*this.y;
    		int olen=o.x*o.x+o.y*o.y;
    		return len-olen;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + x;
    		result = prime * result + y;
    		return result;
    	}
    	
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Pointer other = (Pointer) obj;
    		if (x != other.x)
    			return false;
    		if (y != other.y)
    			return false;
    		return true;
    	}
    }
    
    2.对Pointer对象进行排序
    public class Collections_sort2 {
    	public static void main(String[] args) {
    		List<Pointer> list=new ArrayList<Pointer>();
    		list.add(new Pointer(2,3));
    		list.add(new Pointer(1,4));
    		list.add(new Pointer(0,5));
    		list.add(new Pointer(8,9));
    		list.add(new Pointer(7,6));
    		list.add(new Pointer(1,5));
    		list.add(new Pointer(6,8));
    		System.out.println(list);
    
    		Collections.sort(list);
    		
    		System.out.println("排序后的list为"+list);
    		
    	}
    }
    
    执行结果:

    [Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=8, y=9], Pointer [x=7, y=6], Pointer [x=1, y=5], Pointer [x=6, y=8]]
    排序后的list为[Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=1, y=5], Pointer [x=7, y=6], Pointer [x=6, y=8], Pointer [x=8, y=9]]

    结果分析:

    对对象的排序后的顺序取决于自定义类重写后compareTo(Pointer o)方法,我们可以按照自己的意愿对这个比较方法自行定义,缺点就是侵入性强。

    3.比较器

    推荐的集合排序方式: 当遇到排序自定义类型元素或者集合元素自身的比较规则不满足时都建议使用下面的方式排序,该sort方法要求额外传来一个比较器,并按照比较器规则比较集合元素并进行排序,因此该排序方法不要求集合元素实现comparable接口。

    public class Collections_sort3 {
    	public static void main(String[] args) {
    		List<String> list=new ArrayList<String>();
    		list.add("小马");
    		list.add("小超超");
    		list.add("小陈泽与");
    		list.add("沃德四级啊");
    		
    		
    Comparator<String> cp=new Comparator<String>() {
    			
    		public int compare(String o1, String o2) {
    				int a=o1.length();
    				int b=o2.length();
    				return a-b;
    			}
    		};
    		Collections.sort(list, cp);
    		System.out.println("排序后的结果:"+list);
    	}
    }
    
    执行结果:

    排序后的结果:[小马, 小超超, 小陈泽与, 沃德四级啊]

    结果分析:

    比较器使用更加简便,不用实现comparable接口,更能满足使用者的需求。

    4.利用比较器对对象排序

    public class Collections_sort4 {
    	public static void main(String[] args) {
    		List<Pointer> list=new ArrayList<Pointer>();
    		list.add(new Pointer(2,3));
    		list.add(new Pointer(1,4));
    		list.add(new Pointer(0,5));
    		list.add(new Pointer(8,9));
    		list.add(new Pointer(7,6));
    		list.add(new Pointer(1,5));
    		list.add(new Pointer(6,8));
    		
    		//使用Comparator比较器对集合排序
    		Comparator<Pointer> oop=new Comparator<Pointer>() {
    			public int compare(Pointer o1, Pointer o2) {
    				int a=o1.getX()+o1.getY();
    				int b=o2.getX()+o2.getY();
    				return a-b;
    			}
    		};
    		Collections.sort(list, oop);
    		System.out.println("排序后的list是"+list);
    	}
    }
    
    执行结果:

    排序后的list是[Pointer [x=2, y=3], Pointer [x=1, y=4], Pointer [x=0, y=5], Pointer [x=1, y=5], Pointer [x=7, y=6], Pointer [x=6, y=8], Pointer [x=8, y=9]]

    展开全文
  • java 使用Lambda对集合排序

    千次阅读 2018-12-13 14:47:04
    一、利用lambdalist集合排序  先定义一个集合 List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); list.add(1); list.add(5); list.add(4); list.add(3); list.add(7); 1、升序排序 ...

    一、利用lambda对list集合排序

           先定义一个集合

    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(5);
    list.add(4);
    list.add(3);
    list.add(7);

    1、升序排序

    list.sort((a,b)->a.compareTo(b));

    或者

    list.sort(Comparator.comparing(a->a));

    或者

    list.sort((a,b)->a-b);

    或者

    // 2、匿名内部类
    list.sort(new Comparator<Integer>() {
    	@Override
    	public int compare(Integer o1, Integer o2) {
    		return o1-o2;
    	}
    });

    2、降序

    (1): list.sort((a,b)->b-a);

    (2):2、匿名内部类

                list.sort(new Comparator<Integer>() {
                      @Override
                      public int compare(Integer o1, Integer o2) {
                             return o2-o1;
                      }
                });

    2、对对象集合操作,其实与基本类型集合操作类似

    List<User> list1 = new ArrayList<User>();
    User user = new User("张三", "15", "男");
    User user1 = new User("李四", "10", "男");
    list1.add(user);
    list1.add(user1);
    //1、年龄升序
    list1.sort((a,b) -> a.getAge().compareTo(b.getAge()));
    //2、姓名降序排列
    list1.sort(Comparator.comparing(User::getName).reversed());
    //等价于 2
    list1.sort(Comparator.comparing(a->((User)a).getAge()).reversed());
    //3、先按性别排,如果年龄相同,再按年龄排序
    list1.sort(Comparator.comparing(User::getSex).reversed().thenComparing(User::getAge));

     

    3、对 JSONArray 排序

    定义一个json数组 resultArray

    JSONArray resultArray = new JSONArray();
    JSONObject result = new JSONObject();
    result.put("name","张三");
    result.put("age","15");
    result.put("data","201812130451");
    resultArray.add(result);
    //根据姓名的倒序排序
    resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getString("name")).reversed());
    //根据时间倒序排序
    resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getData("data")).reversed());
    //根据年龄升序排序
    resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getInteger("age")));

    注意:reversed()函数的意思是将数组颠倒。其用法常见于字符串处理中,将字符串颠倒
    如:
    String str = "abcd";
    StringBuffer sb = new StringBuffer(str);
    sb.reverse();
    System.out.println(str);
    System.out.println(sb.toString());

    控制台输出

     

     

     

     

     

     

     

     

    展开全文
  • java中对集合排序,可以使用Collections.sort来进行排序,可以对中文、字母、数字进行排序,当比较的是对象时候,让该类实现comparable接口,示例如下Collections.sort(findShangpID, new Comparator&...
    java中对集合排序,可以使用Collections.sort来进行排序,可以对中文、字母、数字进行排序,当比较的是对象时候,让该类实现comparable接口,示例如下
    Collections.sort(findShangpID, new Comparator<PageData>() {
    @Override
    public int compare(PageData o1, PageData o2) {
    Double o1n=o1.getDouble("stock1")+o1.getDouble("stock2")+o1.getDouble("stock3");
    Double o2n=o2.getDouble("stock1")+o2.getDouble("stock2")+o2.getDouble("stock3");
    if(o1n>o2n){
    return -1;
    }else if(o1n==o2n){
    return 0;
    }else if(o1n<o2n){
    return 1;
    }
    return 0;
    }
    });

    展开全文
  • //对集合元素的处理可以放在forEach中,例如:forEach(this::f2); a c [a, c] [User{age=3, name='Tom3'}, User{age=2, name='Tom2'}, User{age=1, name='Tom1'}] [User{age=1, name='Tom1'}, User{age=2, ...
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.TreeSet;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    class User {
        private Integer age;
        private String name;
    
        public User(Integer age, String name) {
            this.age = age;
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    public class Main {
        private List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            Main main = new Main();
    
            String[] strArray = Stream.of("a", "b", "c")
                    .filter(x -> !x.equals("b"))
                    .toArray(x -> new String[x]);
            Arrays.asList(strArray).forEach(System.out::println);
    
            TreeSet<String> strSet = Stream.of("a", "b", "c", "c")
                    .filter(x -> x != String.valueOf("b"))
                    .collect(Collectors.toCollection(TreeSet::new));
            System.out.println(strSet);
    
            main.f1();
        }
    
        private void f1() {
            List<User> userList = new ArrayList<>();
            userList.add(new User(3, "Tom3"));
            userList.add(new User(2, "Tom2"));
            userList.add(new User(1, "Tom1"));
    
            //java.util.stream.Stream,该排序无效
            userList.stream().sorted((User o1, User o2) -> {
                return o1.getAge().compareTo(o2.getAge());
            });
            System.out.println(userList);
            //[User{age=3, name='Tom3'}, User{age=2, name='Tom2'}, User{age=1, name='Tom1'}]
    
            //java.util.List,该排序有效。
            userList.sort((User o1, User o2) -> {
                return o1.getAge().compareTo(o2.getAge());
            });
            System.out.println(userList);
            //[User{age=1, name='Tom1'}, User{age=2, name='Tom2'}, User{age=3, name='Tom3'}]
    
    
            //userList.stream().forEach(f2(user));//报错
            userList.stream().forEach(this::f2);//正确,方法引用,元素类型要与f2的类型一致,只能有一个入参
            System.out.println(userList);
            //[User{age=12, name='Tom'}, User{age=12, name='Tom'}, User{age=12, name='Tom'}]
    
            userList.stream().forEach(user -> f3(user, 14));//lambda,可以有多个入参
            System.out.println(userList);
            //[User{age=14, name='Tom'}, User{age=14, name='Tom'}, User{age=14, name='Tom'}]
        }
    
        /**
         * forEach中调用,方法引用
         *
         * @param user
         */
        private void f2(User user) {
            user.setName("Tom");
            user.setAge(12);
        }
    
        /**
         * forEach中调用,lambda
         *
         * @param user
         * @param age
         */
        private void f3(User user, Integer age) {
            user.setName("Tom");
            user.setAge(age);
        }
    }
    
    //集合的排序直接使用List.sort即可
    //对集合元素的处理可以放在forEach中,例如:forEach(this::f2);

    a
    c
    [a, c]
    [User{age=3, name='Tom3'}, User{age=2, name='Tom2'}, User{age=1, name='Tom1'}]
    [User{age=1, name='Tom1'}, User{age=2, name='Tom2'}, User{age=3, name='Tom3'}]
    [User{age=12, name='Tom'}, User{age=12, name='Tom'}, User{age=12, name='Tom'}]

     

    展开全文
  • 1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • map集合排序

    千次阅读 2017-08-04 12:15:13
    写东西时遇到一个问题,要将HashMap按照value的值来进行...场景是这样的,一个Map中,泛型为,现在要按照value从大到小这个集合排序,而且value值可能有相同的,所以 没办法将它反着放进另外一个Map中,因为Map中key
  • Redis 集合排序

    千次阅读 2017-09-19 22:44:04
    排序主要针对的是集合操作,即List、Set、ZSet这三种集合。 排序操作主要依赖于如下几个...尽量使用limit限制获取的数据量集合排序返回或保存给定列表、集合、有序集合 key 中经过排序的元素,默认是升序语法:sort
  • scala集合排序

    千次阅读 2017-08-01 09:24:32
    Problem  你想要对一个集合元素进行排序。或者你想定义一个自定义类来... 你可以使用sorted或者sortWith方法来对集合进行排序。  Sorted方法可以对集合元素类型为Double,Float,Int和其他可以隐试转化scala.ma
  • 使用Stream对集合进行排序

    千次阅读 2019-10-23 16:32:23
    JDK 8 用Stream对集合排序 ​ 在开发过程中,大多数的排序场景,我们都可以使用数据库的order by关键字就能够给数据进行排序,但是有些场景是需要获得数据后,需要通过某个对象的属性进行排序,这个时候我们就可以...
  • java中的各种集合排序

    千次阅读 2019-05-03 01:44:35
    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • Map集合排序——根据valuekey进行排序 在流水的业务中,码出最优雅的代码。 描述:有若干个键值格式的json字符串,根据其中的value进排序,取出其中的排位靠前的一半以上的key值,json数据为:{“1.B.1.f”...
  • Android数据排序之集合排序

    千次阅读 2018-01-19 16:28:39
    前言 最近在写项目时遇到这样一个问题,后台...关于排序的处理方法,基本上都是Java基础中的内容,说实话一开始还真是记不太清了,基础掌握的太不牢靠了,吓的我赶紧去翻了翻《Java核心技术》,又重新这一块内容做
  • Set集合排序

    万次阅读 2017-10-03 11:08:08
    TreeSet使用元素的自然顺序元素进行排序,或者根据创建set时提供的Comparator进行排序,具体取决于使用的构造方法。通俗一点来说,就是可以按照排序后的列表显示,也可以按照指定的规则排序。Set<String> set = ...
  • java集合排序

    千次阅读 2015-05-31 15:24:21
    实际开发中,我们经常需要一个实体集合中的实体按照实体的某一个字段进行排序,然后再有序地显示到界面上。例如:我们得到了一个学生集合,而需求要求我们可以按照学生的姓名排序或学生成绩排序。  我们得到的...
  • 前端后台返回的集合排序

    千次阅读 2018-12-29 16:39:12
    也是跟后台一样用的sort方法,不过我现在也没用前端排序
  • JAVA中的集合排序

    千次阅读 2018-02-21 16:32:34
    版权声明:未经允许,随意转载...JAVA集合排序 基本类型和字符串类型排序 基本类型和字符串类型排序直接调用 Collections.sort(list);根据元素的自然顺序指定列表按升序进行排序 + 存储在List中的整型数据...
  • List集合排序、自定义比较器排序

    千次阅读 2019-08-20 17:25:12
    List集合排序 1、集合工具类(包装类)Collections.sort 使用Collections提供的sort方法,对集合进行排序 Collections.sort(list); 实现原理: 将list转成了数组对象后,调用了Array的sort方法,将数组排序,再用...
  • Java—集合排序

    千次阅读 2018-07-27 20:09:38
    Java——集合排序 &amp;lt;一&amp;gt;接口comparable与接口comparator的比较 1&amp;gt; Comparable Comparable是在集合内部定义方法实现的排序,位于java.util包下。是一个对象本身就已经...
  • 自定义List对象集合排序

    千次阅读 2019-06-12 19:59:07
    //准备一个集合,添加一些对象 ArrayList<Commodity> powedList = new ArrayList(); //忽略添加对象的过程 powedList.add........... //排序 Collections.sort(powedList,new SalesComparator(false)); //...
  • Java中对集合排序,因为项目中得实现一个点击表头对数据进行排序... 下面介绍下对集合进行自定义的排序,因为很多情况下,集合中的数据保存的都是类对象,我们要对集合进行排序,换句话讲就是根据类中定义的属性对类
  • Java Collections.sort方法list集合排序

    千次阅读 2016-09-26 14:57:59
    1、排序测试类package com.web.test;import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List;public class UserSort { public static void main(String[] ...
  • Java日期型集合排序

    千次阅读 2018-12-14 10:19:54
    代码 package com.qian.util; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date;...pu...
  • list集合排序升序和降序使用sort()

    万次阅读 2018-07-27 17:36:10
    Collections.sort(resultList, new Comparator&lt;HealthRecordRepeat&gt;() {  @Override  public int compare(HealthRecordRepeat o1, HealthRecordRepeat o2) {  //retu...
  • JavaList集合进行排序

    千次阅读 2019-03-29 15:53:27
    这几天做题刚好遇到List集合排序的题,发现一种好用的方法,做一个笔记。 我是基于spring,对于刚学java的小伙伴可以直接在main方法中去完成。 第一步 创建一个实体类对象User package bean; public class User {...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 453,927
精华内容 181,570
关键字:

对集合排序