7.Java集合

1.对象的存储：①数组（基本数据类型 & 引用数据类型） ②集合（引用数据类型）

>数组存储数据的弊端：长度一旦初始化以后，就不可变；真正给数组元素赋值的个数没有现成的方法可用。

2.集合框架

Collection接口 ：方法：

①add(Object obj),addAll(Collection coll),size(),clear(),isEmpty();

②remove(Object obj),removeAll(Collection coll),retainAll(Collectioncoll),equals(Object obj),contains(Object obj),containsAll(Collection coll),hashCode()

③ iterator(),toArray();

* |------List接口：存储有序的，可以重复的元素.---相当于“动态”数组

>新增的方法：删除remove(int index) 修改set(int index,Object obj) 获取get(int index)插入add(int index,Object obj)

>添加进List集合中的元素（或对象）所在的类一定要重写equals()方法

* |------ArrayList（主要的实现类）

|------LinkedList（更适用于频繁的插入、删除操作）

|------Vector（古老的实现类、线程安全的，但效率要低于ArrayList）

* |------Set接口：存储无序的，不可重复的元素。---相当于高中的“集合”概念

>Set使用的方法基本上都是Collection接口下定义的。

>添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致。

>1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。

>2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。

* |------HashSet（主要的实现类）

|------LinkedHashSet(是HashSet的子类，当我们遍历集合元素时，是按照添加进去的顺序实现的；频繁的遍历，较少的添加、插入操作建议选择此)

|------TreeSet（可以按照添加进集合中的元素的指定属性进行排序）

>要求TreeSet添加进的元素必须是同一个类的！

>两种排序方式：自然排序：①要求添加进TreeSet中的元素所在的类implements Comparable接口

②重写compareTo(Object obj)，在此方法内指明按照元素的哪个属性进行排序

③向TreeSet中添加元素即可。若不实现此接口，会报运行时异常

定制排序：①创建一个实现Comparator接口的实现类的对象。在实现类中重写Comparator的compare(Object o1,Object o2)方法

②在此compare()方法中指明按照元素所在类的哪个属性进行排序

③将此实现Comparator接口的实现类的对象作为形参传递给TreeSet的构造器中

④向TreeSet中添加元素即可。若不实现此接口，会报运行时异常

>要求重写的compareTo()或者compare()方法与equals()和hashCode()方法保持一致。

Map接口：存储“键-值”对的数据 ----相当于高中的“函数y = f(x)” (x1,y1) (x2,y2)

>key是不可重复的，使用Set存放。value可以重复的，使用Collection来存放的。一个key-value对构成一个entry(Map.Entry)，entry使用Set来存放。

>添加、修改 put(Object key,Object value) 删除remove(Object key) 获取get(Object key) size() / keySet() values() entrySet()

* |-----HashMap：主要的实现类，可以添加null键，null值

|-----LinkedHashMap：是HashMap的子类，可以按照添加进Map的顺序实现遍历

|-----TreeMap：需要按照key所在类的指定属性进行排序。要求key是同一个类的对象。对key考虑使用自然排序 或 定制排序

|-----Hashtable：是一个古老的实现类，线程安全的，不可以添加null键，null值不建议使用。

|-----子类：Properties：常用来处理属性文件

Iterator接口：用来遍历集合Collection元素

Collections工具类：操作Collection及Map的工具类，大部分为static的方法。

附：Properties的使用

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

代码块：

/*
 * 1.存储对象可以考虑：①数组 ②集合
 * 2.数组存储对象的特点：Student[] stu = new Student[20]; stu[0] = new Student();....
 * >弊端：①一旦创建，其长度不可变。②真实的数组存放的对象的个数是不可知。
 * 3.集合
 * Collection接口
 * 		|------List接口：存储有序的，可以重复的元素
 * 				|------ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的） 

 * 		|------Set接口：存储无序的，不可重复的元素
 * 				|------HashSet、LinkedHashSet、TreeSet
 * Map接口：存储“键-值”对的数据
 * 		|-----HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)
 */
public class TestCollection {
	@Test
	public void testCollection3() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add(new String("AA"));
		// 10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素。
		coll.removeAll(coll1);
		System.out.println(coll);
		//11.equals(Object obj):判断集合中的所有元素是否完全相同
		Collection coll2 = new ArrayList();
		coll2.add(123);
		coll2.add(new String("AA1"));
		System.out.println(coll1.equals(coll2));
		//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());
		}
	}
	@Test
	public void testCollection2() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		// Person p = new Person("MM",23);
		coll.add(new Person("MM", 23));
		System.out.println(coll);
		// 6.contains(Object obj):判断集合中是否包含指定的obj元素。如果包含，返回true，反之返回false
		// 判断的依据：根据元素所在的类的equals()方法进行判断
		// 明确：如果存入集合中的元素是自定义类的对象。要求：自定义类要重写equals()方法！
		boolean b1 = coll.contains(123);
		b1 = coll.contains(new String("AA"));
		System.out.println(b1);
		boolean b2 = coll.contains(new Person("MM", 23));
		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);
		coll1.add(456);
		// 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 testCollection1() {
		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);
		// 4.isEmpty():判断集合是否为空
		System.out.println(coll.isEmpty());
		// 5.clear():清空集合元素
		coll.clear();
		System.out.println(coll.isEmpty());
	}
}

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

public class TestIterator {
	//面试题：
	@Test
	public void testFor3(){
		String[] str = new String[]{"AA","BB","DD"};
		for(String s : str){
			s = "MM";//此处的s是新定义的局部变量，其值的修改不会对str本身造成影响。
			System.out.println(s);
		}		
		
		for(int i = 0;i < str.length;i++){
			System.out.println(str[i]);
		}
	}
	@Test
	public void testFor2(){
		String[] str = new String[]{"AA","BB","DD"};
		for(int i = 0;i < str.length;i++){
			str[i] = i + "";
		}
		
		for(int i = 0;i < str.length;i++){
			System.out.println(str[i]);
		}
	}
	
	//***********************************************
	//使用增强for循环实现数组的遍历
	@Test
	public void testFor1(){
		String[] str = new String[]{"AA","BB","DD"};
		for(String s:str){
			System.out.println(s);
		}
	}
	
	//使用增强for循环实现集合的遍历 

	@Test
	public void testFor(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		for(Object i:coll){
			System.out.println(i);
		}
	}
	
	//错误的写法
	@Test
	public void test2(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Iterator i = coll.iterator();
		
		while((i.next())!= null){
			//java.util.NoSuchElementException
			System.out.println(i.next());
		}
	}
	//正确的写法：使用迭代器Iterator实现集合的遍历
	@Test
	public void test1(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Iterator i = coll.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
	}
}
 

/*
 * 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(Object
	 * key) 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);
	}
}

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

閱讀更多 異現場調查科 的文章

關鍵字: Object println 接口