集合框架

Collection：

    |--List 有序可重复，有索引，存入的顺序和取出的顺序一致

        |--Arraylist--数组结构，查询速度快，不同步  

        |--linkedlist--链表结构，增删速度快，不同步

    |--Set 无序不重复   

        |--Hashset--哈希表结构，元素唯一，查询速度快，不同步  

        |--Treeset--二叉树结构，可以对set集合中的元素排序，不同步

                Treeset排序两种方式，自然排序：元素实现Comaprable接口，覆盖compareTo()

                                    比较器排序：容器传入实现Comparator接口的比较器，覆盖compare()




Set:元素不能重复，没有顺序。

    Set中的方法和Collection中的一致。


HashSet

	@Test
	public void test7(){
		//创建一个hashSet集合。
		HashSet hs = new HashSet();
		
		hs.add("cba");
		hs.add("nba");
		hs.add("nba");
		hs.add("nba");
		hs.add("haha");
		hs.add("abcd");
		hs.add("haha3");

//		System.out.println("ab".equals("ab"));
//		System.out.println("ab".hashCode());
		
		for(Iterator it = hs.iterator(); it.hasNext(); ){
			System.out.println(it.next());
		}
	}

	打印结果：无序，不重复
	    haha3
            cba
            nba
            haha
            abcd


HashSet存储自定义对象

    HashSet集合判断元素是否相同，依据元素的 hashCode和equals方法。

	@Test
	public void test07(){
		HashSet hs = new HashSet();
		Person p = new Person("hahahha",33);
		hs.add(p);
		hs.add(new Person("hahahha",33));
		hs.add(new Person("hahahha",33));
		hs.add(new Person("hahahha",33));
		for(Iterator it = hs.iterator(); it.hasNext(); ){
			System.out.println(it.next());
		}
	}
	
	测试结果：
	    cn.collection.Person@28f5662f

public class Person {

	private String name;
	private int age;
	 public Person(String name,int age){
		 this.name = name;
		 this.age = age;
		 //System.out.println(name+"  "+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;
		Person other = (Person) 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

    TreeSet集合判断元素相同，依据元素的compareTo方法或者 compare方法的return 0;


TreeSet排序有两种方式：

    第一种：让元素自身具备比较性。让元素对象实现Comparable接口，覆盖compareTo方法。

    第二种：让容器具备比较性。其实就是定义一个比较器，就是实现Comparator接口，覆盖compare方法。将比较器以参数的形式传入构造方法中。

    第二种排序方法的优先级大于第一种排序方法！！


举例子

第一种排序方式，元素自身具备比较性

    conpareTo方法返回值的意思

            return=1;//实现有序 。存入顺序和取出顺序一致。一般不用。

            return=-1;//存入的顺序与取出的顺序相反

            return=0;//只能往TreeSet中存入一个数进去，其他的数存不进去


public class Person implements Comparable{
	private String name;
	private int age;
	public Person(String name,int age){
            this.name = name;
	    this.age = age;
	 }	
	  
	@Override
	public int compareTo(Object o) {
		if(!(o instanceof Person)){
			throw new ClassCastException("类型错误");
		}
		Person p = (Person)o;
	        
	        //通过年龄进行比较。如果年龄相同，必须再次比较次要条件姓名。
		return this.age-p.age==0?this.name.compareTo(p.name):this.age-p.age;

	}
            
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}	 
}

测试
	@Test
	public void test08(){
		TreeSet ts =  new TreeSet();
		ts.add(new Person("zhang",32));
		ts.add(new Person("zhang",31));
		ts.add(new Person("zhang",33));
		ts.add(new Person("zhang",33));
		ts.add(new Person("asd",33));
		for(Iterator it = ts.iterator();it.hasNext();){
			System.out.println(it.next());
		}
	}
	
测试结果：
    Person [name=zhang, age=31]
    Person [name=zhang, age=32]
    Person [name=asd, age=33]
    Person [name=zhang, age=33]


第二中排序方式：让容器具备比较性

测试
	@Test
	public void test09(){
		TreeSet ts =  new TreeSet(new 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;
			}
		});
		ts.add(new Person("des",36));
		ts.add(new Person("zhang",31));
		ts.add(new Person("zhang",33));
		ts.add(new Person("zhang",33));
		ts.add(new Person("asd",33));
		for(Iterator it = ts.iterator();it.hasNext();){
			System.out.println(it.next());
		}
	}

测试结果：
    Person [name=asd, age=33]
    Person [name=des, age=36]
    Person [name=zhang, age=31]
    Person [name=zhang, age=33]

普通javabean    
public class Person {
	private String name;
	private int age;
	 public Person(String name,int age){
		 this.name = name;
		 this.age = 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 + "]";
	}	 
}


/*

 * 练习：对字符串进行长度排序。

 * 思路：

 * 字符串本身具备自然排序，但是不是需求所需要的。

 * 这时只能使用比较器。

 */

        @Test
	public void test10(){
	        //不传入比较器的TreeSet，是按照元素本身的排序方式排序
		TreeSet ts = new TreeSet(new Comparator(){
			
			@Override
			public int compare(Object o1, Object o2) {
				String s1 = (String)o1;
				String s2 = (String)o2;
				int temp = s1.length()-s2.length();
				return temp==0?s1.compareTo(s2):temp;
			}
			
		});
		 ts.add("nba");
		 ts.add("adaddd");
		 ts.add("aa");
		 ts.add("aa");
		 ts.add("zz");
		 ts.add("abc");
		 ts.add("haha");

		 for (Iterator it = ts.iterator(); it.hasNext();) {
				System.out.println(it.next());
		 }
	}
测试结果：元素唯一，并按照长度排序，长度一致按照字典排序
    aa
    zz
    abc
    nba
    haha
    adaddd




集合框架-LinkedHashSet

在哈希表基础上保证有顺序，唯一。

测试
        @Test
	public void test11(){
		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());
		}
	}
测试结果：
    abcd
    nba
    haha
    cba