Set、Map集合

实现类

      （1）HashSet

        采用的结构是数组加链表结构(哈希表)

          无序：因为存放的位置是根据hashCode来计算的.

          不能重复依据： hashCode   equals 

          hashCode要和equals兼容  为了提高性能

 

           HashSet的存储原理

根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：

如果对应的位置没有其它元素，就只需要直接存入。

          如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调equals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。

取对象时：

    根据对象的哈希码值计算出它的存储索引，在散列表的相应位置(表元)上的元素间进行少量的比较操作就可以找出它。

             

代码示例：

package com.qf.day17_1;
/**
 * 重写hashCode和equals来进行比较元素是否相同
 * @author Administrator
 *
 */
public class Employee {
	String name;
	int age;
	String gender;
	String address;
	public Employee() {
		// TODO Auto-generated constructor stub
	}
	public Employee(String name, int age, String gender, String address) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.address = address;
	}
	public void show() {
		System.out.println(name+age+gender+address);
	}
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return name.hashCode()+age;
	}
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		Employee e=(Employee)obj;
		boolean b1= name.equals(e.name);
		boolean b2= age==e.age;
		return b1&&b2;
	}
}

package com.qf.day17_1;

import java.util.HashSet;

public class Demo1 {
	public static void main(String[] args) {
		Employee e1 = new Employee("张三", 20, "男", "北京海淀");
		Employee e2 = new Employee("李四",21,"男","北京朝阳");
		Employee e3 = new Employee("王五",22,"男","浙江杭州");
		Employee e4 = new Employee("王五",22,"男","浙江杭州");
		
		HashSet<Employee> employees = new HashSet<Employee>();
		employees.add(e1);
		employees.add(e2);
		employees.add(e3);
		employees.add(e4);
		
		for (Employee employee : employees) {
			employee.show();
		}
	}
}

运行结果：

      （2）TreeSet

        采用的结构是红黑自平衡二叉树

        无序：添加顺序和存储顺序不一样 ，但是存储有一定顺序    

        不能重复依据

     Comparable接口

所有可“排序”的类都可以通过实现java.lang.Comparable接口来实现，该接口中的唯一方法：

public int compareTo(Object obj);　该方法如果

返回 0，表示 this ==obj

返回正数，表示 this> obj

返回负数，表示 this< obj

可“排序”的类通过Comparable接口的compareTo方法来确定该类对象的排序方式。

 

Comparator接口

使用Comparable接口定义排序顺序有局限性：实现此接口的类只能按compareTo()定义的这一种方式排序。

如果同一类对象要有多种排序方式，应该为该类定义不同的比较器(实现Comparator接口的类)TreeSet有一个构造方法允许给定比较器，它就会根据给定的比较器对元素进行排序.

Comparator接口中的比较方法：

public int compare(Object o1, Object o2);　该方法如果

–      返回0，表示o1 == o2

–      返回正数，表示o1 > o2

返回负数，表示o1 < o2

Comparable与Comparator区别

1> Comparable是用在集合元素对象上，Comparator是实现比较器

2> Comparable实现compareTo方法 Comparator 是实现compare方法

3> 两个方法返回值都是整数，0表示重复，负数 前面比后面晓正数 前面比后面大

Comparable

类实现Comparable接口

public class Person implements Comparable<Person>{
	String name;
	int age;
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public void show() {
			System.out.println(name+age);
	}
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		System.out.println(name+"----------->"+o.name);
		
		int num=age-o.age;
		return num==0?name.compareTo(o.name):num;
		
	}
}

import java.util.TreeSet;

public class Demo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1 = new Person("奥巴马",50);
		Person p2 = new Person("萨达姆",40);
		Person p3 = new Person("本拉登",30);
		Person p4 = new Person("金三胖",20);
		Person p5 = new Person("金三胖",18);
		
		TreeSet<Person> persons = new TreeSet<Person>();
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		persons.add(p4);
		persons.add(p5);
		
		for (Person person : persons) {
			person.show();
		}
	}

}

运行结果

Comparator

实现比较器

import java.util.Comparator;

public class Mycomparator implements Comparator<Person> {

	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		int num = o1.age-o2.age;
		return num==0?o1.name.compareTo(o2.name):num;
	}

}

public class Demo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1 = new Person("奥巴马",50);
		Person p2 = new Person("萨达姆",40);
		Person p3 = new Person("本拉登",30);
		Person p4 = new Person("金三胖",20);
		Person p5 = new Person("金三胖",18);
		
		TreeSet<Person> persons = new TreeSet<Person>(new Mycomparator());
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		persons.add(p4);
		persons.add(p5);
		
		for (Person person : persons) {
			person.show();
		}
	}

}

运行结果

（3）HashMap

HashMap存储结构使用哈希表，使用“键”进行散列存放。所以根据“键”去取“值”的效率很高。

package com.qf.day18_1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map.Entry;

public class Demo1 {
	public static void main(String[] args) {
		HashMap<Student, String> map = new HashMap<Student,String>();
		Student s1 = new Student("张三", 20, "男");
		Student s2 = new Student("李四", 20, "男");
		Student s3 = new Student("王五", 23, "男");
		Student s4 = new Student("张三", 20, "男");
		
		map.put(s1, "北京");
		map.put(s2, "上海");
		map.put(s3, "深圳");
		map.put(s4, "北京");
		
		System.out.println("-----------使用keySet遍历-----------");
		Set<Student> keySet = map.keySet();
		Iterator<Student> kIterator = keySet.iterator();
		while (kIterator.hasNext()) {
			Student student = kIterator.next();
			student.show();
			System.out.println("地址："+map.get(student));
		}
		
		System.out.println("-----------使用EntrySet遍历-----------");
		Set<Entry<Student, String>> enset = map.entrySet();
		Iterator<Entry<Student, String>> eIterator = enset.iterator();
		while (eIterator.hasNext()) {
			Entry<Student, String> entry = eIterator.next();
			entry.getKey().show();
			System.out.println("地址："+entry.getValue());
			
		}
	}
}

（3）TreeMap

TreeMap内部使用红黑二叉树结构对“key”进行排序存放，所以放入TreeMap中的“key-value”对的“key”必须是可“排序”的。

package com.qf.day18_2;

import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		TreeMap<Student, String> student=new TreeMap<Student,String>(new MyComparator());
		student.put(new Student("张三",20), "北京");
		student.put(new Student("张三2",21), "上海");
		student.put(new Student("张三3",24), "广州");
		student.put(new Student("冰冰",22), "深圳");
		
		
//		System.out.println(student.size());
//		student.remove(new Student("张三4", 23),"北京");
//		System.out.println(student.size());
		
		System.out.println("-----------使用keySet遍历------------");
		Set<Student> keySet = student.keySet();
		Iterator<Student> it1 = keySet.iterator();
		while (it1.hasNext()) {
			Student key = it1.next();
			key.show();
			System.out.println(student.get(key));
		}
		
		System.out.println("-----------使用EntrySet遍历------------");
		Set<Entry<Student, String>> enset = student.entrySet();
		Iterator<Entry<Student, String>> it2 = enset.iterator();
		while (it2.hasNext()) {
			
			Entry<Student, String> entry2 = it2.next();
			entry2.getKey().show();
			System.out.println(entry2.getValue());
		}
	}

}

最后附一张集合图