JavaSE-集合Set

package com.btp.t4;

import java.util.HashSet;
import java.util.Set;
import java.util.*;
import org.junit.Test;

/*
 * Collection接口
 *              |--------List接口：存储有序的，可以重复的元素
 *                        |--------ArrayList(主要的实现类)
 *                        |--------LinkedList(适合频繁的插入，删除操作)
 *                        |--------Vector(古老的，线程安全的，但效率要低于ArrayList)
 *              |--------Set接口：存储无序的，不可重复的元素.Set中常用的方法都是Collection下定义的
 *                        |--------HashSet(主要实现类)
 *                        |--------LinkedHashSet
 *                        |--------TreeSet
 *                        
 *                        
 * Set：存储的元素是无序的，不可重复的
 * 1.无序性：无序性 ！= 随机性。真正的无序性指的是元素在底层存储的位置是无序的
 * 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去
 * 
 * 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。进而保证Set元素的不可重复性
 * 
 * Set中的元素存储方法：使用了哈希算法
 * 当向Set中添加对象时，首先调用此对象中所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在
 * Set中的存储位置。若此位置之前没有存储对象，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals
 * 方法比较这两个对象是否相同。如果相同，则后一个对象就不能再添加进来。一般不会出现hashCode相同而equals返回false
 * >要求：hashCode方法和equals方法一致
 * 
 * LinkedHashSet：
 * 1.LinkedHashSet:使用链表维护了一个添加进集合的顺序，导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的
 * 2.LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能
 * 
 * TreeSet
 * 1.向TerrSet中添加的元素必须是同一类的
 * 2.可以按照添加进集合中的元素的指定的顺序遍历。像String，包装类等默认按照从小到大的顺序遍历（因为它们都重写了Comparable接口中的方法）
 * 3.当自定义类没有实现Comparable接口时，当向TreeSet集合中添加自定义类的对象时，报错
 * 4.当向TreeSet中添加自定义类的对象时，有两种排序方法①自然排序②定制排序
 * 5.自然排序：要求自定义类实现java.lang.Comparable接口并重写其中的comparaTo(Object o)方法.在此方法中，指明按照自定义类的哪个属性进行排序
 * 6.向TreeSet中添加对象的时候，首先按照comparaTo()方法进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，但是程序会认为这两个对象是相同的，
 *   进而后一个对象不能添加进来
 * >comparaTo(),hashCode()和equals()方法保持一致
 */
public class TestSet {
	
	@Test
	public void testHashSet(){
		Set set=new HashSet();
		
		set.add(123);
		set.add(456);
		set.add(new String("AA"));
		set.add(new String("BB"));
		set.add(null);
		Person1 p1=new Person1("GG",12);
		Person1 p2=new Person1("GG",12);
		set.add(p1);
		set.add(p2);//如果没有重写Person1的equals方法和HashCode方法，那么就算Person1的两个对象属性都相同，也是可以都加到set中
		//所以还是需要同时重写加进去的对象的equals方法和HashCode方法，才能实现不可重复性
		System.out.println(set.size());
		System.out.println(set);//无序：但是不是随机的
	}
	
	
	@Test
	public void LinkedHashSet(){
		Set set=new LinkedHashSet();
		
		set.add(new String("AA"));
		set.add(123);
		set.add(456);
		set.add(new String("BB"));
		set.add(null);
		Iterator iterator=set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
	
	@Test
	public void TreeSet1(){
        Set set=new TreeSet();
        set.add(new String("AA"));
		set.add(new String("BB"));
		set.add("JJ");
		set.add("JJ");
		set.add("MM");
		for(Object str:set)
		{
			System.out.println(str);
		}
		
	}
	
	@Test
	public void TreeSet2(){
		 Set set=new TreeSet();
		 set.add(new Person1("MM",16));
		 set.add(new Person1("AA",13));
		 set.add(new Person1("CC",21));
		 set.add(new Person1("ZZ",199));
		 set.add(new Person1("BB",99));
		 set.add(new Person1("XX",99));
		 for(Object str:set)
			{
				System.out.println(str);
			}
	}
	
	@Test
	public void TreeSet3(){
		//定制排序1
	//1.创建一个实现了Comparator接口的类对象
		Comparator com=new Comparator(){
			//向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer的哪个对象排序的
			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof Customer && o2 instanceof Customer){
					Customer c1=(Customer)o1;
					Customer c2=(Customer)o2;
					int i=c1.getId().compareTo(c2.getId());
					if(i==0){
						return c1.getName().compareTo(c2.getName());
					}
					return i;
				}
				return 0;
			}
		};
		//将此对象作为形参传递给TreeSet的构造器中
		TreeSet set=new TreeSet(com);
		//向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
		set.add(new Customer("AA",1003));
		set.add(new Customer("BB",1002));
		set.add(new Customer("GG",1004));
		set.add(new Customer("CC",1001));
		set.add(new Customer("DD",1001));
		
		for(Object str:set){
			System.out.println(str);
		}
	}
	


@Test
public void TreeSet4(){
	//定制排序2
	TreeSet set=new TreeSet(new Comparator(){
		public int compare(Object o1, Object o2) {
			if(o1 instanceof Customer && o2 instanceof Customer){
				Customer c1=(Customer)o1;
				Customer c2=(Customer)o2;
				int i=c1.getId().compareTo(c2.getId());
				if(i==0){
					return c1.getName().compareTo(c2.getName());
				}
				return i;
			}
			return 0;
		}
	});
	//向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
	set.add(new Customer("AA",1003));
	set.add(new Customer("BB",1002));
	set.add(new Customer("GG",1004));
	set.add(new Customer("CC",1001));
	set.add(new Customer("DD",1001));
	
	for(Object str:set){
		System.out.println(str);
	}
}

}

class Customer{
	private String name;
	private Integer id;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	
	public Customer(String name,Integer id)
	{
		super();
		this.name=name;
		this.id=id;
	}
	public Customer()
	{
		super();
	}
	@Override
	public String toString() {
		return "Customer [name=" + name + ", id=" + id + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		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;
		Customer other = (Customer) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}

class Person1 implements Comparable{
	String name;
	Integer 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;
	}
	public Person1(String name,int age) {
		super();
		this.name=name;
		this.age=age;
	}
	@Override
	public String toString() {
		return "Person1 [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		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;
		Person1 other = (Person1) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	//当向TreeSet中添加Person1类对象时，依据此方法，确定按照哪个属性排列
	@Override
	public int compareTo(Object o) {
		if(o instanceof Person1){
			Person1 p=(Person1)o;
			int i=this.age.compareTo(p.age);
			if(i==0){
				return this.name.compareTo(p.name);
			}else{
				return i;
			}
			
		}
		return 0;
	}
	
	
	
	
	
}