集合

1.什么是集合？

Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组

Java 集合可分为 Collection 和 Map 两种体系：

1）Collection接口：
（1）Set：元素无序、不可重复的集合 ---类似高中的“集合”
（2）List：元素有序，可重复的集合  ---”动态”数组
2）Map接口：具有映射关系“key-value对”的集合 ---类似于高中的“函数” y = f(x)   (x1,y1) (x2,y2)

2.集合体系分类

3.Collection接口

1）Collection常用方法

2）集合的遍历

	/*
	 * 遍历集合
	 */
	@Test
	public void test(){
		Collection collection = new ArrayList();
		collection.add(111);
		collection.add("aaa");
		collection.add(222);
		//方法一：增强For循环
		for(Object i : collection){
			System.out.println("!!!" + i);
		}
		//方法二：使用Iterator接口的hasNext（） next（） 方法
		Iterator iterator = collection.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}

4.List

1）ArrayList（List接口的主要实现类）：其底层为数组

2）LinkedList：其底层数据结构为链表，插入和删除操作比较方便

3）Vector：基本上不用，线程安全

5.Set

①元素无序、不可重复的集合 

②无序：是指元素在底层的存放位置是无序的

③不可重复：当向Set中添加相同元素是，后面重复的元素添加不进去

1）HashSet(主要实现类）

Person类

public class Person {
	private String name;
	private int 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 Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person() {}
	@Override
	public String toString() {
		return "Person [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;
		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;
	}
	
	
	
}

test方法

	/**
	 * 要求添加进Set中元素所在的类，一定要重写equals()和hashCode()方法
	 * 进而保证Set元素的不可重复性
	 * 
	 * Set是如何存储元素的？使用了哈希算法
	 * 当向Set中添加对象时，首先调用所在类的hashCode()方法，计算此对象的哈希值，此哈希值
	 * 决定了此对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存储到该位置，若
	 * 此位置已有对象存储，就用equals()比较两个对象是否相同，若相同，则此对象不能存储
	 * >要求：hashCode()和equals()方法要一致
	 */
	@Test
	public void test1(){
		Set set = new HashSet();
		set.add(111);
		set.add("aaa");
		set.add(new Person("xiaoming",10));
		set.add(new Person("xiaoming",10));
		set.add(new Person("daming",20));
		System.out.println(set);
	}

2）LinkedHashSet

使用链表维护了元素添加进集合中的顺序，所以遍历LinkedHashSet集合元素时，就是元素的添加顺序

3）TreeSet

（1）特点：①只能添加同一种类型的元素；②可以按添加进集合的元素的顺序进行遍历，默认从小到大

（2）排序：①自然排序  ②定制排序

（3）自然排序：要求自定义类必须实现java.lang.Comparable接口并重写compareTo(Object obj)方法，并在compareTo(Object obj)方法中指定按照自定义类的那个属性进行排序

创建实现Comparable接口的实现类Person

public class Person implements Comparable{
	private String name;
	private 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 Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person() {}
	@Override
	public String toString() {
		return "Person [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;
		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中添加Person类对象时，依据此方法，确定按照那个属性排列
	@Override
	public int compareTo(Object o) {
		if(o instanceof Person){
			Person person = (Person)o;
			int i = this.name.compareTo(person.name);
			if(i == 0){
				return this.age.compareTo(person.age);
			}else{
				return i;
			}
		}
		return 0;
	}

测试

	@Test
	public void test3(){
		Set set = new TreeSet();
		set.add(new Person("xiaoming",10));
		set.add(new Person("daming",20));
		
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}

（4）定制排序：

①创建Comparator接口对象，并重写compare(Object obj1,Object obj2)方法；

②将Comparator接口对象作为参数传递给TreeSet构造器，创建TreeSet对象；

③向TreeSet对象中添加自定义类对象

创建Custommer类

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

创建Comparator接口对象，并测试

	/**
	 * 定制排序
	 */
	@Test
	public void test4(){
		//1.创建一个实现了Comparator接口的对象
		Comparator com = new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof Custommer && o2 instanceof Custommer){
					Custommer c1 = (Custommer)o1;
					Custommer c2 = (Custommer)o2;
					int i = c1.getName().compareTo(c2.getName());
					if(i == 0){
						return c1.getAge().compareTo(c2.getAge());
					}else{
						return i;
					}
				}
				return 0;
			}
			
		};
		//将次对象作为形参传递给TreeSet构造器中
		TreeSet set = new TreeSet(com);
		//向集合中添加对象元素
		set.add(new Custommer("xiaoming",10));
		set.add(new Custommer("xiaoming",20));
		set.add(new Custommer("xiaoding",10));
		
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		
	}

6.Map

1）Map概述

（1）Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value

（2）Map 中的 key 和  value 都可以是任何引用类型的数据

（3）Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。

（4）常用String类作为Map的“键”。

（5）key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。

2）Map常用方法：

3）遍历Map

	@Test
	public void test5(){
		Map map = new HashMap();
		map.put("user", "root");
		map.put("password", 123);
		map.put(new Person("xiaoming",10), "example1");
		//1获取Map中key集
		Set keys = map.keySet();
		for(Object obj : keys){
			System.out.println(obj);
		}
		//2.获取Map中的value集
		Collection values = map.values();
		for(Object obj : values){
			System.out.println(obj);
		}
		//3.获取Map中ley-value集方法一
		Set entrysSet = map.entrySet();
		for(Object obj : entrysSet){
			Map.Entry entry = (Map.Entry)obj;
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
		//4.获取Map中ley-value集方法二
		Set set = map.keySet();
		for(Object objKey : set){
			Object objValue = map.get(objKey);
			System.out.println(objKey + ":" + objValue);
		}
	}

4）HashMap

（1）key是用Set存放的，不可重复；value使用Collection存放的，可重复

（2）一个key-value对是一个Entry，Entry都是用Set来存放的也是不可重复的

（3）HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。若key相同，只能添加最后的那个元素

（4）HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true

5）HashTable—Properties

（1）常用来处理属性文件，它的kye和value都是String类型的

（2）常用方法：①load(InputStream is)    ②String getProperty(Strng key)

	@Test
	public void test6() throws Exception{
		InputStream is = new FileInputStream("pro.properties");
		Properties pro = new Properties();
		pro.load(is);
		String user = pro.getProperty("user");
		String password = pro.getProperty("password");
		System.out.println(user + " : " + password);
	}

6.集合工具类（Collections）