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方法中按照字母的降序排列。