JAVA集合

一、集合概述及特点

1）一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。

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

3）Java 集合可分为 Collection 和 Map 两种体系
Collection接口：
Set：元素无序、不可重复的集合 ---类似高中的“集合”
List：元素有序，可重复的集合  ---”动态”数组

 Map接口：具有映射关系“key-value对”的集合 ---类似于高中的“函数” y = f(x)   (x1,y1)  (x2,y2)

4）Collection接口继承树

二、Collection接口中的常用方法

集合：Collection接口
 *     |------List接口：存储有序的，可以重复的元素
 *     |------ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的）
 *     |------Set接口：存储无序的，不可重复的元素
 *     |------HashSet、LinkedHashSet、TreeSet
 *     Map接口：存储“键-值”对的数据

 *     |-----HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)

List接口和Set接口的实现类主要用的方法是Collection的方法

package com.xijian1.java;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

/*
 * 1.存储对象可以考虑：①数组②集合
 * 2.数组存储对象的特点：Student[] stu = new Student[20];stu[0] = new Student();....
 * 3.集合
 */
import org.junit.jupiter.api.Test;

public class TestCollection {
	@Test
	public void test1() {
		Collection coll = new ArrayList();
		//1.size();返回集合中元素(对象)的个数
		System.out.println(coll.size());
		//2.add(Object obj);向集合中添加一个元素
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		System.out.println(coll.size());
		//3.addAll(Collection coll);将形参coll中包含的所有元素添加到当前集合中
		Collection coll1 = Arrays.asList(1,2,3);
		coll.addAll(coll1);
		System.out.println(coll.size());
		//查看集合元素
		System.out.println(coll);//重写的toString方法
		//4.isEmpty();判断集合是否为空
		System.out.println(coll.isEmpty());
		//5.clear();清空集合元素
		coll.clear();
		System.out.println(coll.isEmpty());
	}
	@Test
	public void test2() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		Person p = new Person("MM",23);
		coll.add(p);
		//6.contains(Object obj);判断集合中是否包含指定的obj元素，如果包含返回true，反之返回false
		//判断的依据：根据元素（对象）所在类的equals()方法进行判断
		//明确：如果存入集合中的元素是自定义类的对象。要求：自定义类要重写equals方法！
		boolean b1 = coll.contains(123);
		boolean b2 = coll.contains(p); //是true
		//boolean b2 = coll.contains(new Person("MM",23));//false,对象的属性一样，要想返回true，必须重写对象的equals()方法
		System.out.println(b1);
		System.out.println(b2);
		//7.containsAll(collection coll);判断当前集合中是否包含coll中所有的元素
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add(new String("AA"));
		boolean b3 = coll.containsAll(coll1);
		System.out.println(b3);
		//8.retainAll(Collection coll);:求当前集合与coll的共有元素，返回给当前集合
		coll.retainAll(coll1);
		System.out.println(coll);
		//9.remove(Object obj);删除集合中的obj元素。若删除成功，返回true。否则，返回false
		boolean b4 = coll.remove("BB");
		System.out.println(b4);
	}
	@Test
		public void test3() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM",123));
		
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add("AA");
		//10.removeAll(Collection coll);从当前集合中删除包含在coll中的元素
		coll.removeAll(coll1);
		System.out.println(coll);
		//11.equals(Object obj);判断集合中的所有元素是否完全相同
		boolean b1 = coll.equals(coll1);
		System.out.println(b1);
		//12.hashCode();
		System.out.println(coll.hashCode());
		System.out.println();
		//13.toArray();将集合转换成数组
		Object[] obj = coll.toArray();
		for(int i = 0;i<obj.length;i++) {
			System.out.println(obj[i]);
		}
		System.out.println();
		//14.iterator();返回一个Iterator接口实现类的对象,实现集合的遍历！
		Iterator iterator = coll.iterator();
		//方式一：不用
		/*System.out.println(iterator.next());
		System.out.println(iterator.next());
		System.out.println(iterator.next());*/
		//方式二：不用
		/*for(int i = 0;i < coll.size();i++) {
			System.out.println(iterator.next());
		}*/
		//方式三：使用
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
		
	}
	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 + "]";
		}

		@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 (!getOuterType().equals(other.getOuterType()))
				return false;
			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;
		}

		private TestCollection getOuterType() {
			return TestCollection.this;
		}
		
		
	}
}

三、集合的遍历（详解）

package com.xijian.java;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

import org.junit.Test;

public class TestIterator {
	@Test
	public void test1() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM",123));
		
		Iterator i = coll.iterator();//iterator()方法返回一个Iterator接口类的实现对象
		while(i.hasNext()) {//hasNext()方法一开始指向第一个元素的上方，执行此方法时会判断下一位元素是否存在，但缺不改变指向
			System.out.println(i.next());
		}
	}
	//错误的写法
	@Test
	public void test2() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM",123));
		
		Iterator i = coll.iterator();
		while(i.next()!=null) {//nexxt();方法会使指针指向下移，不能完全打印并且报错NoSuchElementException
			System.out.println(i.next());
		}
	}
	//使用增强for循环实现集合的遍历
	@Test
	public void test3() {
			Collection coll = new ArrayList();
			coll.add(123);
			coll.add("AA");
			coll.add(new Date());
			coll.add("BB");
			coll.add(new Person("MM",123));
			
			for(Object i:coll) {
				System.out.println(i);
			}
	}
}
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 + "]";
	}
	@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;
	}
	
}

四、ArraList和List的常用方法

package com.atguigu.java1;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class TestList {
	
	//ArrayList：List的主要实现类
	/*
	 * List中相对于Collection，新增加的方法
	 *  void add(int index, Object ele):在指定的索引位置index添加元素ele
		boolean addAll(int index, Collection eles)
		Object get(int index):获取指定索引的元素
		Object remove(int index):删除指定索引位置的元素
		Object set(int index, Object ele):设置指定索引位置的元素为ele
		int indexOf(Object obj):返回obj在集合中首次出现的位置。没有的话，返回-1
		int lastIndexOf(Object obj)：返回obj在集合中最后一次出现的位置.没有的话，返回-1
		List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list
		
		List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index,Object obj))
					查(get(int index)) 插(add(int index, Object ele)) 长度(size())
	 */
	@Test
	public void testList2(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("GG"));
		list.add(456);
		System.out.println(list.indexOf(456));
		System.out.println(list.lastIndexOf(456));
		System.out.println(list.indexOf(123) == list.lastIndexOf(123));
		System.out.println(list.indexOf(444));
		
		List list1 = list.subList(0, 3);
		System.out.println(list1);
	}
	
	@Test
	public void testList1(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("GG"));
		System.out.println(list);
		list.add(0,555);
		System.out.println(list);
		Object obj = list.get(1);
		System.out.println(obj);
		list.remove(0);
		System.out.println(list.get(0));
		list.set(0, 111);
		System.out.println(list.get(0));
	}
}

五、HashSet、LinkedHashSet、TreeSet（自然排序和定制排序）

package com.atguigu.java;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

/*
 * Collection接口 ：
 * 		|------List接口：
 * 			|------ArrayList（主要的实现类）、
 * 			|------LinkedList（对于频繁的插入、删除操作）、
 * 			|------Vector（古老的实现类、线程安全的，但效率要低于ArrayList）
 * 		|------Set接口：存储无序的，不可重复的元素.Set中常用的方法都是Collection下定义的。
 *     				|------HashSet(主要实现类)
 |------LinkedHashSet
 |------TreeSet
 */
public class TestSet {
	@Test
	public void testTreeSet3() {

		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;
			}
		});
		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);
		}
	}

	/*
	 * TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！
	 */
	@Test
	public void testTreeSet2() {
		// 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;
			}
		};
		// 2.将此对象作为形参传递给TreeSet的构造器中
		TreeSet set = new TreeSet(com);
		// 3.向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);
		}
	}

	/*
	 * TreeSet: 1.向TreeSet中添加的元素必须是同一个类的。
	 * 2.可以按照添加进集合中的元素的指定的顺序遍历。像String，包装类等默认按照从小到大的顺序遍历。
	 * 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
	 * 4.自然排序：要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法
	 * 在此方法中，指明按照自定义类的哪个属性进行排序。
	 * 
	 * 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此
	 * 属性值相同，但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
	 * 
	 * >compareTo()与hashCode()以及equals()三者保持一致！
	 */
	@Test
	public void testTreeSet1() {
		Set set = new TreeSet();
		// set.add(new String("AA"));
		// set.add(new String("AA"));
		// set.add("JJ");
		// set.add("GG");
		// set.add("MM");
		// 当Person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
		set.add(new Person("CC", 23));
		set.add(new Person("MM", 21));
		set.add(new Person("GG", 25));
		set.add(new Person("JJ", 24));
		set.add(new Person("KK", 20));
		set.add(new Person("DD", 20));
		// set.add("AA");

		for (Object str : set) {
			System.out.println(str);
		}

	}

	/*
	 * LinkedHashSet:使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHashSet集合
	 * 元素时，是按照添加进去的顺序遍历的！
	 * 
	 * LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
	 */
	@Test
	public void testLinkedHashSet() {
		Set set = new LinkedHashSet();
		set.add(123);
		set.add(456);
		set.add(new String("AA"));
		set.add(new String("AA"));
		set.add("BB");
		set.add(null);

		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}

	}

	/*
	 * Set:存储的元素是无序的，不可重复的！
	 *  1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
	 * 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
	 * 
	 * 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。 进而保证Set中元素的不可重复性！
	 * 
	 * Set中的元素时如何存储的呢？使用了哈希算法。
	 * 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
	 * 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。若此位置
	 * 已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。 万一返回false呢，都存储。（不建议如此）
	 * >要求：hashCode()方法要与equals()方法一致。
	 */
	@Test
	public void testHashSet() {
		Set set = new HashSet();
		set.add(123);
		set.add(456);
		set.add(new String("AA"));
		set.add(new String("AA"));
		set.add("BB");
		set.add(null);
		Person p1 = new Person("GG", 23);
		Person p2 = new Person("GG", 23);
		System.out.println(p1.equals(p2));
		System.out.println(p1.hashCode());
		System.out.println(p2.hashCode());
		set.add(p1);
		set.add(p2);
		System.out.println(set.size());
		System.out.println(set);
	}
}

package com.atguigu.java;

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 Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Person() {
		super();
	}
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	//static int init = 1000;
	@Override
	public int hashCode() {//return age.hashCode() + name.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;
		//return init++;//不能这样用
	}
	@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 == 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;
	}
	//当向TreeSet中添加Person类的对象时，依据此方法，确定按照哪个属性排列。
	@Override
	public int compareTo(Object o) {
		if(o instanceof Person){
			Person p = (Person)o;
			//return this.name.compareTo(p.name);
			//return -this.age.compareTo(p.age);
			int i = this.age.compareTo(p.age);
			if(i == 0){
				return this.name.compareTo(p.name);
			}else{
				return i;
			}
		}
		return 0;
	}
	
}

package com.atguigu.java;

public 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;
	}
	
}

我刚用1.5倍速看完了Set接口下的三个集合，讲到TreeSet的排序实现的时候已经懵了，现在头嗡嗡的，而且这个笔记加源码太多- - 以后用到的话回来查也好…… 这比我当时刚学C语言的时候研究冒泡排序研究了两个小时要头疼的多……

——————————————————————————————————————————————————

六、Map接口常用方法以及HashMap LinkedHashMap TreeMap 

package com.atguigu.java;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;

import org.junit.Test;

/*
 * Collection接口
 * 
 * Map接口
 * 		|-----HashMap:Map的主要实现类
 * 		|-----LinkedHashMap:使用链表维护添加进Map中的顺序。故遍历Map时，是按添加的顺序遍历的。
 * 		|-----TreeMap:按照添加进Map中的元素的key的指定属性进行排序。要求：key必须是同一个类的对象！
 * 				针对key：自然排序   vs 定制排序
 * 		|-----Hashtable:古老的实现类，线程安全，不建议使用。
 * 			|----Properties:常用来处理属性文件。键和值都为String类型的
 */
public class TestMap {
	//使用Properties处理属性文件
	@Test
	public void test6() throws FileNotFoundException, IOException{
		Properties pros = new Properties();
		pros.load(new FileInputStream(new File("jdbc.properties")));
		String user = pros.getProperty("user");
		System.out.println(user);
		String password = pros.getProperty("password");
		System.out.println(password);
	}
	
	// 定制排序
	@Test
	public void test5() {
		Comparator com = 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;
			}
		};
		TreeMap map = new TreeMap(com);
		map.put(new Customer("AA", 1001), 87);
		map.put(new Customer("CC", 1001), 67);
		map.put(new Customer("MM", 1004), 77);
		map.put(new Customer("GG", 1002), 97);
		
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}

	// 自然排序
	@Test
	public void test4() {
		Map map = new TreeMap();
		map.put(new Person("AA", 23), 89);
		map.put(new Person("MM", 22), 79);
		map.put(new Person("GG", 23), 99);
		map.put(new Person("JJ", 13), 69);

		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}

	@Test
	public void test3() {
		Map map = new LinkedHashMap();
		map.put("AA", 213);
		map.put("BB", 45);
		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);

		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}

	/*
	 * 如何遍历Map Set keySet() 
	 * Collection values() 
	 * Set entrySet()
	 */
	@Test
	public void test2() {
		Map map = new HashMap();
		map.put("AA", 213);
		map.put("BB", 45);
		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);

		// 1.遍历key集。
		Set set = map.keySet();
		for (Object obj : set) {
			System.out.println(obj);
		}
		// 2.遍历value集
		Collection values = map.values();
		Iterator i = values.iterator();
		while (i.hasNext()) {
			System.out.println(i.next());
		}
		// 3.如何遍历key-value对。
		// 方式一：
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
		// 方式二：
		Set set2 = map.entrySet();
		for (Object obj : set2) {
			Map.Entry entry = (Map.Entry) obj;
			// System.out.println(entry.getKey() + "---->" + entry.getValue());
			System.out.println(entry);
		}
	}

	/*
	 * Object put(Object key,Object value):向Map中添加一个元素 
	 * Object remove(Object key):按照指定的key删除此key-value 
	 * void putAll(Map t) void clear():清空 Object
	 * get(Object key)：获取指定key的value值。若无此key，则返回null 
	 * boolean containsKey(Objectkey) boolean containsValue(Object value)
	 * int size():返回集合的长度
	 * boolean isEmpty() 
	 * boolean equals(Object obj)
	 * 
	 * HashMap： 1.key是用Set来存放的，不可重复。value是用Collection来存放的，可重复
	 * 一个key-value对，是一个Entry。所有的Entry是用Set存放的，也是不可重复的。
	 * 2.向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同 则只能添加进后添加的那个元素。
	 */
	
	
	@Test
	public void test1() {
		Map map = new HashMap();
		map.put("AA", 213);
		map.put("BB", 456);
		map.put("BB", 45);
		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);
		map.put(new Person("DD", 23), 87);
		System.out.println(map.size());
		System.out.println(map);
		map.remove("BB");
		System.out.println(map);
		Object value = map.get(1234);
		System.out.println(value);
	}
}

七、操作集合的工具类Collections

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
1）排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

2）查找、替换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中

boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

3）Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题