jdk集合常用方法分析之HashSet和TreeSet

HashSet常用方法介绍

public boolean add(E e)

public boolean isEmpty()

void clear()

public Iterator<E> iterator()

int size()

详细方法详见JDK帮助文档

 

Object的equals方法和hashCode方法

1、 Object类equals方法的特点:

　　a) 自反性：x.equals(x)应该返回true

　　b) 对称性：x.equels(y)为true，那么y.equals(x)也为true

　　c) 传递性：x.equels(y)为true并且y.equels(z)为true，那么x.equels(z)也应该为true

　　d) 一致性：x.equels(y)的第一次调用为true，那么x.equels(y)的第二次、第三次、第n次调用也应该为true，前提条件是在比较之间没有修改x也没有修改y

　　e) 对于非空引用x，x.equels(null)返回false

2、 Object类hashCode方法的特点：

　　a) 在java应用的一次执行过程中，对于同一个对象的hashCode方法的多次调用，他们应该返回同样的值(前提是该对象的信息没有发生变化)；

　　b) 对于两个对象来说，如果使用equals方法比较返回true，那么这两个对象的hashCode值一定是相同的；

　　c) 对于两个对象来说，如果使用equals方法比较返回false，那么这两个对象的hashCode值不要求一定不同(可以相同，也可以不同)，但是如果不同则可以提高应用的性能；

　　d) 对于Object类来说，不同Object对象的hashCode的值是不同的(Object类的hashCode值表示的是对象的地址)；Object的toString()方法默认调用的是：

getClass().getName() + '@' + Integer.toHexString(hashCode())

3、 如果我们重写equals方法，那么也要重写hashCode方法，反之亦然；

 

HashSet常用方法源码分析

构造方法

public HashSet() {

    map = new HashMap<E,Object>();

}



private transient HashMap<E,Object> map;

add()

public boolean add(E e) {

    return map.put(e, PRESENT)==null;

}



private static final Object PRESENT = new Object(); //同一个set中的PRESENT对象一致

remove()

public boolean remove(Object o) {

    return map.remove(o)==PRESENT;

}

size()

public int size() {

    return map.size();

}

iterator ()

public Iterator<E> iterator() {

    return map.keySet().iterator();

}

常用方法源码分析总结：

1、 set可以添加null；

2、 在使用HashSet时，hashCode()方法会得到调用，判断已经存储在集合中的对象的hashCode值是否与添加的对象的hashCode值一致，如果不一致，直接添加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经添加进去了，就不会再添加新的对象，否则就加进去；

3、 HashSet底层是使用HashMap实现的，当调用add方法将对象添加到Set中时，实际上是将该对象作为底层所维护的Map对象的key,而value则都是同一个Object对象(该对象我们用不上)。在HashMap中，同一个key，后添加的value会覆盖前一个value；

4、 当重写equals方法的时候必须要重写hashCode方法，如果一个类的两个对象的equals方法比较结果为true，那么该两个对象必须具有相同的hashCode值。

 

HashSet示例分析

示例1：添加两个相同的对象

public class HashSetDemo03 {

    public static void main(String[] args) {

        HashSet set = new HashSet();

        People p1 = new People("zhangsan");// p1存放的是zhangsan的引用地址



        set.add(p1);

        set.add(p1);

        System.err.println(set);

    }

}



public class People {

    String name;

    public People(String name) {

        this.name = name;

    }

    public String toString() {

        return this.name;

    }

}

分析：当往set中添加Person对象的时候，先添加进去p1，在第二次还是添加p1的时候，会先调用hashCode方法(同一对象的hashCode值当然相同)，再去判断equals()方法，同一对象的equals()方法肯定是true的，所以加不进去。

 

示例2：添加两个相同的字符串

public class HashSetDemo04 {

    public static void main(String[] args) {

        HashSet set = new HashSet();

        String s1 = new String("a");

        String s2 = new String("a");

        set.add(s1);

        set.add(s2);

        System.out.println(set);

    }

}

分析：当往set中添加是s1的时候，先添加进去s1，在第二次还是添加s1的时候，会先调用hashCode方法，String对象已经重写了hashCode()方法(根据给定的字符串用一个公式运算)，hashCode值是相同的，再去判断equals()方法，String的equals()方法比较的是字符串的内容，所以equals()为true，所以加不进去。

 

示例3：重写equals和hashcode后对比

public class HashSetDemo05 {

    public static void main(String[] args) {

        HashSet set = new HashSet();

        Student s1 = new Student("zhangsan");

        Student s2 = new Student("zhangsan");

        set.add(s1);

        set.add(s2);

        System.out.println(set);

    }

}

public class Student {

    String name;

    public Student(String name) {

        this.name = name;

    }

    public String toString() {

        return name;

    }

}

分析：

未重写equals和hashcode方法之前：s1和s2是不同的两个对象，由于hashCode存放的是引用的地址，所以他们是不同的，就直接加进去了。

重写equals()和hashCode()方法之后，hashCode就按照name进行取值，所以他们的hashCode相等，然后比较equals()方法，而我们自己也按照name重写了equals()方法。所以equals为true，就不会加进去。

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + ((name == null) ? 0 : name.hashCode());

        return result;

    }



    @Override

    public boolean equals(Object obj) {

        if (this == obj)

            return true;

        if (obj == null)

            return false;

        if (getClass() != obj.getClass())

            return false;

        Student other = (Student) obj;

        if (name == null) {

            if (other.name != null)

                return false;

        } else if (!name.equals(other.name))

            return false;

        return true;

    }

 

 

示例3：HashSet常用迭代方法

public class HashSetDemo06 {

    public static void main(String[] args) {

        HashSet set = new HashSet();

        set.add("a");

        set.add("b");

        set.add("c");

        set.add("d");

        set.add("e");

        

        Iterator iter = set.iterator(); while (iter.hasNext()) {

            String value = (String) iter.next();

            System.out.println(value);

        }

        

        System.out.println("--------------");

    

        for (Iterator iterator = set.iterator(); iterator.hasNext();) {

            String s = (String) iterator.next();

            System.out.println(s);

        }

    }

}

 

TreeSet

HashSet是在输出的时候是没有顺序的，而TreeSet是能够按照指定的顺序进行输出的。

TreeSet的构造方法

public TreeSet(Comparator<? super E> comparator)

在构造方法中需要我们事先自定义好一个实现Comparator接口的方法，并重写它的int compare(T o1,T o2)方法。

如何定义自己的Comparator

public class TreeSetDemo02 {

    public static void main(String[] args) {

        TreeSet<Order> set = new TreeSet<Order>(new OrderComparator());

        set.add(new Order(10));

        set.add(new Order(20));

        set.add(new Order(30));

        set.add(new Order(40));



        for (Order order : set) {

            System.out.println(order);

        }

    }

}



class OrderComparator implements Comparator<Order> {

    @Override

    public int compare(Order o1, Order o2) {

        return -(o1.count - o2.count);

    }

}



class Order {

    int count;

    public Order(int count) {

        this.count = count;

    }

    public String toString() {

        return String.valueOf(count);

    }

}

我们可以在OrderComparator类中的compare方法中按照自己的意愿进行重写以实现升序或者降序排列。

public class TreeSetDemo03 {

    public static void main(String[] args) {

        TreeSet set = new TreeSet(new MyComparator());

        set.add("A");

        set.add("F");

        set.add("E");

        set.add("D");

        set.add("a");

        set.add("C");

        set.add("B");

        for (Iterator iterator = set.iterator(); iterator.hasNext();) {

            String s = (String) iterator.next();

            System.out.println(s);

        }

    }

}



class MyComparator implements Comparator {

    public int compare(Object o1, Object o2) {

        String s1 = (String) o1;

        String s2 = (String) o2;

        return -s1.compareTo(s2);

    }

}

我们可以在MyComparator类中的compare方法中按照字母的降序排列。