javaSE-常用类-集合类Set系列

Set接口中常用的类

HashSet：线程不安全，存取速度快。
它是如何保证元素唯一性的呢？

TreeSet： 线程不安全，可以对Set集合中的 元素进行排序。
它的排序是如何进行的呢？

Set集合元素唯一性原因

HashSet：通过equals方法和hashCode 方法来保证元素的唯一性。

TreeSet：通过compareTo或者compare 方法中的来保证元素的唯一 性。元素是以二叉树的形式存 放的。
------------------


Set:元素不可以重复的。不保证顺序。
爽了，Set中的方法和Collection中的一致。所以不用在演示了。

Set:
|--HashSet:哈希表结构。不同步的。查询速度快。
|--TreeSet:它可以对Set集合中的元素进行排序。数据结构是二叉树。不同步的。
TreeSet排序有两种方式：
第一种：让元素自身具备比较性。让元素对象实现Comparable接口，覆盖compareTo方法。
但是，需求中，需要元素的非自然排序时，或者元素本身就不具备自然排序时，怎么办？
第二种：让容器具备比较性。其实就是定义一个比较器，就是实现Comparator接口，
覆盖compare方法。


List集合判断元素是否相同使用的equals方法。
HashSet集合判断元素相同，依据 hashCode和equals方法。，
TreeSet集合判断元素形同，依据compareTo或者compare方法的return 0;

List集合判断元素是否相同使用的equals方法。
HashSet集合判断元素相同，依据 hashCode和equals方法。，
TreeSet集合判断元素形同，依据compareTo或者compare方法的return 0;




集合名称规律：
前缀名：数据结构名。
后缀名：所属集合的名字。


ArrayList：数组结构，所属于List。想到索引，查询快。


LinkedList：链表结构，所属于List。想到增删快。


HashSet：哈希表结构，所属于Set,想到唯一性，查询速度快。


TreeSet：二叉树结构，所属于Set，想到唯一性，而且排序。
排序两种，自然排序Comaprable，compareTo比较器排序。Comparator.compare

public static void main(String[] args) {

		//创建一个hashSet集合。
		HashSet hs = new HashSet();
		
		hs.add("cba");
		hs.add("nba");
		hs.add("haha");
		hs.add("abcd");
		hs.add("haha");
//		"ab".equals("cc");
//		"ab".hashCode();
		for(Iterator it = hs.iterator(); it.hasNext(); ){
			System.out.println(it.next());
		}
	}

///

/*
 * 为了让Person具备自然排序功能。必须可以进行比较。
 * 就需要让Person具备比较功能。该功能已经定义在Comparable接口。
 * 只要实现Comparable接口覆盖compareTo方法。
 */
public class Person implements Comparable {

	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	
	/**
	 * 覆盖接口中的compareTo方法。
	 */
	@Override
	public int compareTo(Object o) {
		
		/*
		 * 通过年龄进行比较。如果年龄相同，必须再次比较次要条件姓名。
		 */
		if(!(o instanceof Person)){
			throw new ClassCastException("类型错误");
		}
		Person p = (Person)o;
		/*
		if(this.age > p.age){
			return 1;
		}else if(this.age<p.age){
			return -1;
		}else{
			return 0;
		}*/
		
		int temp = this.age - p.age;
		
		return temp==0?this.name.compareTo(p.name):temp;
//		return 1;//实现有序 。存入顺序和取出顺序一致。
		/*
		if(temp==0)
			return this.name.compareTo(p.name);
		else
			return temp;*/
		
	}
	
	
	
	/**
	 * 建立Person对象自己的哈希值。
	 * 根据对象自身的特点建立哈希算法。
	 * @return
	 */
	public int hashCode(){
		
		return name.hashCode()+age*39;
		
	}
	
	/**
	 * 判断Person对象内容相同的依据。
	 * 根据姓名很年龄
	 */
	public boolean equals(Object obj){
		
		if(!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		Person p = (Person)obj;
		
		return this.name.equals(p.name)&& this.age == p.age; 
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	
}

public class HashSetTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		HashSet hs = new HashSet();
		
		
		/*
		 * 同名同年龄视为同一个人 。
		 * 
		 * 记住：存储到哈希表中的对象，必须覆盖hashCode和euqals方法。
		 * 建立在哈希表判断元素唯一性的方式。
		 * */
		 
		hs.add(new Person("xiaoqiang",21));
		hs.add(new Person("wangcai",28));
		hs.add(new Person("xiaoming",23));
		hs.add(new Person("wangcai",28));
		hs.add(new Person("mazi",25));
		
		for(Iterator it = hs.iterator(); it.hasNext(); ){
			Person p = (Person)it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
		
	}

}

如果往hashset里面放对象 保证放的对象一定覆盖equals和hashcode方法

public class TreeSetDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		TreeSet ts = new TreeSet();

		// ts.add("abc");
		// ts.add("nba");
		// ts.add("aa");
		// ts.add("zz");
		// ts.add("haha");

		
		/*
		 * 按照Person的年龄从小到大排序。
		 * 
		 * 二叉树中判断元素是否相同是通过比较结果return 0，来完成的。
		 */
		ts.add(new Person("aa", 28));
		ts.add(new Person("cc", 23));
		ts.add(new Person("nba", 21));
		ts.add(new Person("abc", 23));
		ts.add(new Person("zz", 25));
		ts.add(new Person("cba", 26));
		ts.add(new Person("nba", 21));

		for (Iterator it = ts.iterator(); it.hasNext();) {
			System.out.println(it.next());
		}

	}

}

/**
 * 创建了一个比较器，按照Person的姓名进行比较。
 * @author Administrator
 *
 */
public class ComparatorByName extends Object implements Comparator {

	
	@Override
	public int compare(Object o1, Object o2) {

		/*
		 * 根据Person的姓名进行比较，如果姓名相同，再次比较年龄。
		 */
		
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		
		int temp = p1.getName().compareTo(p2.getName());
		
		return temp==0?p1.getAge()-p2.getAge():temp;
	}

}

public class TreeSetDemo2 {

	public static void main(String[] args) {

		/*
		 * 创建TreeSet集合时，直接在构造中明确具体的比较器。
		 */
		TreeSet ts = new TreeSet(new ComparatorByName());
		ts.add(new Person("aa", 28));
		ts.add(new Person("cc", 23));
		ts.add(new Person("nba", 21));
		ts.add(new Person("abc", 23));
		ts.add(new Person("zz", 25));
		ts.add(new Person("cba", 26));
		ts.add(new Person("nba", 21));

		for (Iterator<Person> it = ts.iterator(); it.hasNext();) {
			System.out.println(it.next());
		}
	}

}

TreeSet内的元素必须覆盖comparable接口或者TreeSet通过构造传递一个比较器

public class LinkedHashSetDemo {

	public static void main(String[] args) {

		HashSet hs = new LinkedHashSet();// 在哈希表基础上保证有序。

		hs.add("abcd");
		hs.add("nba");
		hs.add("haha");
		hs.add("cba");
		hs.add("haha");

		for (Iterator it = hs.iterator(); it.hasNext();) {
			System.out.println(it.next());
		}
	}

}

class name implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		return 0;
	}

}