HashSet和TreeSet

Set接口
Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。
Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不 会接受这两个对象。

HashSet
HashSet有以下特点
 不能保证元素的排列顺序，顺序有可能发生变化
 不是同步的
 集合元素可以是null,但只能放入一个null
当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相 等
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 = "4873279";
        String s2 = "8884567";
        String s3 = "4873279";
        String s4 = "4873279";
        String s5 = "4873279";
        String s6 = "1023279";
        Set<String> strs = new HashSet<String>();
        strs.add(s1);
        strs.add(s2);
        strs.add(s3);
        strs.add(s4);
        strs.add(s5);
        strs.add(s6);
        System.out.println(strs.size());
        for(String str:strs){
            System.out.println(str);
        }
        
        
    }

}

结果：

3
1023279
8884567
4873279

TreeSet类
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1 = "4873279";
        String s2 = "8884567";
        String s3 = "4873279";
        String s4 = "4873279";
        String s5 = "4873279";
        String s6 = "1023279";
        Set<String> strs = new TreeSet<String>();
        strs.add(s1);
        strs.add(s2);
        strs.add(s3);
        strs.add(s4);
        strs.add(s5);
        strs.add(s6);
        System.out.println(strs.size());
        for(String str:strs){
            System.out.println(str);
        }
        
        
    }

}

结果：

3
1023279
4873279
8884567

TreeSet排序的问题：

默认排序：

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;


public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        String s1 = "7";
        String s2 = "8884567";
        String s3 = "4873279";
        String s4 = "4873279";
        String s5 = "4873279";
        String s6 = "1023279";
        String s7 = "988456";
    
        Set<String> strs = new TreeSet<String>();/*(new Comparator<Object>() {        
            @Override
            public int compare(Object o1, Object o2) {
                if(Long.parseLong(o1.toString()) > Long.parseLong(o2.toString())){
                    return 1;
                }else if(Long.parseLong(o1.toString()) < Long.parseLong(o2.toString())){
                    return -1;
                }else{
                    return 0;
                }
                
            }
        });*/
        
        strs.add(s1);
        strs.add(s2);
        strs.add(s3);
        strs.add(s4);
        strs.add(s5);
        strs.add(s6);
        strs.add(s7);
        System.out.println(strs.size());
        Iterator<String> iterator1 = strs.iterator();
        while(iterator1.hasNext()){
            String str = iterator1.next();        
            System.out.println(str);
        }
        System.out.println("");
        Iterator<String> iterator2 = strs.iterator();
        while(iterator2.hasNext()){
            String str = iterator2.next();    
            System.out.println(str);
        }



    }
    

    public static String toNormalNO(String s) {
        
        String result = s;
        // 先去掉-和空格
        result = s.replace("-", "");
        result = result.replaceAll("\s+", "");
        // 再把字母换成数字
        String reg1 = "[abcABC]";// 映射2
        String reg2 = "[defDEF]";// 映射3
        String reg3 = "[ghiGHI]";// 映射4
        String reg4 = "[jklJKL]";// 映射5
        String reg5 = "[mnoMNO]";// 映射6
        String reg6 = "[pqrsPQRS]";// 映射7
        String reg7 = "[tuvTUV]";// 映射8
        String reg8 = "[wxyzWXYZ]";// 映射9

        String ss = result;
        result = ss.replaceAll(reg1, "2").replaceAll(reg2, "3")
                .replaceAll(reg3, "4").replaceAll(reg4, "5")
                .replaceAll(reg5, "6").replaceAll(reg6, "7")
                .replaceAll(reg7, "8").replaceAll(reg8, "9");


        String sss = result;
    
        result = sss.replaceAll("^0+", "");
        if(result.length()>12){
            return "";
        }
        return result;

    }

}



/*
public class Main {

    *//**
     * @param args
     *//*
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s = "0003adaF";
        
         * Pattern pattern = Pattern.compile("[0]*"); Matcher m =
         * pattern.matcher(s); if(m.matches()){ System.out.println(true); }
         
        // String newStr = str.replaceAll("^(0+)", "");
        if (s.matches("^0+.*")) {
            String newStr = s.replaceAll("^0+", "");
            newStr += "
";
            newStr += "abc";
            newStr += "
";
            newStr += "def";


            String[] strs = newStr.split("
");

            System.out.println(true);
            System.out.println(newStr);
            for (String str : strs)
                System.out.println(str);

            Pattern p = Pattern.compile("abc");
            Matcher m = p.matcher(newStr);
            String last = null;
            while (m.find()) {
                last = newStr.replaceAll(m.group(), "");
                System.out.println(m.group());
            }
            
            System.out.println(last);
        }
    }

}*/

结果：

1023279
4873279
7
8884567
988456

默认采用的就是字符串的排序，从小到大。

    Set<String> strs = new TreeSet<String>(new Comparator<Object>() {        
                @Override
                public int compare(Object o1, Object o2) {
                    if(Long.parseLong(o1.toString()) > Long.parseLong(o2.toString())){
                        return 1;
                    }else if(Long.parseLong(o1.toString()) < Long.parseLong(o2.toString())){
                        return -1;
                    }else{
                        return 0;
                    }
                    
                }
            });

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;


public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        String s1 = "7";
        String s2 = "8884567";
        String s3 = "4873279";
        String s4 = "4873279";
        String s5 = "4873279";
        String s6 = "1023279";
        String s7 = "988456";
    
        Set<String> strs = new TreeSet<String>(new Comparator<Object>() {        
            @Override
            public int compare(Object o1, Object o2) {
                if(Long.parseLong(o1.toString()) > Long.parseLong(o2.toString())){
                    return 1;
                }else if(Long.parseLong(o1.toString()) < Long.parseLong(o2.toString())){
                    return -1;
                }else{
                    return 0;
                }
                
            }
        });
        
        strs.add(s1);
        strs.add(s2);
        strs.add(s3);
        strs.add(s4);
        strs.add(s5);
        strs.add(s6);
        strs.add(s7);
        System.out.println(strs.size());
        Iterator<String> iterator1 = strs.iterator();
        while(iterator1.hasNext()){
            String str = iterator1.next();        
            System.out.println(str);
        }
        System.out.println("");
        Iterator<String> iterator2 = strs.iterator();
        while(iterator2.hasNext()){
            String str = iterator2.next();    
            System.out.println(str);
        }



    }
｝    

结果：

7
988456
1023279
4873279
8884567

比较部分针对具体类型更好的写法：

    Set<String> strs = new TreeSet<String>(new Comparator<String>() {        
            @Override
            public int compare(String o1, String o2) {
                if(Long.parseLong(o1) > Long.parseLong(o2)){
                    return 1;
                }else if(Long.parseLong(o1) < Long.parseLong(o2)){
                    return -1;
                }else{
                    return 0;
                }
                
            }
        });