精华内容
参与话题
问答
  • 目录 方法1:实现comparable接口 方法2:自定义排序(Comparator接口、compare方法) ...java集合的工具类Collections中提供了两种排序的方法,分别是: Collections.sort(List list) Collections.sort...

    目录

    方法1:实现comparable接口

    方法2:自定义排序(Comparator接口、compare方法)


    参考:https://www.cnblogs.com/huangjinyong/p/9037588.html

    java集合的工具类Collections中提供了两种排序的方法,分别是:

    1. Collections.sort(List list)
    2. Collections.sort(List list,Comparator c)

    方法1:实现comparable接口

    参与排序的对象需实现comparable接口,重写其compareTo()方法,方法体中实现对象的比较大小规则,示例如下: 

    package test;
    
    public class Emp implements Comparable {
    
        private String name;
        private int age;
        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;
        }
        public Emp() {
            super();
        }
        public Emp(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Emp [name=" + name + ", age=" + age + "]";
        }
        @Override
        public int compareTo(Object o) {
            if(o instanceof Emp){
                Emp emp = (Emp) o;
    //          return this.age-emp.getAge();//按照年龄升序排序
                return this.name.compareTo(emp.getName());//换姓名升序排序
            }
            throw new ClassCastException("不能转换为Emp类型的对象...");
        }
    
    }

    方法2:自定义排序(Comparator接口、compare方法)

    先new一个Comparator接口的比较器对象c,同时实现compare()其方法;然后将比较器对象c传给Collections.sort()方法的参数列表中,实现排序功能;

    /**使用Comparator比较器按age升序排序*/
        @Test
        public void testComparatorSortAge(){
            Collections.sort(list,new Comparator () {
                @Override
                public int compare(Object o1, Object o2) {
                    if(o1 instanceof Emp && o2 instanceof Emp){
                        Emp e1 = (Emp) o1;
                        Emp e2 = (Emp) o2;
                        return e1.getAge() - e2.getAge();
                    }
                    throw new ClassCastException("不能转换为Emp类型");
                }
            });
            System.out.println("使用Comparator比较器按age升序排序后:");
            for(Object o : list){
                System.out.println(o);
            }
        }

     

    展开全文
  • 如何对List集合中的元素进行排序

    千次阅读 2018-01-04 15:18:19
    Collections对List集合中的数据进行排序

    Collections对List集合中的数据进行排序

    有时候需要对集合中的元素按照一定的规则进行排序,这就需要用到
    Java中提供的对集合进行操作的工具类Collections,其中的sort方法

    先看一个简单的例子:
    [java] view plain copy
    public static void main(String[] args) {
    List nums = new ArrayList();
    nums.add(3);
    nums.add(5);
    nums.add(1);
    nums.add(0);
    System.out.println(nums);
    Collections.sort(nums);
    System.out.println(nums);
    }
    输出结果:
    [3, 5, 1, 0]
    [0, 1, 3, 5]
    稍微复杂的List里面放一个复杂的对象
    [java] view plain copy
    package core.java.collection.collections;

    public class User implements Comparable{

    private int score;  
    
    private int age;  
    
    public User(int score, int age){  
        super();  
        this.score = score;  
        this.age = age;  
    }  
    
    public int getScore() {  
        return score;  
    }  
    
    public void setScore(int score) {  
        this.score = score;  
    }  
    
    public int getAge() {  
        return age;  
    }  
    
    public void setAge(int age) {  
        this.age = age;  
    }  
    
    @Override  
    public int compareTo(User o) {  
        int i = this.getAge() - o.getAge();//先按照年龄排序  
        if(i == 0){  
            return this.score - o.getScore();//如果年龄相等了再用分数进行排序  
        }  
        return i;  
    }  
    

    }

    public static void main(String[] args) {
    List users = new ArrayList();
    users.add(new User(78, 26));
    users.add(new User(67, 23));
    users.add(new User(34, 56));
    users.add(new User(55, 23));
    Collections.sort(users);
    for(User user : users){
    System.out.println(user.getScore() + “,” + user.getAge());
    }
    }
    输出结果:
    55,23
    67,23
    78,26
    34,56
    我们会发现sort(List)方法中List中的T必须实现Comparable接口,然后实现
    compareTo()方法,该方法的返回值0代表相等,1表示大于,-1表示小于;为什么
    在简单例子中没有看到实现Comparable接口呢?是因为Integer类其实自己已经实现
    了Comparable接口,Java已经给我们做好了。

    Collections提供的第二种排序方法sort(List list, Comparator

    展开全文
  • List集合的各种排序

    万次阅读 多人点赞 2019-02-15 17:56:39
    在Java编程中,经常要对List集合进行排序,因此对List排序的各种情况进行总结,希望对各位读者有所帮助。 1.单属性变量List排序 1.1按照变量属性升序,降序排序 /** * 单属性变量list 自身属性升序, 降序排序 ...

    在Java编程中,经常要对List集合进行排序,因此对List排序的各种情况进行总结,希望对各位读者有所帮助。

    1.单属性变量List排序

              1.1按照变量属性升序,降序排序

    /**
     * 单属性变量list 自身属性升序, 降序排序
     */
    private void singleVariableSort1(){
    
        List<Integer> list = Arrays.asList(10,1,6,4,8,7,9,3,2,5);
    
        System.out.println("原始数据:");
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("升序排列:");
        Collections.sort(list); // 升序排列
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("降序排列:");
        Collections.reverse(list); // 倒序排列
        list.forEach(n ->{System.out.print(n+", ");});
    }

              1.2按照自定义的顺序排序

    /**
     * 单属性变量list 自定义顺序排序
     */
    private void singleVariableSort2(){
    
        List<String> list = Arrays.asList("北京","上海","北京","广州","广州","上海","北京","上海");
    
        List<String> sortRule = Arrays.asList("北京","上海","广州");
    
        System.out.println("原始数据:");
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("排序规则:");
        sortRule.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("正序排列:");
        Collections.sort(list, new Comparator<String>()
        {
            public int compare(String a1, String a2)
            {
                    int io1 = sortRule.indexOf(a1);
                    int io2 = sortRule.indexOf(a2);
                    return io1 - io2;
            }
        });
    
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("倒序排列:");
        Collections.sort(list, new Comparator<String>()
        {
            public int compare(String a1, String a2)
            {
                int io1 = sortRule.indexOf(a1);
                int io2 = sortRule.indexOf(a2);
                return io2 - io1;
            }
        });
    
        list.forEach(n ->{System.out.print(n+", ");});
    }

    2.对象List排序

              2.1按照对象单属性升序,降序排序

    /**
     * 对象单属性升序,降序排序
     */
    private void entitySort1(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+ s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数升序排序:");
        students.sort(comparing(Student::getScore));
        students.forEach(s ->{ 
         System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+ s.getCollege()+""+s.getAddress());}); 
    
        System.out.println("按照分数降序排序:");
        students.sort(comparing(Student::getScore).reversed());
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.2按照对象多属性升序,降序排序

    /**
     * 对象多属性升序,降序排序
     */
    private void entitySort2(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数降序排序,当分数相同时, 按照身高升序排序");
        students.sort(comparing(Student::getScore).reversed().thenComparing(Student::getHeight));
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数降序排序,当分数相同时, 按照身高降序排序");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getScore().equals(student2.getScore())){
                    return student2.getHeight() - student1.getHeight();
                }else{
                    return student2.getScore() - student1.getScore();
                }
            }
        });
    
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.3按照对象自定义单属性的顺序排序

    /**
     * 对象自定义单属性的顺序排序
     */
    private void entitySort3(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("自定义按照地区(北京,上海,广州)排序:");
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
            }
        });
    
        students.forEach( s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.4按照对象自定义多属性的顺序排序

     

    /**
     * 对象自定义多属性的顺序排序
     */
    private void entitySort4(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("先按照学院(电气学院,计算机学院,财经学院)排序, 当学院相同时,按照地区(北京,上海,广州)排序");
        List<String> collegeOrder = Arrays.asList("电气学院","计算机学院","财经学院");
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getCollege().equals(student2.getCollege())){
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
                }else{
                    int io1 = collegeOrder.indexOf(student1.getCollege());
                    int io2 = collegeOrder.indexOf(student2.getCollege());
                    return io1 - io2;
                }
            }
        });
    
        students.forEach( s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }
    

              2.5按照对象属性自定义混合排序

    /**
     * 对象属性自定义混合排序
     */
    private void entitySort5(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        //先按照分数从高到低排序,当分数相同时,然后按照地区(北京,上海,广州)排序
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getScore().equals(student2.getScore())){
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
                }else{
                    return student2.getScore() - student1.getScore();
                }
            }
        });
    
        System.out.println("");
        System.out.println("先按照分数从高到低排序,当分数相同时,然后按照地区(北京,上海,广州)排序:");
        students.forEach( s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());}); 
    }

              2.6按照对象单属性升序,降序排序(float类型)

    /**
     * 对象单属性升序,降序排序(float类型)
     */
    private void entitySort6(){
    
       //Shop 的 list 集合
       List<Shop> shops = new ArrayList<>();
       shops.add(new Shop("华润万家", 20200921, (float) 10000.25));
       shops.add(new Shop("华润万家", 20200922, (float) 20000.26));
       shops.add(new Shop("华润万家", 20200923, (float) 9999.37));
       shops.add(new Shop("华润万家", 20200924, (float) 12587.86));
       shops.add(new Shop("华润万家", 20200925, (float) 15798.65));
    
       System.out.println("原始数据:");
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome() );
       });
    
       System.out.println("按照收入升序排序:");
       shops.sort(comparing(Shop::getIncome));
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome());
       });
    
       System.out.println("按照收入降序排序:");
       shops.sort(comparing(Shop::getIncome).reversed());
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome());
       });
    
    
    }

     

    展开全文
  • Java中对集合进行排序的两种方法

    万次阅读 多人点赞 2019-04-21 19:26:47
    Collections是集合的工具类,它提供了很多便于我们操作集合的方法, 其中就有用于集合排序的sort方法。 实际上,在使用Collection的sort排序的集合元素都必须是Comparable接口的实现类,该接口表示子类是可以比较的...

    Collections是集合的工具类,它提供了很多便于我们操作集合的方法, 其中就有用于集合排序的sort方法。
    在这里插入图片描述
    实际上,在使用Collection的sort排序的集合元素都必须是Comparable接口的实现类,该接口表示子类是可以比较的。因为实现接口必须重写抽象方法 - int compareTo(T t)。

    一、 对于集合的比较

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    public class Test1 {
    	public static void main(String[] args) {
    		List<Integer> list0 = new ArrayList<>();
    		Random random = new Random();
    		for(int i = 0; i<10;i++){
    			list0.add(random.nextInt(100));
    		}
    		System.out.println(list0);//[46, 7, 91, 48, 52, 25, 64, 3, 28, 60]
    		/*
    		 * 对集合进行自然排序,从小到大
    		 */
    			Collections.sort(list0);
    			System.out.println(list0);//[2, 19, 44, 46, 61, 67, 68, 89, 91, 94]
    			
    		List<String> list1 = new ArrayList<>();
    		list1.add("Alive");
    		list1.add("Rose");
    		list1.add("Jack");
    		list1.add("Noname");
    		System.out.println(list1);//[Alive, Rose, Jack, Noname]
    		Collections.sort(list1);
    		/*
    		 *对集合进行自然排序,显而易见是按照首字母顺序排序
    	   	 */
    		System.out.println(list1);//[Alive, Jack, Noname, Rose]
    		}
    	}
    	
    
    

    那么你有没有发现在该类中我并没有实现Comparable接口,那么为什么
    我对list0和list1集合排序时没有报错呢?
    在这里插入图片描述
    在这里插入图片描述
    原因:查询源码可知Integer、String类都实现了Comparable接口,所以在对list0和list1集合排序时没有报错。

    二、对于集合中的对象比较(自定义排序)

    那么问题来了对象这个大小之分是如何判断呢?

     *  实际上,在使用Collection的sort排序的集合元素都必须是Comparable接口的实现类,该接口
     *  表示子类是可以比较的。
     *  因为实现接口必须重写抽象方法。
     *    - int compareTo(T t);
     *    该方法用于使当前对象与给定对象进行比较。
     *    返回值为一个int值,该值表示大小关系,它不关注具体的取值是多少,而关注的是取值范围。
     *    当返回值>0时:当前对象比参数对象大
     *    当返回值<0时:当前对象比参数对象小
     *    当返回值=0时:当前对象等于参数对象
    
    Cell类:
    public class Cell implements Comparable<Cell>{//哪个类实现Comparable接口泛型就写哪个类
    private  int x;
    private  int y;
    public Cell(int x, int y) {
    	super();
    	this.x = x;
    	this.y = y;
    }
    /**
     * @return the x
     */
    public int getX() {
    	return x;
    }
    /**
     * @param x the x to set
     */
    public void setX(int x) {
    	this.x = x;
    }
    /**
     * @return the y
     */
    public int getY() {
    	return y;
    }
    /**
     * @param y the y to set
     */
    public void setY(int y) {
    	this.y = y;
    }
    @Override
    public String toString() {
    	return "Cell [x=" + x + ", y=" + y + "]";
    }
    @Override
    public int compareTo(Cell o) {//自定义排序逻辑
    	// TODO Auto-generated method stub
    	return this.x-o.x;//以传入的Cell的横坐标由小到大进行排序
    }
      
    }
    
    
     @Test
        public void testComparable(){
        	/*
        	 * Cell实现了Comparable接口,compareTo方法逻辑为按照x值大小进行排序
        	 */
        	List<Cell> cells = new ArrayList<Cell>();
        	cells.add(new Cell(2,3));
        	cells.add(new Cell(5,1));
        	cells.add(new Cell(3,2));
        	System.out.println(cells);//[Cell [x=2, y=3], Cell [x=5, y=1], Cell [x=3, y=2]]
        	Collections.sort(cells);
        	System.out.println(cells);//[Cell [x=2, y=3], Cell [x=3, y=2], Cell [x=5, y=1]]
        }
    

    我们想使用sort方法排序集合,但是该方法要求我们的集合元素必须实现Comparable接口并且定义比较规则,这种我们想使用某个功能,而它要求我们修改程序的现象称为“侵入性”。修改的代码越多,侵入性比较强,越不利于程序的扩展。
    所以不建议使用这个构造方法。

    三、使用重载的Collections.sort(List,Comparator)方法

     * 重载的sort方法要求传入一个额外的比较器
     * 该方法不再要求集合元素必须实现Comparable接口,
     * 并且也不再使用集合元素自身的比较规则排序了,而是根据给定的这个额外的比较器的比较规则
     * 对集合元素进行排序。
     * 实际开发中也推荐使用这种方式排序集合元素,若集合元素是自定义的,创建比较器时也推荐使用匿名内部类
     * 的形式。
    

    方法一:自定义一个比较器然后传入
    Collections.sort(List,Comparator)中。

    
    测试代码:
    
    自定义的比较器:
    import java.util.Comparator;
    
    public class MyComparator implements Comparator<Cell>{
    	@Override
    	public int compare(Cell o1, Cell o2) {
    		return o1.getY()-o2.getY();//根据传入的cell的y坐标由小到大进行排序
    	}
    }
    测试类:
     @Test
        public void testComparator() {
        	List<Cell> cells = new ArrayList<>();
        	cells.add(new Cell(2,3));
        	cells.add(new Cell(5,1));
        	cells.add(new Cell(3,2));
        	System.out.println(cells);//[Cell [x=2, y=3], Cell [x=5, y=1], Cell [x=3, y=2]]
        	MyComparator com = new MyComparator();
        	Collections.sort(cells,com);
        	System.out.println(cells);//根据自定义排序后的结果:[Cell [x=5, y=1], Cell [x=3, y=2], Cell [x=2, y=3]]
        } 
    
    
    

    方法二:采用匿名内部的形式(推荐做法)

     @Test
        public void testComparator() {
        	List<Cell> cells = new ArrayList<>();
        	cells.add(new Cell(2,3));
        	cells.add(new Cell(5,1));
        	cells.add(new Cell(3,2));
        	System.out.println(cells);//[Cell [x=2, y=3], Cell [x=5, y=1], Cell [x=3, y=2]]
        	Collections.sort(cells,new Comparator<Cell>(){//此处创建了一个匿名内部类
    		@Override
    		public int compare(Cell o1,Cell o2){
    			return o1.getY() - o2.getY();
    		}
    
    	});
        	System.out.println(cells);//[Cell [x=5, y=1], Cell [x=3, y=2], Cell [x=2, y=3]]
        } 
    

    比较总结:

    *1.对于集合比较使用Collections.sort();
    *2.对于集合中的对象比较,需要指定比较逻辑,指定比较逻辑需要实现 Comparable接口并重写compareTo方法自定义逻辑。
    *3.对于需要临时改变比较规则,需要使用Collections.sort(List,Comparator),采用回调方式重写Comparator接口的compare方法自定义逻辑。
    
    展开全文
  • java集合进行排序的两种方式

    万次阅读 2016-09-18 11:41:43
    java集合的工具类Collections中提供了两种排序的方法,分别是: Collections.sort(List list)//自然排序 Collections.sort(List list,Comparator c)//定制排序 第一种称为自然排序,参与排序的对象需实现comparable...
  • 数据集合排序

    2019-01-15 10:47:18
    1、 正常数组排序 1.1自然排序 public static void main(String[] args) { int a[] = new int[]{1,6,3,0,19}; Arrays.sort(a);//默认的从小到大排序 for (int i : a) { System.out.println(i); } } ...
  • 所谓集合排序是指对集合内的元素进行排序。 集合工具类Collections中提供了两种排序算法,分别是: Collections.sort(List list) Collections.sort(List list,Comparator c) Collections.sort(List list)这种方式...
  • 集合排序

    2019-12-19 15:29:28
    1.要求打印集合中最大和最小的元素。 2.要求找出集合中长度最大和长度最小的元素。 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Test01 { public static ...
  • List集合序列排序的两种方法

    万次阅读 多人点赞 2018-06-24 00:37:20
    首先讲一下Comparable接口和...请参考1.Comparable自然规则排序 //在自定义类Student里面实现Comparable接口,并重写抽象方法compareTo(Student o); //Collections.sort(集合); 先看一个简单的例子: public st...
  • 实现集合List中的元素进行排序

    万次阅读 多人点赞 2016-06-14 22:08:32
    Collections对List集合中的数据进行排序 有时候需要对集合中的元素按照一定的规则进行排序,这就需要用到 Java中提供的对集合进行操作的工具类Collections,其中的sort方法 先看一个简单的例子: public static ...
  • java中的各种集合排序

    千次阅读 2019-05-03 01:44:35
    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • 1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • Redis 集合排序

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

    千次阅读 2018-12-13 14:47:04
    一、利用lambda对list集合排序  先定义一个集合 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、升序排序 ...
  • map集合排序

    千次阅读 2019-05-05 20:32:59
    今天做统计时需要对X轴的地区按照地区代码(areaCode)进行排序,由于在构建XMLData使用的map来进行数据统计的,所以在统计过程中就需要对map进行排序。 一、简单介绍Map 在讲解Map排序之前,我们先来稍微了解下...
  • Java集合排序及java集合类详解

    万次阅读 2012-08-20 14:21:53
    Java集合排序及java集合类详解 (Collection, List, Set, Map)   摘要内容 集合是Java里面最常用的,也是最重要的一部分。能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java...
  • 1.定义实体类 public class Commodity { //种类、名称、价格、商家名称、月均销量 private String type; private String name; private double price; private String shopName;... private int sales;...
  • Java—集合排序

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

    千次阅读 2018-12-25 09:18:16
    原文... 目录 1.普通排序 2.使用增强版的Comparator接口 3.使用lamda表达式进行排序 4.多条件排序 1.普通排序 Collections.sort(voList); //逆序 voList.sort(comparing(Apple::ge...
  • 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...

空空如也

1 2 3 4 5 ... 20
收藏数 479,037
精华内容 191,614
关键字:

集合排序