第十三节、轻松学Java_集合

集合的概述

集合按照其存储结构可以分为两大类： 单列集合 Collection 和双列集合 Map。
Collection两个重要的子接口List 和 Set。 List 接口的主要接口实现类有两个： ArrayList 和 LinkedList， 而 Set 接口的主要接口实现类也有两个： HashSet 和 TreeSet。
Map 接口的主要接口实现类有两个： HashMap 和 TreeMap。

package com.test;

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class Test {
	public static void main(String[] args) {
		String a = "A";
		String b = "B";
		String c = "C";
		Collection<String> list = new ArrayList<String>();
		list.add(a); // 通过add(E obj)方法添加指定对象到集合中
		list.add(b);
		
		Collection<String> list2 = new ArrayList<String>();
		// 通过addAll(Collection<? extends E> col)方法添加指定集合中的所有对象到该集合中
		list2.addAll(list);
		list2.add(c);
		Iterator<String> it = list2.iterator(); // 通过iterator()方法序列化集合中的所有对象
		while (it.hasNext()) {
			String str = it.next(); // 因为对实例it 进行了泛化，所以不需要进行强制类型转换
			System.out.println(str);
		}

		// 通过containsAll()方法查看在该集合中是否存在指定集合中的所有对象，并获得返回信息
		boolean isContains = list.containsAll(list2);
		System.out.println(isContains);
		
		// 通过retainAll()方法仅保留该集合中同时包含在指定集合中的对象，并获得返回信息
		boolean isContains2 = list.retainAll(list2);
		System.out.println(isContains2);
		Iterator<String> it2 = list.iterator();
		while (it2.hasNext()) {
			String str = it2.next();
			System.out.println(str);
		}

		// 通过removeAll()方法从该集合中移除同时包含在指定集合中的对象，并获得返回信息
		boolean isContains1 = list2.removeAll(list);
		System.out.println(isContains1);
		Iterator<String> it1 = list2.iterator();
		while (it1.hasNext()) {
			String str = it1.next();
			System.out.println(str);
		}
	}
}

输出：
A
B
C
false
false
A
B
true
C

List集合

List集合为列表类型，以线性方式存储对象。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。用户可以通过索引来访问List中的元素。

ArrayList集合

ArrayList支持可随需要而增长的动态数组。

package com.test;

import java.util.ArrayList;
public class Test {
	public static void main(String args[]) {
		// 创建一个ArrayList 对象
		ArrayList al = new ArrayList();
		System.out.println("a1 的初始化大小：" + al.size());
		// 向ArrayList 对象中添加新内容
		al.add(new Integer(1)); // 0 位置
		al.add(new Integer(2)); // 1 位置
		al.add(new Integer(3)); // 2 位置
		al.add(new Integer(4)); // 3 位置
		al.add(new Integer(5)); // 4 位置
		al.add(new Integer(6)); // 5 位置
		// 把A2 加在ArrayList 对象的第2 个位置
		al.add(1, new Integer(0)); // 加入之后的内容：C A2 A E B D F
		System.out.println("a1 加入元素之后的大小：" + al.size());
		// 显示Arraylist 数据
		System.out.println("a1 的内容: " + al);
		// 从ArrayList 中移除数据
		al.remove(2); // C A2 E B D
		System.out.println("a1 删除元素之后的大小: " + al.size());
		System.out.println("a1 的内容: " + al);
		
		// 得到对象数组
		Object ia[] = al.toArray();
		int sum = 0;
		// 计算数组内容
		for (int i = 0; i < ia.length; i++)
			sum += ((Integer) ia[i]).intValue();
		System.out.println("数组累加结果是：" + sum);
	}
}

输出：
a1 的初始化大小：0
a1 加入元素之后的大小：7
a1 的内容: [1, 0, 2, 3, 4, 5, 6]
a1 删除元素之后的大小: 6
a1 的内容: [1, 0, 3, 4, 5, 6]
数组累加结果是：19

LinkedList集合

除了LinkedList类继承的方法外，它本身还定义了一些有用的方法。
使用addFirst()方法可以在列表头增加元素，使用addLast()方法可以在列表的尾部增加元素。
使用getFirst()方法可以获得第一个元素，使用getLast()方法可以得到最后一个元素。
使用removeFirst()方法可以删除第一个元素，使用removeLast()方法可以删除最后一个元素。

package com.test;

import java.util.LinkedList;
public class Test {
	public static void main(String args[]) {
		// 创建LinkedList 对象
		LinkedList ll = new LinkedList();
		// 加入元素到LinkedList 中
		ll.add("F");
		ll.add("B");
		ll.add("D");
		ll.add("E");
		ll.add("C");
		// 在链表的最后一个位置加上数据
		ll.addLast("Z");
		// 在链表的第一个位置上加入数据
		ll.addFirst("A");
		// 在链表的第二个元素的位置上加入数据
		ll.add(1, "A2");
		System.out.println("ll 最初的内容：" + ll);
		// 从linkedlist 中移除元素
		ll.remove("F");
		ll.remove(2);
		System.out.println("从ll 中移除内容之后：" + ll);
		// 移除第1 个和最后一个元素
		ll.removeFirst();
		ll.removeLast();
		System.out.println("ll 移除第一个和最后一个元素之后的内容：" + ll);
		// 取得并设置值
		Object val = ll.get(2);
		ll.set(2, (String) val + " Changed");
		System.out.println("ll 被改变之后：" + ll);
	}
}

输出：
ll 最初的内容：[A, A2, F, B, D, E, C, Z]
从ll 中移除内容之后：[A, A2, D, E, C, Z]
ll 移除第一个和最后一个元素之后的内容：[A2, D, E, C]
ll 被改变之后：[A2, D, E Changed, C]

Set集合

Set集合中的对象不按特定的方式排序，但是Set集合中不能包含重复对象。Set集合继承自Collection接口，因此包含Collection接口的所有方法。

HashSet集合

需要注意的是，散列集合并不能确定元素的排列顺序，通常无法干预排序集合的创建，如果需要排序，另一种类集TreeSet将是一个更好的选择。

TreeSet集合

对象按升序存储， 访问和检索是很快的。 在存储了大量的需要进行快速检索的排序信息的情况下， TreeSet 是一个很好的选择。

package com.test;
import java.util.TreeSet;
public class Test {
	public static void main(String args[]) {
		// 创建TreeSet 对象
		TreeSet ts = new TreeSet();
		// 加入元素到TreeSet 中
		ts.add("C");
		ts.add("A");
		ts.add("B");
		ts.add("E");
		ts.add("F");
		ts.add("D");
		System.out.println(ts);
	}
}

输出：
[A, B, C, D, E, F]

Map集合

Map中不能包含相同的键，每个键只能映射一个值。

HashMap集合

散列映射并不保证它的元素的顺序，因此元素加入三列映射的顺序并不一定是它们被迭代方法读出的顺序。

TreeMap集合

TreeMap提供了按顺序存储键-值对的有效手段，同时允许快速检索，树映射保证它的元素按照键升序排序。

package com.test;
import java.util.TreeMap;
import java.util.Iterator;
import java.util.Collection;
public class Test {
	public static void main(String args[]) {
		// 创建TreeMap 对象
		TreeMap tm = new TreeMap();
		// 加入元素到TreeMap 中
		tm.put(new Integer(2000), "张三");
		tm.put(new Integer(1500), "李四");
		tm.put(new Integer(2500), "王五");
		tm.put(new Integer(5000), "赵六");
		//获得值，将值按照键排序
		Collection col = tm.values();
		Iterator i = col.iterator();
		System.out.println("按工资由低到高顺序输出：");
		while (i.hasNext()) {
			System.out.println(i.next());
		}
	}
}

输出：
按工资由低到高顺序输出：
李四
张三
王五
赵六

Properties集合

键和值都是字符串。

package com.test;
import java.util.Set;
import java.util.Iterator;
import java.util.Properties;
public class Test {
	public static void main(String args[]) {
		Properties capitals = new Properties();
		Set states;
		String str;
		capitals.put("中国", "北京");
		capitals.put("俄罗斯", "莫斯科");
		capitals.put("日本", "东京");
		capitals.put("法国", "巴黎");
		capitals.put("英国", "伦敦");
		// 返回映射中包含的项的集合
		states = capitals.keySet();
		Iterator itr = states.iterator();
		while (itr.hasNext()) {
			str = (String) itr.next();
			//getProperty返回与键相关联的值
			System.out.println("国家：" + str + " ，首都：" + capitals.getProperty(str) + ".");
		}
		// 查找列表，如果没有则显示为默认的返回值：“没有发现”
		str = capitals.getProperty("美国", "没有发现");
		System.out.println("美国的首都：" + str + ".");
	}
}

输出;
国家：法国 ，首都：巴黎.
国家：俄罗斯 ，首都：莫斯科.
国家：中国 ，首都：北京.
国家：日本 ，首都：东京.
国家：英国 ，首都：伦敦.
美国的首都：没有发现.

Properties还有一个有用之处就是利用store()和load()方法方便地对包含在Properties对象中的信息进行存储或从盘中装入信息。

package com.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
public class Test {
	public static void main(String[] args) {
		Properties settings = new Properties();
		try {
			settings.load(new FileInputStream("c:\\count.java"));
		} catch (Exception e) {
			settings.setProperty("count", new Integer(0).toString());
		}
		int c = Integer.parseInt(settings.getProperty("count")) + 1;
		System.out.println("这是本程序第" + c + "次被使用");
		settings.put("count", new Integer(c).toString());
		try {
			settings.store(new FileOutputStream("c:\\count.java"), "PropertiesFile use it .");
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

Stack集合

是Vector的一个子类，它实现标准的后进先出堆栈。

package com.test;

import java.util.Stack;
import java.util.EmptyStackException;
public class Test {
	static void showpush(Stack st, int a) {
		st.push(new Integer(a));
		System.out.println("入栈(" + a + ")");
		System.out.println("Stack: " + st);
	}

	static void showpop(Stack st) {
		System.out.print("出栈 -> ");
		Integer a = (Integer) st.pop();
		System.out.println(a);
		System.out.println("Stack: " + st);
	}

	public static void main(String args[]) {
		Stack st = new Stack();
		System.out.println("Stack: " + st);
		showpush(st, 42);
		showpush(st, 66);
		showpush(st, 99);
		showpop(st);
		showpop(st);
		showpop(st);
		// 出栈的时候会有一个EmptyStackException 的异常，需要进行异常处理
		try {
			showpop(st);
		} catch (EmptyStackException e) {
			System.out.println("出现异常：栈中内容为空");
		}
	}
}

输出：
Stack: [42, 66]
入栈(99)
Stack: [42, 66, 99]
出栈 -> 99
Stack: [42, 66]
出栈 -> 66
Stack: [42]
出栈 -> 42
Stack: []
出栈 -> 出现异常：栈中内容为空

Vector集合

是实现动态数组，与ArrayList相似，但是Vector是同步的。

package com.test;

import java.util.Vector;
import java.util.Iterator;
public class Test {
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("A");
		v.add("B");
		v.add("C");
		v.add("D");
		v.add("E");
		v.add("F");
		Iterator e = v.iterator();
		while (e.hasNext()) {
			System.out.print(e.next() + "\t");
		}
	}
}

输出;
A B C D E F