精华内容
参与话题
问答
  • 集合排序

    2018-12-14 10:49:03
    集合排序: Collections.sort(nums); List<Integer> nums = new ArrayList<Integer>(); nums.add(23); nums.add(11); nums.add(45); nums.add(65); //有一行代码...

    集合排序: Collections.sort(nums);

      List<Integer> nums = new ArrayList<Integer>();
            nums.add(23);
            nums.add(11);
            nums.add(45);
            nums.add(65);
            //有一行代码能一下添加好多数,暂时想不起来了
            //Collections.addAll(12,32,43,535);
           // nums.addAll(23,43,53,2,54);
            System.out.println(nums);
            Collections.sort(nums);
            System.out.println(nums);
    

    在这里插入图片描述

    展开全文
  • * 集合排序; * * 首先先看一下关于集合的排序Demo; * * 先创建一个自己的测试类; * @author Administrator * */ public class SortTest { public static void main(String[] args).
    package cn.sort;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    /**
     * 集合排序;
     * 
     * 首先先看一下关于集合的排序Demo;
     * 
     * 先创建一个自己的测试类;
     * @author Administrator
     *
     */
    public class SortTest {
    
    	public static void main(String[] args) {
    		
    		// 实例化一个指定类型存储的List集合;
    		List<String> list = new ArrayList<String>();
    		
    		// 集合数据装载;
    		list.add("aaa");
    		list.add("ccc");
    		list.add("bbb");
    		
    		// 利用Collections工具类的sort()进行升序;
    		Collections.sort(list);
    		
    		// 控制台数据打印;
    		System.out.println(list);
    		
    	}
    	
    }
    
    package cn.sort;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * 
     * 集合对象排序|根据集合中对象的指定属性进行排序;
     * 
     * 下面整理一下关于集合对象的排序规则;
     * 
     * 利用实现Comparator来进行排序;
     * 
     * 首先还是和以往一样,创建一个自己的测试类;
     * @author Administrator
     *
     */
    public class CollectionsSort {
    	
    	/**
    	 * Java主函数|入口;
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		/**
    		 * 实例化一个指定对象存储的List集合;
    		 */
    		List<Student> list = new ArrayList<Student>();
    		
    		// 对象数据装载;
    		Student b = new Student("BBB","Y",32);
    		Student c = new Student("CCC","x",33);
    		Student a = new Student("AAA","Y",31);
    		
    		// 集合数据装载;
    		list.add(a);
    		list.add(b);
    		list.add(c);
    		
    		// 调用排序规则;
    		sortObj(list);
    		
    		//重新打印排序后的集合数据;
    		for(Student people : list) {
    			
    			// 控制台数据打印;
    			System.out.println(people.getAge());
    		}
    	}
    	
    	/**
    	 * 封装排序函数|方法;
    	 * @param list
    	 */
    	public static void sortObj(List<Student> list) {
    		
    		/**
    		 * 自定义排序规则;
    		 * 
    		 * 利用Collections工具类的sort()方法进行重写排序规则;
    		 */
    		Collections.sort(list,  new Comparator<Student>() {
    
    			/**
    			 * 重写排序规则;
    			 * @param a
    			 * @param b
    			 * @return
    			 */
    			@Override
    			public int compare(Student a, Student b) {
    				
    				/**
    				 * 自定义排序规则;
    				 * 
    				 * 如果没有明确具体的排序内容,可以直接进行对象排序;
    				 * Eg: a.compareTo(b);
    				 * 
    				 * 如果有明确的需求说要对某个集合中的对象按照指定属性进行排序,
    				 * 则可以按照以下方式进行自定义排序;
    				 */
    				String one = a.getSex();
    				String two = b.getSex();
    //				return two.compareTo(one);
    				return one.compareTo(two);
    			}
    		});
    	}
    
    }
    
    /**
     * 封装自定义排序规则;
     * 
     * 下面是将排序规则封装进入自己特定的工具类中,
     * 可以根据不同的需求封装不同的函数|方法;
     * @author Administrator
     *
     */
    class sortUtils implements Comparator {
    
    	@Override
    	public int compare(Object o1, Object o2) {
    		String a = (String) o1;
    		String b = (String) o2;
    		return -a.compareTo(b);
    	}
    	
    }
    
    /**
     * 临时创建一个Entity测试类;
     * 
     * @author Administrator
     *
     */
    class Student {
    	
    	// 初始化私有属性;
    	private String name;
    	private String sex;
    	private int age;
    	
    	/**
    	 * 由于申明了有参构造,故而
    	 * 在这里需要重新申明无参构造器;
    	 * 
    	 * 在默认的情况下无参构造器就存在,只是当创建了有参构造器之后便覆盖了无参构造器;
    	 * 所以需要自己重现有参构造器;
    	 */
    	public Student() {}
    
    	/**
    	 * 申明有参构造器;
    	 * 
    	 * 根据指定顺序的构造器进行对象初始化;
    	 * @param name
    	 * @param sex
    	 * @param age
    	 */
    	public Student(String name, String sex, int age) {
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    	
    	/**
    	 * Get/Set;
    	 * @return
    	 */
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    }
    
    
    /**
     * 数据排序.
     * @param platformList
     */
    public static void sortPlatformList(List<BePlatform> platformList) {
      Collections.sort(platformList, new Comparator<BePlatform>() {
        @Override
        public int compare(BePlatform p1, BePlatform p2) {
          return p1.getStartTime().compareTo(p2.getStartTime());
        }
      });
    }

     

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

    一、背景

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

    二、UML的类图

    三、第一种方法

    1.实体类

    public class Person {
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    
      }
    }

    2.测试类

    public class TreeMapTest {
        public static void main(String[] args) {
    
            Map<String, Person> treeMap = new TreeMap<String, Person>(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                   return new Double(o2).compareTo(new Double(o1));
                }
            });
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                treeMap.put(""+i,new Person(""+i,"张三","河南"));
            }
            Iterator it = treeMap.keySet().iterator();
            while (it.hasNext()) {
                //it.next()得到的是key,treeMap.get(key)得到obj
                System.out.println(treeMap.get(it.next()));
            }
        }
    }
    

    3.结果(降序)

    Person{id='11', name='张三', address='河南'}
    Person{id='10', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='1', name='张三', address='河南'}
    

    四、总结

    1.compareTo(String str) :是String 提供的一个方法,如果参数字符串等于此字符串, 则返回 0 值;如果按字典顺序此字符串小于字符串参数,则返回一个小于 0 的值;如果按字典顺序此字符串大于字符串参数,则返回一个大于 0 的值。
       int compare(T o1,T o2):随第一个参数小于、等于或大于第二个参数而分别返回负整数、零或正整数。

    2.compareTo就是比较两个值,如果前者大于后者,返回1,等于返回0,小于返回-1,我下面给出了例子,由于比较的变量我用的是int,int型可以直接比较,所有没有用到compareTo比较,如果声明的是Date、String、Integer或者其他的,也可以直接使用compareTo比较,比如以下函数代码用法:

    public int compareTo(TestModel1 o) {

    return this.str1.compareTo(o.str1);

    }

    五、结束

    Always keep the faith!!!

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

    一、背景

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

    二、Set集合排序

    1.UML类图

    三、注意点

    1.我们先来说下集合的各个特点:

    2.List的主要特点以及用法

    2.1.可以允许存储重复的对象.

    2.2.可以插入多个null元素.

    2.3.是一个有序容器,保持了每一个元素的插入顺序,插入的顺序即输出的顺序.

    2.5.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行,它提供了使用索引的随意访问,而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适.

    3.Set集合的主要特点及用法

    3.1 不允许重复对象 
    3.2 只允许一个 null 元素 
    3.3 无序容器,你无法保证每个元素的存储顺序,TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序 
    3.4 Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet;TreeSet 还实现了 SortedSet 接口,因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器

    4.Map集合的主要特点及用法 
    4.1 Map不是collection的子接口或者实现类。Map是一个接口。而List和Set是collection的子接口 
    4.2 Map 的 每个 Entry 都持有两个对象,也就是一个键一个值,Map 可能会持有相同的值对象但键对象必须是唯一的,这是双列集合的特点 
    4.3 TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序 
    4.4 Map 里你可以拥有随意个 null 值但最多只能有一个 null 键 
    4.5 Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。(其中HashMap、TreeMap最常用)

    5. 区别 
    5.1、Collection 和 Map 的区别 
    容器内每个为之所存储的元素个数不同。 
    Collection类型者,每个位置只有一个元素。 
    Map类型者,持有 key-value pair,像个小型数据库。

    5.2、各自旗下的子类关系 
    Collection 
    –List:将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。 
    –ArrayList / LinkedList / Vector 
    –Set : 不能含有重复的元素 
    –HashSet / TreeSet 
    Map 
    –HashMap 
    –HashTable 
    –TreeMap

    四、第一种做法(排序)

    1.实体类

    public class Person{
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

    2.测试类

    public class TreeSetTest {
        public static void main(String[] args) {
    
            Set<Person> set = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return new Double(o1.getId()).compareTo(new Double(o2.getId()));//升序排列
                }
            });
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                set.add(new Person(""+i,"张三","河南"));
            }
            for(Object o : set){
                System.out.println(o);
            }
        }
    }
    

    3.结果(升序)

    Person{id='1', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='10', name='张三', address='河南'}
    Person{id='11', name='张三', address='河南'}

    4.如果要倒序(改动一下面这个就行了)

    Set<Person> set = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return new Double(o2.getId()).compareTo(new Double(o1.getId()));//降序排列
                }
            });

    五、第二种做法

    1.实体类

    public class Person implements Comparable<Person> {
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    
        @Override
        public int compareTo(Person o) {
            if (o instanceof Person) {
                Person o1 = (Person) o;
                return new Double(o1.getId()).compareTo(new Double(this.getId()));
            }
            throw new ClassCastException("不能转换为Person类型的对象...");
        }
    }

    2.测试类

    public class TreeSetTest {
        public static void main(String[] args) {
    
            Set<Person> set = new TreeSet<Person>();
    
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                set.add(new Person(""+i,"张三","河南"));
            }
            for(Object o : set){
                System.out.println(o);
            }
        }
    }

     3.结果(倒列),正序需调换下实体类中的比较对象的位置

    Person{id='10', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='1', name='张三', address='河南'}

    六、结束

    上面是对set集合中的TreeSet排序进行的总结。

    Always keep the faith!!!

    展开全文
  • List集合排序

    2019-05-20 19:08:51
    需求:对一个集合排序,集合中存放的是自定义对象。按照自定义对象的2个属性排序【小–>大】【大–>小】 1、List中是基本数据类型or包装数据类型 public static void main(String[] args) { List<...
  • 1.倒序排列 list.stream().sorted(Comparator.comparing(list::getAbc).reversed()).collect(Collectors.toList()); 2.正序排列 list.stream().sorted(Comparator.comparing(list::getAbc)).collect(Collectors.to...
  • map集合排序

    千次阅读 2019-05-05 20:32:59
    今天做统计时需要对X轴的地区按照地区代码(areaCode)进行排序,由于在构建XMLData使用的map来进行数据统计的,所以在统计过程中就需要对map进行排序。...map是键值对的集合接口,它的实现类主要包...
  • 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...
  • scala集合排序

    千次阅读 2017-08-01 09:24:32
     你想要对一个集合元素进行排序。或者你想定义一个自定义类来实现Ordered trait,来让你可以使用sorted方法,或者使用比较操符,>=来对类的实例进行比较。 Solution  你可以使用sorted或者sortWith方法来对集合...
  • List集合排序之Java8stream流排序

    千次阅读 2020-07-24 16:10:51
    1.新建测试JavaBean User.java @Data public class User { ...2.:stream流根据年龄正序排序 resultList = resultList.stream().sorted(Comparator.comparing(User::getAge)) .collect(Collectors.toList()); 3:
  • 在有些场景可能会需要通过程序对集合中的元素进行排序,本文总结一下List集合排序可以通过哪些方式来实现 1.使用集合的工具类Collections对ArrayList集合进行排序 简单的整数型排序: 当集合的范型为Integer类型...
  • java集合排序

    2018-12-20 05:12:46
    List集合排序 2 将三个人的姓名年龄set进Person类中并添加到list集合里,运行一下,看控制台打印结果 List集合排序 3 我们可以看到控制台输出的结果是按照我们set进去的顺序是一样到 List集合排序 4 使用冒泡排序将...
  • public class Student { public string First { get; set; } public string Last { get;...可以排序,如果被排序的字段是个变量,应该怎么写呢? 如 string field="First"; GetStudents().OrderBy(u => u.?)
  • android集合排序

    2018-11-09 11:52:02
    import android.os.Bundle; import android.support.annotation.Nullable; import android.support.v7.app.AppCompatActivity; import java.util.ArrayList; import java.util.Collections;...import java.util.L...
  • Java排序之集合排序

    2016-10-10 15:29:56
    集合排序 要么让集合的对象具有比较性也就是让集合中的对象实现Comparable接口 自定义比较器实现Comparator 举例:按人的年龄排序代码如下 - UserBean对象/** * Created by yuandl on 2016-10-10. */ public ...
  • js 对集合排序 , 冒泡排序 sort排序

    千次阅读 2019-02-12 19:12:57
    var listDoctorTime= [ { "id": 1, "name": "张三", "index": "100" }, { "id": 2, "name": "李四", "index": 120 }, { "id": 3, "name": "王武", "index": 80 }, { "id": 4, "name":...
  • Android数字集合排序

    2019-08-18 11:58:08
    Android数字集合排序 遇到了记一下 List<Long> sortedKeys = new ArrayList<>(); sortedKeys.add((long) 2); sortedKeys.add((long) 1); sortedKeys.add((long) 4); sortedKeys.add((long) 3); ...
  • JAVA 集合排序

    2018-07-06 16:17:24
    //集合排序, List arrayList = new ArrayList(enterpriseEntityList1); Collections.sort(arrayList, new Comparator&lt;EnterpriseEntity&gt;() { @Override public int compare(EnterpriseEntity o1, E...
  • compareTO集合排序方法

    2019-06-18 19:41:35
    /前提:元素类实现了comparable接口,此接口强制对它的类每个对象进行排序/ 对象所在类方法代码 public int compareTo(Object obj){ //将该对象向下转型 Eg618_4_demo num=(Eg618_4_demo)obj; //学号相等两者相等 if...
  • 可以利用Collections工具类中的sort方法,可以对数字、字母、对象进行排序。 通过Comparable接口进行排序: (1)普通数字、字母排序(Integer、String类均已经实现了compareTo()方法): Integer类源码: public...
  • map的内部结构是红黑数,所以STL中map默认是按key排序的。 初始化 map&lt;k, v&gt; map; // 定义了一个名为map的空的map对象; map&lt;k, v&gt; map(m2); // 创建了m2的副本map; map&lt;k, ...
  • List集合排序 1、集合工具类(包装类)Collections.sort 使用Collections提供的sort方法,对集合进行排序 Collections.sort(list); 实现原理: 将list转成了数组对象后,调用了Array的sort方法,将数组排序,再用...
  • Set集合排序

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

    千次阅读 2019-09-03 23:20:51
    存入数据代码 /* redisTemplate.opsForZSet().add(Kkey,Vvalue, doublescore);*/ String redisKey = "yourKey"; Long itemId = 100; Long itemId = 101; // 存放数据 redisTemplate.opsForZSet().add(redisKe....
  • Android数据排序之集合排序

    千次阅读 2018-01-19 16:28:39
    最近在写项目时遇到这样一个问题,后台接口返回的一个审批流程List集合中的数据顺序是乱序的,但是为了和PC前端在显示上保持一致,所以只能自己排序。一般这种情况都是可以根据集合中对应实体对象中的某一个属性去...

空空如也

1 2 3 4 5 ... 20
收藏数 29,363
精华内容 11,745
关键字:

集合排序