Set集合 哈希表 Hash表 SortedSet Comparator 单独编写一个比较器

无序，不可重复

哈希表（数组和单向链表的结合，本质是一个数组，只不过这个数组中每一个元素又是单向链表），散列表的数据结构

HashMap中有一个方法，Object get(Object key)

 

Hashset底层实际上是一个HashMap，HashMap底层采用了哈希表数据结构

哈希表是一个数组，这个数组中每一个元素是一个单向链表，每个单向链表都有独一无二的hash值，代表数组的下标

每一个节点上的hash值是相等的。

Hash值实际上是Key调用HashCode方法，再通过hash function转换成的值

HashSet是HashMap中的key部分。

HashMap和HashSet初始化容量都是16，默认加载因子是0.75

//Hashset底层实际上是一个HashMap
	 public static void main(String[] args) {
		Set s = new HashSet();
		
		s.add(1);
		s.add(1);
		s.add(100);
		s.add(89);
		
		Iterator it  = s.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
			}
		}

关于往Set中存储的元素，该元素的hashCode和equals方法

存储在HashSet或HashMap -Key部分的元素要重写hashCode方法和equals方法

public static void main(String[] args) {
		Set s = new HashSet();
		E e = new E("aaa", "000");
		E e1 = new E("aaa", "001");
		E e2 = new E("ccc", "002");
		E e3 = new E("ddd", "004");

		s.add(e);
		s.add(e1);
		s.add(e2);
		s.add(e3);
		System.out.println(s.size());// 4

	}
}

class E {
	String name;
	String no;

	public E(String name, String no) {
		super();
		this.name = name;
		this.no = no;
	}

	// 重写equals方法
	public boolean equals(Object o) {
		if (this == o) {
			return true;
		}
		if (o instanceof E) {
			E e = (E) o;
			if (e.no.equals(no) && e.name.equals(name)) {
				return true;
			}
		}
		return false;
	}

	// 重写HashCode方法
	public int hashCode() {
		return no.hashCode(); // 返回值 根据情况而定
	}
}

SortedSet(无序不可重复 但是可以自动排列)

 

public static void main(String[] args) throws ParseException {
		SortedSet ss = new TreeSet();
		ss.add(2);
		ss.add(1);
		ss.add(3);
		ss.add(4);
		ss.add(6);
		Iterator it  = ss.iterator();
		while (it.hasNext()) {
			Object element = it.next();
			System.out.println(element);
		}
		//String 
		SortedSet str = new TreeSet();
		str.add("a");
		str.add("de");
		str.add("w");
		str.add("sw");
		it  = str.iterator();
		while (it.hasNext()) {
			Object element1 = it.next();
			System.out.println(element1);
		}
		//Date
		String time1 ="2008-08-08";
		String time2 ="2009-08-08";
		String time3 ="2010-08-08";
		String time4 ="2011-08-08";
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date t1 = sdf.parse(time1);
		Date t2 = sdf.parse(time2);
		Date t3 = sdf.parse(time3);
		Date t4 = sdf.parse(time4);
		
		SortedSet times = new TreeSet();
		times.add(t1);
		times.add(t2);
		times.add(t3);
		times.add(t4);
		
		it  = times.iterator();
		while (it.hasNext()) {
			Object element2 = it.next();
			if(element2 instanceof Date) {
				Date d = (Date)element2;
				System.out.println(sdf.format(d));
			}
			
		}
		
	}
}

SortedSet
怎么实现排序的

被存储的元素实现了Comparable接口，Sun编写TreeSet集合在添加元素时，会调用CompareTo方法完成比较

	public static void main(String[] args)  {
		SortedSet ss = new TreeSet();
		User u = new User(1);
		User u1 = new User(3);
		User u2 = new User(2);
		User u3 = new User(4);
		
		ss.add(u);
		ss.add(u3);
		ss.add(u2);
		ss.add(u1);
		Iterator<E> it = ss.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
	}
	
}
 class User implements Comparable{
	int age;
	String name;
	User(int age){
		this.age = age;
		
	}
	public String toString() {
		return "User[age="+age+"]";
	}
	public int compareTo(Object o) {//程序员负责实现
		//编写比较规则
		
		int age1 = this.age;
		int age2 = ((User)o).age;
		return age1- age2;
	}
}

单独编写一个比较器（耦合度较强）

public static void main(String[] args) {
		//创建TreeSet集合的时候提供一个比较器
		SortedSet  ps = new TreeSet(new ProductComparator()); 
		Product p1 = new Product(1.0);
		Product p2 = new Product(1.2);
		Product p3 = new Product(1.5);
		Product p4 = new Product(2.0);
		
		ps.add(p1);
		ps.add(p2);
		ps.add(p3);
		ps.add(p4);
		
		Iterator it  = ps.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
class Product{
	double price;
	Product(double price){
		this.price = price;
	}
	public String toString () {
		return price +" ";
	}
}
class ProductComparator implements Comparator{
	public int compare(Object o1,Object o2) {
		double price1 = ((Product)o1).price;
		double price2 = ((Product)o2).price;
		if(price1==price2) {
			return 0;
		}else if(price1>price2) {
			return 1;
		}else {
			return -1;
		}
	}
}