浅谈java Collection中的排序问题

这里讨论list、set、map的排序,包括按照map的value进行排序。

1)list排序

list排序可以直接采用Collections的sort方法,也可以使用Arrays的sort方法,归根结底Collections就是调用Arrays的sort方法。

public static <T> void sort(List<T> list, Comparator<? super T> c) {
  Object[] a = list.toArray();
  Arrays.sort(a, (Comparator)c);
  ListIterator i = list.listIterator();
  for (int j=0; j<a.length; j++) {
    i.next();
    i.set(a[j]);
  }
  }

如果是自定义对象,需要实现Comparable接口使得对象自身就有“比较”的功能,当然我们也可以在外部使用Comparator来规定其排序。

例如:

package com.fox; 

/**
 * @author huangfox
 * @desc
 */
public class User implements Comparable<User> { 

  private String name;
  private int age; 

  public User() {
  } 

  public User(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  } 

  @Override
  public String toString() {
    return "name:" + name + ",age:" + 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;
  } 

  @Override
  public int compareTo(User o) {
    if (o.age < this.age)
      return 1;
    else if (o.age > this.age)
      return -1;
    else
      return 0;
  } 

  /**
   * @param args
   */
  public static void main(String[] args) {
    User u1 = new User("fox", 11);
    User u2 = new User("fox2", 21);
    System.out.println(u2.compareTo(u1));
  } 

}

排序:

// List<User> us = new ArrayList<User>();
    List<User> us = new LinkedList<User>();
    us.add(new User("f5", 12));
    us.add(new User("f2", 22));
    us.add(new User("f3", 2));
    us.add(new User("f4", 14));
    us.add(new User("f5", 32));
    us.add(new User("f4", 12));
    us.add(new User("f7", 17));
    us.add(new User("f8", 52));
    System.out.println(us.toString());
    long bt = System.nanoTime();
    Collections.sort(us, new Comparator<User>() { 

      @Override
      public int compare(User o1, User o2) {
        if (o1.getAge() < o2.getAge())
          return -1;
        else if (o1.getAge() > o2.getAge())
          return 1;
        else
          return o1.getName().compareTo(o2.getName());
      }
    });
    long et = System.nanoTime();
    System.out.println(et - bt);
    System.out.println(us.toString());

当然这里可以直接Collections.sort(us),这里用Comparator对User自身的比较方法compareTo做了一点点优化(对相同年龄的人根据用户名排序,String的排序)。

简单提一下,Arrays的排序采用的是插入排序和归并排序,当数组长度较小时直接插入排序。

2)set排序

set包括HashSet和TreeSet,HashSet是基于HashMap的,TreeSet是基于TreeMap的。

TreeMap是用红黑树实现,天然就具有排序功能,“天然就具有排序功能”是指它拥有升序、降序的迭代器。

那么HashSet怎么排序呢?我们可以将HashSet转成List,然后用List进行排序。

例如:

Set<User> us = new HashSet<User>();
    // Set<User> us = new TreeSet<User>();
    // Set<User> us = new TreeSet<User>(new Comparator<User>() {
    //
    // @Override
    // public int compare(User o1, User o2) {
    // if (o1.getAge() < o2.getAge())
    // return -1;
    // else if (o1.getAge() > o2.getAge())
    // return 1;
    // else
    // return o1.getName().compareTo(o2.getName());
    // }
    // });
    us.add(new User("f5", 12));
    us.add(new User("f2", 22));
    us.add(new User("f3", 2));
    us.add(new User("f4", 14));
    us.add(new User("f5", 32));
    us.add(new User("f4", 12));
    us.add(new User("f7", 17));
    us.add(new User("f8", 52));
    // set -> array
    List<User> list = new ArrayList<User>(us);
    System.out.println(list);
    Collections.sort(list);
    System.out.println(list);

也可以将HashSet转换成数组用Arrays排序。

3)map排序

map包括HashMap和TreeMap,上面已经提过,TreeMap用红黑树实现,天然具有排序功能。

那么HashMap怎么按“key”排序呢?方法很简单,用HashMap来构造一个TreeMap。

Map<String, Integer> us = new HashMap<String, Integer>();
    // Map<String, Integer> us = new TreeMap<String, Integer>();
    us.put("f1", 12);
    us.put("f2", 13);
    us.put("f5", 22);
    us.put("f4", 42);
    us.put("f3", 15);
    us.put("f8", 21);
    us.put("f6", 123);
    us.put("f7", 1);
    us.put("f9", 19);
    System.out.println(us.toString());
    System.out.println(new TreeMap<String, Integer>(us));

怎么按照“value”进行排序?

// 按照value排序
    Set<Entry<String, Integer>> ks = us.entrySet();
    List<Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(
        ks);
    Collections.sort(list, new Comparator<Entry<String, Integer>>() { 

      @Override
      public int compare(Entry<String, Integer> o1,
          Entry<String, Integer> o2) {
        if (o1.getValue() < o2.getValue())
          return -1;
        else if (o1.getValue() > o2.getValue())
          return 1;
        return 0;
      }
    });
    System.out.println(list);

将map的Entry提出成set结构,然后将set转成list,最后按照list进行排序。

以上这篇浅谈java Collection中的排序问题就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

时间: 2016-12-11

浅谈java web中常用对象对应的实例化接口

1. request对象 是javax.servlet.HttpServletRequest接口的实例化 2. response对象 是javax.servlet.HttpServletResponse接口的实例化 3. session 对象 是javax.servlet.HttpSession接口的实例化 4. application对象 是javax.servlet.ServletContext接口的实例化 以上是常用的对象 5. pageContext对象 是javax.servlet.j

浅谈java线程中生产者与消费者的问题

一.概念 生产者与消费者问题是一个金典的多线程协作的问题.生产者负责生产产品,并将产品存放到仓库:消费者从仓库中获取产品并消费.当仓库满时,生产者必须停止生产,直到仓库有位置存放产品:当仓库空时,消费者必须停止消费,直到仓库中有产品. 解决生产者/消费者问题主要用到如下几个技术:1.用线程模拟生产者,在run方法中不断地往仓库中存放产品.2.用线程模拟消费者,在run方法中不断地从仓库中获取产品.3  . 仓库类保存产品,当产品数量为0时,调用wait方法,使得当前消费者线程进入等待状态,当有新

浅谈java继承中是否创建父类对象

1. 调用父类构造方法是真的,但是根本没有创建父类对象,只不过是调用父类构造方法来初始化属性. 如果说调用父类构造方法就等于创建父类对象,那就真的无稽之谈. new指令开辟空间,用于存放对象的各个属/性引用等,反编译字节码你会发现只有一个new指令,所以开辟的是一块空间,一块空间就放一个对象. 然后,子类调用父类的属性,方法啥的,那并不是一个实例化的对象. 在字节码中子类会有个u2类型的父类索引,属于CONSTANT_Class_info类型,通过CONSTANT_Class_info的描述可以

浅谈Java 类中各成分加载顺序和内存中的存放位置

一.什么时候会加载类? 使用到类中的内容时加载:有三种情况 1.创建对象:new StaticCode(); 2.使用类中的静态成员:StaticCode.num=9;  StaticCode.show(); 3.在命令行中运行:java StaticCodeDemo 二.类所有内容加载顺序和内存中的存放位置 利用语句进行分析: 1.Person p=new Person("zhangsan",20); 该句话所做的事情: 1.在栈内存中,开辟main函数的空间,建立main函数的变量

浅谈Java编程中string的理解与运用

一,"=="与equals() 运行以下代码,如何解释其输出结果? public class StringPool { public static void main(String args[]) { String s0="Hello"; String s1="Hello"; String s2="He"+"llo"; System.out.println(s0==s1);//true System.out

浅谈Java继承中的转型及其内存分配

看书的时候被一段代码能凌乱啦,代码是这样的: package 继承; abstract class People { public String tag = "疯狂Java讲义"; //① public String name = "Parent"; String getName(){ return name; } } class Student extends People { //定义一个私有的tag实例变量来隐藏父类的tag实例变量 String tag =

浅谈java面向对象中四种权限

俗话说没有规矩就没有方圆,java作为一门严谨的面向对象的高级编程语言,自然对权限整个重要的问题有严格的控制. Java中,可以通过一些Java关键字,来设置访问控制权限: 主要有 private(私有), package(包访问权限),protected(子类访问权限),public(公共访问权限) 在java里,这些语句都可以修饰类中的成员变量和方法,但是只有public和友好型可以修饰类.举个例子: 接下来就详细解释一下这几种权限的差别(博客最后有表格)按权限由低到高:(高权限有低权限所有

浅谈Java开发中的安全编码问题

1 - 输入校验 编码原则:针对各种语言本身的保留字符,做到数据与代码相分离. 1.1 SQL 注入防范 严重性高,可能性低. (1) 参数校验,拦截非法参数(推荐白名单): public String sanitizeUser(String username) { return Pattern.matches("[A-Za-z0-9_]+", username) ? username : "unauthorized user"; } (2) 使用预编译: Stri

浅谈Java编程中的synthetic关键字

java synthetic关键字.有synthetic标记的field和method是class内部使用的,正常的源代码里不会出现synthetic field.小颖编译工具用的就是jad.所有反编译工具都不能保证完全正确地反编译class.所以你不能要求太多. 下面我给大家介绍一下synthetic 下面的例子是最常见的synthetic field Java代码 class parent { public void foo() { } class inner { inner() { foo