set集合：Hashset
1、HashSet底层实际上是一个HashMap，HashMap底层采用了哈希表数据结构
2、哈希表又叫散列表，哈希表底层是一个数组，这个数组中的每一个元素是一个单
向链表，每一个单项链表都有一个独一无二的hash值，代表数组下表。某个单向链表
中的每个元素节点上的hash值都是相等的，hash值实际上是key调用hashCode方
法，在通过"hash function"转换成的值。
3、如果向哈希表中添加元素，先调用被存储的key的hashCode方法，经过某个算法
得出hash值，这个哈希表中不存在hash值则直接加入元素，如果hash值已经存在，
继续调用key之间的eqyals方法
如果equals方法返回false，则将该方法添加
如果equals方法返回true，则放弃添加该元素
4、HashSet其实是HashMap中的key部分。HashSet有什么特点，hashMap中的key
应该具有什么特点
5、HashMap和HashSet初始化都是16，默认加载因子0.75
class Test {
public static void main(String[] args){
// 创建set集合
Set s = new HashSet();
// 无序不重复
s.add(1);
s.add(1);
s.add(2);
s.add(5);
java.util.Iterator it = s.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
Set存储：
关于向Set集合中存储的元素，该元素的hashCode和equals方法， HashMap中有一
个put方法，put(key,value) key是无序不可重复的。
结论：存储在HashSet集合或HashMap集合key部分的元素，需要同时重写hashCode
- equals， hashCode方法相同时才会调用equals。
举个栗子：
class Test {
public static void main(String[] args){
// 创建集合
Set es = new HashSet();
Employee1 e1 = new Employee1("1000","Jack");
Employee1 e2 = new Employee1("1000","Jack"); // 重复了 输出还是6
Employee1 e3 = new Employee1("1002","SCOTT");
Employee1 e4 = new Employee1("1003","SUN");
Employee1 e5 = new Employee1("1004","JIM");
Employee1 e6 = new Employee1("1005","COOK");
//添加元素
es.add(e1);
es.add(e2);
es.add(e3);
es.add(e4);
es.add(e5);
es.add(e6);
System.out.println(es.size());
}
}
// 该公司员工编号是：1000 - 9999
class Employee1{
String no;
String name;
Employee1(String no,String name){
this.no = no;
this.name = name;
}
// 重写equals方法
// 如果员工标号相同，并且名字相同，则是同一个对象
public boolean equals(Object o) {
if(this == o) {
return true;
}
if(o instanceof Employee1) {
Employee1 e = (Employee1)o;
if(e.name.equals(this.name) && e.no.equals(this.no)){
return true;
}
}
return false;
}
// 重写hashCode方法
public int hashCode() { // 返回key
// 以员工编号分组
return no.hashCode();
}
}
输出：
不重写hashcode和equals方法时输出为：6
重写hashcode和equals方法时输出为：5
SortedSet TreeSet
SortedSet集合存储元素为什么可以自动排序?
因为被存储的元素实现了Comparable接口，SUN编写TreeSet集合在添加元素的时
候，会调用comoareTo方法，完成比较。
举个栗子：
class Test {
public static void main(String[] args){
// 创建集合
SortedSet users = new TreeSet();
User u1 = new User(7);
User u2 = new User(2);
User u3 = new User(6);
User u4 = new User(4);
User u5 = new User(5);
users.add(u1);
users.add(u2);
users.add(u3);
users.add(u4);
users.add(u5);
java.util.Iterator it = users.iterator();
while(it.hasNext()) {
Object element = it.next();
System.out.println(element); // java.lang.Error: Unresolved compilation problem:
}
}
}
class User implements Comparable{
int age;
User(int age){
this.age = age;
}
public String toString() {
return "User[age = " + age + "]";
}
@Override
// 实现java.lang.Comparable;接口中的compareTo方法
// 该方法程序员负责实现，SUN提供的程序已经调用了该方法
// 需求：按照User的age排序
public int compareTo(Object o) {
// TODO Auto-generated method stub
int age1 = this.age;
int age2 = ((User)o).age;
return age1 - age2; // > 0 < 0 = 0
}
}
单独编写一个比较器
让SortedSet集合做到排序还需要另一种方式：java.util.comparator;
举个栗子：
class Test {
public static void main(String[] args){
// 创建TreeSet集合的时候提供一个比较器
SortedSet products = new TreeSet(new ProdeuctComparator());
Product p1 = new Product(2.1);
Product p2 = new Product(2);
Product p3 = new Product(4);
Product p4 = new Product(3.6);
Product p5 = new Product(7);
products.add(p1);
products.add(p2);
products.add(p3);
products.add(p4);
products.add(p5);
java.util.Iterator it = products.iterator();
while(it.hasNext()) {
Object element = it.next();
System.out.println(element); // java.lang.Error: Unresolved compilation problem:
}
}
}
class Product{
double price;
Product(double price){
this.price = price;
}
public String toString() {
return price + "";
}
}
// 单独写的比较器（优先使用）
class ProdeuctComparator implements Comparator{
@Override
// 需求：按照商品价格排序
public int compare(Object o1, Object o2) {
// TODO Auto-generated method stub
double price1 = ((Product)o1).price;
double price2 = ((Product)o2).price;
if(price1 == price2) {
return 0;
}else if(price1 > price2) {
return -1;
}else {
return 1;
}
}
}
