关于List,Map的排序

——List

 

1：继承Comparator接口

import java.util.Collections;

import java.util.Comparator;

import java.util.Vector;

public class ListSort {

    public static void main(String[] args) {

                String[] str={"aa","b","cccc","ddd"};

                Vector v = new Vector();

                for(int i=0;i<str.length;i++)

                {

                    v.add(str[i]);

                }

                Collections.sort(v, new Comp());

                System.out.println(v);

            }

        }

        class Comp implements Comparator {

            public int compare(Object o1, Object o2) {

                int i1 = ((String)o1).length();

                int i2 = ((String)o2).length();

                if (i1 < i2){

                    return -1;

                }

                if (i1 > i2){

                    return 1;

                }

                return 0;

            }

}

 

排序结果为：

[b, aa, ddd, cccc]

 

2：使用Collections.sort方法 

            Collections.sort(v, new Comparator() {

            @Override

            public int compare(Object o1, Object o2) {

                return 0;

            }

        });

问题：如何判断啥时候o1和o2交换位置呢？

 

//查看sort的源码可以看出 return >0时交换位置

 private static void mergeSort(Object[] src,

                                  Object[] dest,

                                  int low, int high, int off,

                                  Comparator c) {

        int length = high - low;

 

        // Insertion sort on smallest arrays

        if (length < INSERTIONSORT_THRESHOLD) {

            for (int i=low; i<high; i++)

                for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)

                    swap(dest, j, j-1);

            return;

        }

 

这样的话可以通过设置的return -1 （1）来判断是否交换位置，从而可以实现降序和升序排序

比如像按年龄进行升序排序，代码入下：

  Collections.sort(person, new Comparator<Person>() {

                @Override

                public int compare(Persono1, Persono2) {

                    return Float.parseFloat(o1.getName()) >  Float.parseFloat(o2.getName) ? 1 : -1;

                }

            });

注意：String、float比较大小

compareTo适用于String的比较

int i = "c".compareTo("ab")  

i = 2;

通过public static <T> void sort(List<T> list, Comparator<? super T> c)可以看出sort()支持List的排序，那么Map如何排序呢？

 

方法：将map放在List中

 

import java.util.*;

public class hashMapSort {

    public static void main(String[] args) {

    Map<String, Integer> map = new HashMap<String, Integer>();

    map.put("d", 2);

    map.put("c", 1);

    map.put("b", 1);

    map.put("a", 3);

    List<Map.Entry<String, Integer>> infoIds =

            new ArrayList<Map.Entry<String, Integer>>(map.entrySet());

        for(Map.Entry<String, Integer> mapEntry : infoIds){

            System.out.println(mapEntry.getValue());

        }

//排序

  Collections.sort(infoIds, new Comparator<Map.Entry<String, Integer>>() {

        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {

           return o1.getValue() > o2.getValue() ? 1 : -1;

        }

    });

//排序后

        for(Map.Entry<String, Integer> mapEntry : infoIds){

            System.out.println(mapEntry.getValue());

        }

    }

}

排序前

2

1

1

3

排序后

1

1

2

3

http://www.importnew.com/20703.html

转载于:https://my.oschina.net/u/2361475/blog/485714