【转】SortedSet实现过滤重复字符串并排序

 参考了：http://www.lurenjia.net/article.asp?id=233 和 http://csourcesearch.net/java/fidAB55053EB2EBD58B30F9B28C706AAF40861E637C.aspx?s=mdef%3Ainsert

一个同事在项目过程中要实现过滤字符串并排序的功能，比如输入：

111-1111
131-1111
111-1111
131-1111
121-1221
111-1111
111-1111
输出：
111-1111
121-1221
131-1111

我想过滤重复的话，可以用Set，因为集合是不允许重复元素的，至于排序，Collections的sort方法可以实现List的排序，以下由方法二实现，其中removeIterance用来过滤重复元素，sortStringList用来排序。

后 来在查Java Collection API的时候，看到有个SortedSet的接口可以一步实现两个功能，以下由方法一实现，但是TreeSet 是非同步的，应该使用 Collections.synchronizedSet方法进行“包装”。此操作最好在创建时进行，以防止对 set 的意外非同步访问，即：
SortedSet set = Collections.synchronizedSortedSet(new TreeSet(…))；

实现代码：

程序代码

Code
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Comparator;
import java.io.*;

public class SortStringList {

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("111-1111");
        list.add("131-1111");
        list.add("111-1111");
        list.add("131-1111");
        list.add("121-1221");
        list.add("111-1111");
        list.add("111-1111");

        SortStringList sortList = new SortStringList();

        // 方法一：使用SortedSet一步实现去除重复并排序
        // Object[] result = sortList.removeIteranceAndSortIt(list).toArray();

        // 方法二：使用HashSet先去除重复，然后再排序
        Object[] result = sortList.SortStringList(sortList.removeIterance(list)).toArray();

        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }

    private List removeIterance(List<String> list) {
        ArrayList<String> result = new ArrayList<String>();
        if (list != null && list.size() > 0) {
            HashSet set = new HashSet();
            set.addAll(list);
            result.addAll(set);
        }
        return result;
    }

    private List SortStringList(List list) {
        Collections.sort(list, new StringComparator());
        return list;
    }

    private List removeIteranceAndSortList(List list) {
        ArrayList result = new ArrayList();
        if (list != null && list.size() > 0) {
            SortedSet set = Collections.synchronizedSortedSet(new TreeSet(new StringComparator()));
            set.addAll(list);
            result.addAll(set);
        }
        return result;
    }
}
class StringComparator implements Comparator, Serializable {

      /**
       * Creates an instance of StringComparator
       */
      public StringComparator() {}

      /**
       * Compares two HeapNode objects.
       *
       * @param o1  Must be an instance of String
       * @param o2  Must be an instance of String
       */
      public int compare(Object o1, Object o2) {
        String  s1 = (String) o1;
        String  s2 = (String) o2;
        
        if (s1 == null && s2 == null) {
            return 0;
        } else if (s1 == null) {
            return -1;
        } else if (s2 == null) {
            return 1;
        } else {
            return s1.compareTo(s2);
        }
      }

      public boolean equals(Object obj) {
        return obj.equals( this );
      }
}

 

转载于:https://www.cnblogs.com/fzzl/archive/2009/04/01/1427344.html