JAVA范例 十二）Java高级开发技术

     12.1 Set

　　实例204 利用HashSet删除学生

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class demoHashSet {
	public static void main(String args[]) {
		HashSet stu = new HashSet();			// 创建一个String类型的哈希表
		Scanner in = new Scanner(System.in); 	// 准备从键盘输入
		String name;
		System.out.println("请依次输入学生姓名，空行表示结束");
		boolean goon = true;
		while (goon) { 						// 循环输入学生姓名
			name = in.nextLine();
			if (name.length() > 0) 			// 若读入了空行，则name的长度为0
				stu.add(name); 			// 插入到哈希表中
			else
				goon = false;
		}
		System.out.println("请输入要删除的学生姓名，空行表示结束");
		goon = true;
		while (goon) { 						// 循环删除指定的学生
			name = in.nextLine();
			if (name.length() > 0) {
				if (stu.remove(name)) 		// 删除指定元素
					System.out.println("删除成功: " + name);
				else
					System.out.println("没有找到此人: " + name);
			} else
				goon = false;
		}
		System.out.println("还剩下的学生有：");
		Iterator iterator = stu.iterator();// 将HashSet转换成Iterator对象
		while (true) {
			if (iterator.hasNext()) {			// 判断是否还有下一个元素
				System.out.println(iterator.next().toString());	// 有则将下一个元素输出
			} else {
				break;								// 没有则退出循环
			}
		}
		in.close();										// 关闭输入流
	}
}

 

　　实例205 不重复的随机数序列

package list;

import java.util.*;

public class RandomSort {
	private int minValue; // 最小值

	private int maxValue; // 最大值

	public RandomSort() { // 构造方法初始化变量
		this.minValue = 0;
		this.maxValue = 10;
	}

	public RandomSort(int minValue, int maxValue) { // 带参数构造方法初始化变量
		this(); // 调用上面的构造方法
		if (maxValue >= minValue) {
			this.minValue = minValue;
			this.maxValue = maxValue;
		} else {
			System.out.println("最大值小于最小值，按缺省值进行赋值！");
		}
	}

	public static void main(String[] args) { // java程序主入口处
		RandomSort rs = new RandomSort(3, 12);
		System.out.println("<1> 运用排除法生成不重复的随机数序列");
		printArray(rs.exclusionSort(6));
		System.out.println("<2> 运用筛选法生成不重复的随机数序列");
		printArray(rs.proceduresSort(6));
	}

	public Integer[] exclusionSort(int len) { // 运用排除法生成不重复的随机数序列
		if (len <= 0) { // 判断传入的数值
			return new Integer[0];
		} else if (len > (this.maxValue - this.minValue)) {
			System.out.println("长度不能达到:" + len + ", 长度只能是："
					+ (this.maxValue - this.minValue));
			len = this.maxValue - this.minValue; // 重新赋值
		}
		Random random = new Random(); // 用于生成随机对象
		List rlist = new ArrayList(); // 创建列表对象
		while (rlist.size() < len) {
			// 将[minValue, maxValue]区间等价于min + [0, maxValue - minValue + 1)
			// 生成随机数
			Integer randnum = new Integer(this.minValue
					+ random.nextInt(this.maxValue - this.minValue + 1));
			if (!rlist.contains(randnum)) { // 判断列表中是否包含对象
				rlist.add(randnum); // 添加整型对象
			}
		}
		return (Integer[]) rlist.toArray(new Integer[0]); // 将列表转换成整型数组返回
	}

	public Integer[] proceduresSort(int len) { // 运用筛选法生成不重复的随机数序列
		if (len <= 0) {
			return new Integer[0];
		} else if (len > (this.maxValue - this.minValue)) {
			System.out.println("长度不能达到:" + len + ", 长度只能是："
					+ (this.maxValue - this.minValue));
			len = this.maxValue - this.minValue;
		}
		int numLength = this.maxValue - this.minValue + 1; // 初始化列表长度
		List alist = new ArrayList();
		for (int i = this.minValue; i <= this.maxValue; i++) { // 循环依次获得整数
			alist.add(new Integer(i)); // 在列表中添加整型数据
		}
		Random rd = new Random(); // 用于生成随机下标
		List rlist = new ArrayList(); // 创建列表对象
		while (rlist.size() < len) {
			int index = rd.nextInt(numLength); // 生成在[0,numLength)范围内的下标
			rlist.add(alist.get(index)); // 下标为index数字对象放入列表对象中
			alist.remove(index); // 移除下标为index的数字对象
			numLength--; // 候选队列长度减去1
		}
		return (Integer[]) rlist.toArray(new Integer[0]); // 将列表转换成整型数组返回
	}

	public static void printArray(Integer[] data) { // 显示数组元素
		if (data != null) { // 判断数组是否为空
			for (int i = 0; i < data.length; i++) { // 循环显示数组数据
				System.out.print(data[i] + "\t");
			}
		}
		System.out.println(); // 换行
	}

}

 

　　实例206 运用映射的相关类（Map）

package list;

import java.util.*;

public class MyMapClass {
	public static void main(String[] args) { // java程序主入口处
		printHashMap(); // 操作HashMap显示图书种类
		printHashtable(); // 操作Hashtable显示图书种类
		printTreeMap(); // 操作TreeMap显示图书种类
		printArrayList(); // 操作ArrayList显示图书种类
	}

	public static void printHashMap() { // 操作HashMap的方法
		Map map = new HashMap(); // hashMap是无序的
		map.put("01", "计算机类图书");
		map.put("02", "外语类图书");
		map.put("03", "音乐类图书");
		map.put("04", "人文类图书");
		map.put("05", "医学类图书");
		map.put("06", null);
		map.put(null, "食谱类图书");
		Iterator iterator = map.keySet().iterator(); // 获得迭代器Iterator
		System.out.println("<1> 操作HashMap显示图书种类");
		while (iterator.hasNext()) { // 循环获得每个对象
			Object key = iterator.next(); // 获得每个键元素
			System.out.print(map.get(key) + "\t"); // 输出值
		}
		System.out.println();
	}

	public static void printHashtable() { // 操作Hashtable的方法
		Hashtable hashTable = new Hashtable(); // Hashtable是无序的
		hashTable.put("01", "计算机类图书");
		hashTable.put("02", "外语类图书");
		hashTable.put("03", "音乐类图书");
		hashTable.put("04", "人文类图书");
		hashTable.put("05", "医学类图书");
		Iterator iterator = hashTable.keySet().iterator();// 获得迭代器Iterator
		System.out.println("<2> 操作Hashtable显示图书种类");
		while (iterator.hasNext()) { // 循环获得每个对象
			Object key = iterator.next(); // 获得每个键元素
			System.out.print(hashTable.get(key) + "\t");// 输出值
		}
		System.out.println();
	}

	public static void printTreeMap() { // 操作TreeMap的方法
		TreeMap treeMap = new TreeMap(); // Hashtable是无序的
		treeMap.put("01", "计算机类图书");
		treeMap.put("02", "外语类图书");
		treeMap.put("03", "音乐类图书");
		treeMap.put("04", "人文类图书");
		treeMap.put("05", "医学类图书");
		treeMap.put("06", null);
		Iterator iterator = treeMap.keySet().iterator(); // 获得迭代器Iterator
		System.out.println("<3> 操作TreeMap显示图书种类");
		while (iterator.hasNext()) { // 循环获得每个对象
			Object key = iterator.next(); // 获得每个键元素
			System.out.print(treeMap.get(key) + "\t"); // 输出值
		}
		System.out.println();
	}

	public static void printArrayList() { // 操作有序的ArrayList列表集合
		ArrayList arrayList = new ArrayList(); // 创建列表集合对象
		arrayList.add("01 计算机类图书");
		arrayList.add("03 音乐类图书");
		arrayList.add("06 食谱类图书");
		arrayList.add("04 人文类图书");
		arrayList.add("05 医学类图书");
		arrayList.add("02 外语类图书");
		System.out.println("<4> 排序前的图书种类");
		for (int i = 0; i < arrayList.size(); i++) { // 循环显示列表集合中的元素
			System.out.print(arrayList.get(i) + "\t");
		}
		System.out.println();
		Collections.sort(arrayList); // 对列表集合进行排序
		System.out.println("<5> ArrayList排序后图书种类");
		for (int i = 0; i < arrayList.size(); i++) { // 循环显示列表集合中的元素
			System.out.print(arrayList.get(i) + "\t");
		}
		System.out.println();
	}

}

 

　　实例207 运用集的相关类（Set）

package list;

import java.util.*;

public class MySetClass {
	public static void main(String[] args) { // java程序主入口处
		hashSetResult();
		treeSetResult();
		linkedHashSetResult();
		Set hashSet = new HashSet();
		addSetElement(hashSet);
		hashSet.add("经济法基础"); // Set不允许元素重复
		hashSet.add("初级会计实务");
		System.out.println("\n为hashSet加入经济法基础, 初级会计实务元素后->: ");
		showElement(hashSet); // 调用方法显示元素
		hashSet.remove("财务管理"); // 删除元素
		System.out.println("\nhashSet删除财务管理元素后->: ");
		showElement(hashSet); // 调用方法显示元素
		List list = new ArrayList(); // 创建一个列表集合
		list.add("经济法基础");
		list.add("经济法");
		list.add("财务管理");
		hashSet.addAll(list); // 将列表集合添加到Set中
		System.out.println("\nhashSet添加一个集合的所有元素后->: ");
		showElement(hashSet);
		hashSet.retainAll(list); // 删除除列表集合中的元素之外的元素
		System.out.println("\nhashSet删除除了列表集合之外的元素后->: ");
		showElement(hashSet); // 调用方法显示元素
		hashSet.removeAll(list); // 删除集合中的元素
		System.out.println("\nhashSet删除集合中的元素后->: ");
		showElement(hashSet); // 调用方法显示元素
		// 获取Set中元素的个数
		System.out.println("\thashSet中当前元素的个数: " + hashSet.size());
		// 判断Set中的元素是否为空
		System.out.println("\thashSet中当前元素为0？  " + hashSet.isEmpty());
	}

	public static void hashSetResult() { // 使用HashSet操作元素
		Set hashSet = new HashSet();
		addSetElement(hashSet); // 调用方法初始化元素
		System.out.println("使用HashSet存储的数据元素如下->： ");
		showElement(hashSet); // 调用方法显示元素
	}

	public static void treeSetResult() { // 使用TreeSet操作元素
		Set treeSet = new TreeSet();
		addSetElement(treeSet); // 调用方法初始化元素
		System.out.println("\n使用TreeSet存储的数据元素如下->：");
		showElement(treeSet); // 调用方法显示元素
	}

	public static void linkedHashSetResult() { // 使用LinkedHashSet操作元素
		Set linkedHashSet = new LinkedHashSet();
		addSetElement(linkedHashSet); // 调用方法初始化元素
		System.out.println("\n使用LinkedHashSet存储的数据元素如下->：");
		showElement(linkedHashSet); // 调用方法显示元素
	}

	public static void addSetElement(Set set) { // 初始化Set的元素
		if (set != null) {
			set.add("经济法基础");
			set.add("初级会计实务");
			set.add("财务管理");
			set.add("经济法");
			set.add("中级会计实务");
		}
	}

	public static void showElement(Set set) { // 输出set的元素
		if (set != null && set.size() > 0) {
			Iterator it = set.iterator(); // 获得迭代器Iterator
			while (it.hasNext()) { // 循环获得Set每个元素
				System.out.print(it.next() + " ");
			}
		} else {
			System.out.println("没有元素！");
		}
		System.out.println(); // 换行
	}

}

 

　　12.2 List 368

　　实例208 增加所需的元素

import java.util.Vector;

public class addElement {
	public static void main(String[] args) {
		// 创建一个Vector对象,容量初始化为5
		Vector vec = new Vector(5); 		// 这时参数与返回值都必须为String类型
		vec.addElement(new String("one")); // 添加一个字符串对象
		vec.addElement("three");
		vec.addElement("four");
		vec.insertElementAt("zero", 0); 	// 在位置0插入一个字符串对象
		vec.insertElementAt("two", 2);
		vec.insertElementAt("five", 5);
		System.out.println("vec:" + vec); 	// 输出Vector对象中的元素值
		System.out.println("vec的容量为：" + vec.capacity()); 	// 输出Vector对象的容量
		// 创建一个Vector对象,容量初始化为5,容量的增量为1
		Vector vector = new Vector(5, 1); 					// 这时参数与返回值都必须为String类型
		vector.addElement("one"); 						// 添加一个字符串对象
		vector.addElement("three");
		vector.addElement("four");
		vector.insertElementAt("zero", 0); 					// 在位置0插入一个字符串对象
		vector.insertElementAt("two", 2);
		vector.insertElementAt("five", 5);
		System.out.println("vector:" + vector);
		System.out.println("vector的容量为：" + vector.capacity()); // 输出Vector对象的容量
	}
}

 

　　实例209 Iterator迭代器的使用

package list;

import java.util.ArrayList; //引入类
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

public class MyIterator {
	public static void main(String[] args) { // java程序主入口处
		addFood(); // 调用方法获得书目
	}

	public static void addFood() { // 查看冰箱中的食物
		List list = new ArrayList(5); // 创建容量为5的列表集合
		list.add("面包"); // 添加元素(对象)，向冰箱中添加食物
		list.add("香肠");
		list.add("薯片");
		list.add("牛奶");
		System.out.println("第一次打开冰箱里面的食物有:");
		for (Iterator iter = list.iterator(); iter.hasNext();) { // 使用Iterator进行循环
			Object obj = iter.next(); // 获得每个元素(对象)
			System.out.print(obj + "\t");
			if ("香肠".equals(obj)) // 第一次想要吃掉香肠，所以先判断哪个是香肠（判断元素）
				iter.remove(); // 选择正确后吃掉（移除对象）
		}
		System.out.println();
		System.out.println("第二次打开冰箱里面的食物有：");
		Iterator it = list.iterator(); // 获得Iterator对象
		while (it.hasNext()) { // 只要有元素(对象)便进行循环，第二次打开冰箱时香肠已经不存在了
			System.out.print(it.next() + "\t");
		}
		System.out.println();
	}
}

 

　　实例210 谁是幸运儿

import java.util.Iterator;
import java.util.LinkedList;

public class luckyDog {
	public static void main(String args[]) {
		// 创建一个元素类型为Integer的链表
		LinkedList lucky = new LinkedList();
		int number, cnt;
		// 将每个人的编号依次放入到链表中
		for (number = 1; number <= 100; ++number)
			lucky.addLast(number);
		cnt = 100;
		number = 0;
		Iterator it = lucky.iterator();
		// 循环删除退出的人，直到只剩下一个人
		while (cnt > 1) {
			if (it.hasNext()) {
				it.next(); 		// 往后面数
				++number; 	// 计数器加1
			} else { 			// 迭代器已经到达末尾，重新将它置回到链表头部
				it = lucky.iterator();
			}
			// 删除应该退出圈外的人
			if (number == 14) {
				number = 0;
				it.remove();
				--cnt;
			}
		}
		// 最后链表中剩下的就是幸运儿
		System.out.println("幸运儿编号为：" + lucky.element());
	}
}

 

　　实例211 自定义Queue队列

package list;

import java.util.LinkedList;

public class MyQueue {
	private LinkedList link = new LinkedList();

	public MyQueue() {

	}

	/** 向队列添加一个元素，只能加入到队尾 */
	public void m_add(Object obj) {
		this.link.addLast(obj);
	}

	/** 查看队首元素，数据还保留在队列中 */
	public Object m_peek() {
		if (link.isEmpty()) {
			System.out.println("队列中没有元素！");
			return null;
		}
		return link.getFirst();
	}

	/** 删除队首元素 */
	public boolean m_remove() {
		if (link.isEmpty()) {
			System.out.println("队列中没有元素！");
			return false;
		}
		link.removeFirst();
		return true;
	}

	/** 弹出元素，即获取队首元素并将其从队列中删除 */
	public Object m_pop() {
		if (link.isEmpty()) {
			System.out.println("队列中没有元素！");
			return null;
		}
		return link.removeFirst();
	}

	/** 在队列中查找元素，返回第一次出现的位置 */
	public int m_indexOf(Object obj) {
		return link.indexOf(obj);
	}

	/** 在队列中查找元素，返回最后一次出现的位置 */
	public int m_lastIndexOf(Object obj) {
		return link.lastIndexOf(obj);
	}

	/** 判断队列是否为空 */
	public boolean m_isEmpty() {
		return link.isEmpty();
	}

	/** 清除队列中所有元素 */
	public void m_clear() {
		link.clear();
	}

	public static void main(String[] args) {
		MyQueue myQueue = new MyQueue();
		// 向队列插入元素
		myQueue.m_add("Apple");
		myQueue.m_add("Orange");
		myQueue.m_add("Banana");
		myQueue.m_add("Orange");
		myQueue.m_add("Banana");
		myQueue.m_add("Orange");
		System.out.println("排在队列中第一个位的数据是: " + myQueue.m_peek()); // 获取第一个元素
		// 获取第一个元素并删除
		System.out.println("第一个先出队的数据是: " + myQueue.m_pop());
		// 查找bbb第一次出现的位置
		System.out
				.println("Orange第一次在队列中出现的位置是：" + myQueue.m_indexOf("Orange"));
		// 查找bb最后一次出现的位置
		System.out.println("Orange最后一次在队列中出现的位置是："
				+ myQueue.m_lastIndexOf("Orange"));
		myQueue.m_clear(); // 清除队列中的所有元素
		// 判断队列中的元素个数是否为0
		System.out.print("队列中是否还存在元素？ ");
		System.out.println(myQueue.m_isEmpty() ? "没有元素存在" : "还有元素存在");
	}

}

 

　　实例212 List、Set与Array之间的相互转换

package list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class Transtormation {
	public static void main(String[] args) {

		List list = new ArrayList();// 创建List列表
		// 往List列表中添加数据元素
		list.add("北京");
		list.add("上海");
		list.add("青岛");
		list.add("大连");
		list.add("浙江");
		// 当List中的数据类型都一致时，可以将list转化成数组
		// 转化成对象数组时，直接调用toArray方法
		Object[] arrObject = list.toArray();
		System.out.println("从list转化成的对象数组的长度为: " + arrObject.length);
		System.out.println("我们都是Object类型的");
		for (int i = 0; i < arrObject.length; i++) {
			System.out.print("\t" + arrObject[i]);

		}
		// 在转化成其他类型的数组时，需要强制类型转换，并且，要使用带参数的toArray方法。
		// toArray方法的参数为一个对象数组，将list中的内容放入参数数组中
		// 当参数数组的长度小于list的元素个数时，会自动扩充数组的长度以适应list的长度
		String[] arrString_1 = (String[]) list.toArray(new String[0]);
		System.out.println("\n从list转化成的字符串数组的长度为: " + arrString_1.length);
		System.out.println("我们都是String类型的");
		for (int i = 0; i < arrString_1.length; i++) {
			System.out.print("\t" + arrString_1[i]);

		}
		// 分配一个长度与list的长度相等的字符串数组。
		String[] arrString_2 = (String[]) list.toArray(new String[list.size()]);
		System.out.println("\n从list转化成的字符串数组的长度为: " + arrString_2.length);
		System.out.println("我们都是String类型的");
		for (int i = 0; i < arrString_2.length; i++) {
			System.out.print("\t" + arrString_2[i]);

		}
		list.clear();// 清空List

		// 将数组转化成List
		// 逐个添加到List
		for (int i = 0; i < arrObject.length; i++) {
			list.add(arrObject[i]);
		}
		System.out.println("\n从数组转化成的list的元素个数: " + arrObject.length);
		list.clear();// 清空List
		// 直接使用Arrays类的asList方法
		list = Arrays.asList(arrObject);
		for (int i = 0; i < list.size(); i++) {
			Object ob = list.get(i);
			System.out.print("\t" + ob.toString());
		}
		System.out.println("\n从数组转化成的list的元素个数: " + arrObject.length);

		Set set = new HashSet();
		set.add("北京");
		set.add("上海");
		// Set转化成数组
		arrObject = set.toArray();
		arrString_1 = (String[]) set.toArray(new String[0]);
		arrString_2 = (String[]) set.toArray(new String[set.size()]);

		// 数组转换成Set
		// 将数组转换成List后，再用List构造Set
		set = new HashSet(Arrays.asList(arrObject));
		// 将Set清空，然后把数组转换成的List全部add
		set.clear();
		set.addAll(Arrays.asList(arrString_1));
		Iterator ite = set.iterator();
		while (true) {
			if (ite.hasNext()) {
				System.out.print("\t" + ite.next().toString());
			} else {
				break;
			}
		}
	}

}

 

　　实例213 二分查找法的实现方法

package list;

import java.util.*;

public class MyBinary {
	public static void main(String args[]) {
		ArrayList list = new ArrayList();// 创建一个ArrayList对象
		int key;// 声明要查找的数据
		Scanner in = new Scanner(System.in);// 声明Scanner对象，可由键盘输入数据
		boolean flag = true;
		int index;// 返回查找数据的下标值
		for (int i = 0; i < 10; i++)
			list.add(((int) (Math.random() * 100)) + "");// 将生成的随机数添加到ArrayList列表中
		Collections.sort(list);// 对ArrayList列表中的数据进行排序
		System.out.print("以按升序排序的数据如下：");
		show(list);// 显示列表中的数据
		System.out.println("请输入你要查找的数据，输入0结束本次查找：");
		while (flag) {
			System.out.print("请输入你要查找的数据：");
			key = in.nextInt();// 获得由键盘输入的数据
			if (key > 0) {
				index = Collections.binarySearch(list, key + ""); // 调用二分查找
				if (index >= 0)
					System.out.println("\t查找成功，在" + index + "号位置");
				else
					System.out.println("\t没有找到" + key);
			} else {
				System.out.println("结束查找！");
				flag = false;
			}

		}
		in.close();
	}

	public static void show(ArrayList list) {// 显示列表中的数据
		for (int i = 0; i < list.size(); i++) {
			String str = (String) list.get(i);// 获得列表中指定位置上的数据值
			System.out.print(str + " ");
		}
		System.out.println();
	}

}

 

　　实例214 模拟操作系统的进程调度

package list;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
public class MyPriotityQueue {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);
		myProcess process = new myProcess();
		// 创建Process类型的队列，以process为比较方法
		PriorityQueue<Process> priQue = new PriorityQueue<Process>(20, process);
		System.out.println("请依次输入进程被执行时所需要的时间，0表示结束：");
		boolean flag = true;
		int time;
		for (int count = 1; flag; count++) {
			System.out.print("进程" + count + "执行所需的时间：");
			time = in.nextInt();
			if (time > 0)
				priQue.add(new Process(count, time)); // 插入作业到队列，优先队列会自动调整它的位置
			else
				flag = false;
		}
		System.out.println("\n进程被调度的顺序是：");
		// 队列中所有元素依次从队头出列，即为调度的顺序
		while (priQue.size() > 0) {
			Process tj;
			tj = priQue.poll();
			System.out.println("进程" + tj.getNumber() + "执行所需的时间："
					+ tj.getTime());
		}
	}

}

class Process {
	private int processID; // 记录进程的编号

	private int time; // 记录进程所需时间

	public Process(int id, int time) {
		processID = id;
		this.time = time;
	}

	public int getNumber() {
		return processID;
	}

	public void setNumber(int id) {
		processID = id;
	}

	public int getTime() {
		return time;
	}

	public void setTime(int time) {
		this.time = time;
	}
}

class myProcess implements Comparator<Process> { // 比较的对象是job
	// 根据job对象所需时间来确定优先级
	public int compare(Process p1, Process p2) {
		if (p1.getTime() > p2.getTime())
			return 1;
		if (p1.getTime() < p2.getTime())
			return -1;
		return 0;
	}

}

 

　　实例215 利用栈将字符串逆序输出

package list;

import java.io.*;
import java.util.Stack;

public class MyStack {
	public static void main(String argv[]) {
		FileInputStream input;
		char ch;
		// 创建一个空栈，用于存放字符
		Stack stack = new Stack();
		try {
			input = new FileInputStream(FileDescriptor.in);
			System.out.println("请输入一行字符，相当于入栈操作：");
			while ((ch = (char) input.read()) != '\r')
				stack.push(Character.valueOf(ch));
			input.close();
			// 如果栈内还有元素，则反复输出
			System.out.println("\n数据被逆序输出，相当于出栈操作：");
			while (!stack.empty())
				System.out.print(stack.pop());
		} catch (IOException e) {
			System.out.println("输入输出流有误!");
		}
	}
}

 

　　实例216 动态的数组链表

package list;

public class MyLinkedList {
	public static void main(String[] args) {
		ImpQueue myQueue = new LinkedList(); // 实例化队列Queue对象
		myQueue.inQueue("\tThankyou"); // 添加元素入队
		myQueue.inQueue("\tThanks"); // 添加元素入队
		System.out.println("Queue队列中元素出队情况：");
		while (!myQueue.isEmpty()) { // 循环判断队列是否为空
			System.out.println(myQueue.outQueue()); // 不为空则输出队列中的元素
		}
		ImpStack myStack = new LinkedList(); // 实例化Stack栈对象
		System.out.println("\nStack栈中元素出栈情况：");
		myStack.push("\tabcdefg"); // 添加元素入栈
		myStack.push("\tgfedcba"); // 添加元素入栈
		while (!myStack.isEmpty()) { // 循环判断栈是否为空
			System.out.println(myStack.pop()); // 不为空则输出出栈元素
		}
	}

}

class LinkedList extends AbsMyList implements ImpQueue, ImpStack {
	private static class InnerMyEntry { // 静态内部类
		Object object; // 对象

		InnerMyEntry next; // 下一个对象

		InnerMyEntry previous; // 上一个对象

		// 带参数的构造方法进行初始化
		InnerMyEntry(Object object, InnerMyEntry next, InnerMyEntry previous) {
			this.object = object;
			this.next = next;
			this.previous = previous;
		}
	}

	private InnerMyEntry header = new InnerMyEntry(null, null, null);// 创建实体对象

	public LinkedList() { // 默认构造方法进行初始化
		this.header.next = this.header.previous = this.header;
	}

	private InnerMyEntry addBefore(Object o, InnerMyEntry e) { // 添加对象之前的操作方法
		InnerMyEntry newEntry = new InnerMyEntry(o, e, e.previous);// 创建实体对象
		newEntry.previous.next = newEntry;
		newEntry.next.previous = newEntry;
		this.len++;
		return newEntry;
	}

	public boolean add(Object o) { // 添加对象
		this.addBefore(o, header);
		return true;
	}

	public void clear() { // 清空对象
		InnerMyEntry e = this.header.next;
		while (e != this.header) { // 判断进行循环
			InnerMyEntry next = e.next;
			e.next = e.previous = null; // 清空对象
			e.object = null; // 清空对象
			e = next;
		}
		this.header.next = this.header.previous = this.header;
		this.len = 0;
	}

	public boolean isElement(Object o) { // 是否包含对象
		return this.indexOf(o) != -1;
	}

	public Object getElement(int index) { // 获得指定的对象
		InnerMyEntry myEntry = this.entry(index);
		if (myEntry == null)
			return null;
		return myEntry.object;
	}

	public int indexOf(Object o) { // 获得对象在栈或队列中的位置
		int index = 0;
		if (o == null) {
			for (InnerMyEntry e = this.header.next; e != this.header; e = e.next) {// 循环获得元素对象
				if (e.object == null)
					return index;
				index++;
			}
		} else {
			for (InnerMyEntry e = this.header.next; e != this.header; e = e.next) {// 循环获得元素对象
				if (o.equals(e.object))
					return index;
				index++;
			}
		}
		return -1;
	}

	public boolean deleteElement(Object o) { // 移除对象
		if (o == null) {
			// 循环获元素对象
			for (InnerMyEntry e = header.next; e != header; e = e.next) {
				if (e.object == null) {
					return this.deleteElement(e); // 移除对象
				}
			}
		} else {
			for (InnerMyEntry e = header.next; e != header; e = e.next) {// 循环获元素对象
				if (o.equals(e.object)) {
					return this.deleteElement(e); // 移除对象
				}
			}
		}
		return false;
	}

	public Object outQueue() { // 出队方法
		Object result = this.header.next.object; // 获得对象
		this.deleteElement(this.header.next); // 移除对象
		return result;
	}

	public void inQueue(String o) { // 入队方法
		this.addBefore(o, header); // 调方法添加对象
	}

	public Object pop() { // 出栈方法
		Object result = this.header.previous.object; // 获得对象
		this.deleteElement(this.header.previous); // 移除对象
		return result;
	}

	public void push(Object o) { // 入栈
		this.addBefore(o, header); // 调方法添加对象
	}

	private boolean deleteElement(InnerMyEntry e) { // 移除对象
		if (e == header) {
			return false;
		}
		e.previous.next = e.next; // 重新赋值
		e.next.previous = e.previous; // 重新赋值
		e.next = e.previous = null; // 清空
		e.object = null;
		this.len--;
		return true;
	}

	private InnerMyEntry entry(int index) { // 获得指定的对象
		if (index < 0 || index >= this.len) { // 判断指定元素的下标
			return null;
		}
		InnerMyEntry e = header;
		if (index < (this.len >> 1)) { // 判断循环获得指定的实体
			for (int i = 0; i <= index; i++)
				e = e.next;
		} else {
			for (int i = this.len; i > index; i--)
				e = e.previous;
		}
		return e;
	}
}

abstract class AbsMyList {
	protected int len = 0; // 长度

	protected AbsMyList() { // 默认构造方法
	}

	abstract public boolean add(Object o); // 抽象向链表末尾添加一个元素

	abstract public Object getElement(int index); // 获得指定元素

	abstract public boolean isElement(Object o); // 判断是否包含元素

	abstract int indexOf(Object o); // 判断元素的位置

	abstract public boolean deleteElement(Object o); // 移除元素

	abstract public void clear(); // 清空

	public int len() { // 获得长度大小
		return this.len;
	}

	public boolean isEmpty() { // 判断是否为空
		return this.len == 0;
	}
}

interface ImpQueue { // 队列接口
	void inQueue(String o); // 入队

	Object outQueue(); // 出队

	boolean isEmpty(); // 判断是否为空
}

interface ImpStack { // 栈接口
	void push(Object o); // 元素入栈

	Object pop(); // 元素出栈

	boolean isEmpty(); // 是否为空
}

 

　　实例217 你能猜出鱼是谁的宠物吗？

package list;

import java.util.ArrayList;

public class WhoseFish {
	private static String[] FIVEHOUSES = { "红房子", "白房子", "绿房子", "蓝房子", "黄房子" };// 定义5种不同颜色的房子

	private static String[] FIVEPERSONS = { "英国人", "瑞典人", "丹麦人", "挪威人", "德国人" };// 定义5种不同的国籍的人

	private static String[] FIVEDRINKS = { "茶", "咖啡", "牛奶", "啤酒", "水" };// 定义5种不同的饮料

	private static String[] FIVESMOKES = { "PalMal", "Dunhill", "BlMt",// 定义5种不同牌子的香烟
			"Prince", "Blends" };

	private static String[] FIVEPETS = { "狗", "鸟", "猫", "马", "鱼" };// 定义5种不同的宠物

	private int[][] co_Array; // 颜色数组

	private int[][] pe_Array; // 人员数组

	private int[][] dr_Array; // 饮料数组

	private int[][] sm_Array; // 烟数组

	private int[][] pet_Array; // 宠物数组

	private static int total = 0;

	public static void main(String args[]) { // java程序主入口处
		WhoseFish test = new WhoseFish(); // 实例化对象
		test.lookUp(); // 调用方法进行计算统计
		System.out.println("\n\t\t\t共计算出" + total + "组符合题意的答案。");
	}

	public void lookUp() { // 查找符合题意的答案
		init(); // 调用方法实始化数据
		for (int num1 = 0; num1 < co_Array.length; num1++) {
			if (!case4(num1))
				continue;
			if (!case14(num1))
				continue;
			for (int num2 = 0; num2 < pe_Array.length; num2++) {
				if (!case1(num2, num1))
					continue;
				if (!case8(num2))
					continue;
				for (int num3 = 0; num3 < dr_Array.length; num3++) {
					if (!case3(num2, num3))
						continue;
					if (!case5(num1, num3))
						continue;
					if (!case9(num3))
						continue;
					for (int num4 = 0; num4 < sm_Array.length; num4++) {
						if (!case7(num1, num4))
							continue;
						if (!case12(num4, num3))
							continue;
						if (!case13(num2, num4))
							continue;
						if (!case15(num4, num3))
							continue;
						for (int num5 = 0; num5 < pet_Array.length; num5++) {
							if (!case2(num2, num5))
								continue;
							if (!case6(num4, num5))
								continue;
							if (!case10(num4, num5))
								continue;
							if (!case11(num5, num4))
								continue;
							total++;
							answer(num1, num2, num3, num4, num5);
						}
					}
				}
			}
		}
	}

	public void init() { // 计算一组数据的组合方式
		ArrayList array = new ArrayList(); // 创建集合数组
		for (int num1 = 0; num1 < 5; num1++) {
			for (int num2 = 0; num2 < 5; num2++) {
				if (num2 == num1)
					continue;
				for (int num3 = 0; num3 < 5; num3++) {
					if (num3 == num2 || num3 == num1)
						continue;
					for (int num4 = 0; num4 < 5; num4++) {
						if (num4 == num3 || num4 == num2 || num4 == num1)
							continue;
						for (int num5 = 0; num5 < 5; num5++) {
							if (num5 == num4 || num5 == num3 || num5 == num2
									|| num5 == num1)
								continue;
							int oneArray[] = { num1, num2, num3, num4, num5 };
							array.add(oneArray);
						}
					}
				}
			}
		}
		co_Array = new int[array.size()][5]; // 创建颜色的二维数组
		for (int count = 0; count < array.size(); count++) { // 循环数组实始化房颜色数据
			co_Array[count] = (int[]) array.get(count);
		}
		pe_Array = co_Array;
		dr_Array = co_Array;
		sm_Array = co_Array;
		pet_Array = co_Array;
	}

	public boolean case1(int cy, int cl) { // 英国人住红色房子
		for (int i = 0; i < 5; i++) {
			if (pe_Array[cl][i] == 0) {
				if (co_Array[cy][i] == 0) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case2(int cy, int p) { // 瑞典人养狗
		for (int i = 0; i < 5; i++) {
			if (pe_Array[cy][i] == 1) {
				if (pet_Array[p][i] == 0) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case3(int cy, int d) { // 丹麦人喝茶
		for (int i = 0; i < 5; i++) {
			if (pe_Array[cy][i] == 2) {
				if (dr_Array[d][i] == 0) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case4(int cl) { // 绿色房子在白色房子左面
		int white = 0; // 白房子
		int green = 0; // 绿房子
		for (int i = 0; i < 5; i++) {
			if (co_Array[cl][i] == 1) {
				white = i;
			}
			if (co_Array[cl][i] == 2) {
				green = i;
			}
		}
		if (green < white)
			return true;
		else
			return false;
	}

	public boolean case5(int cl, int d) { // 绿色房子主人喝咖啡
		for (int i = 0; i < 5; i++) {
			if (co_Array[cl][i] == 2) {
				if (dr_Array[d][i] == 1) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case6(int s, int p) { // 抽PallMall香烟的人养鸟
		for (int i = 0; i < 5; i++) {
			if (sm_Array[s][i] == 0) {
				if (pet_Array[p][i] == 1) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case7(int cl, int s) { // 黄色房子主人抽Dunhill香烟
		for (int i = 0; i < 5; i++) {
			if (co_Array[cl][i] == 4) {
				if (sm_Array[s][i] == 1) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case8(int cy) { // 住在中间房子的人喝牛奶
		if (pe_Array[cy][0] == 3)
			return true;
		else
			return false;
	}

	public boolean case9(int d) { // 挪威人住第一间房
		if (dr_Array[d][2] == 2)
			return true;
		else
			return false;
	}

	public boolean case10(int s, int p) { // 抽Blends香烟的人住在养猫的人隔壁
		for (int i = 0; i < 5; i++) {
			if (sm_Array[s][i] == 4) {
				if (i < 4 && pet_Array[p][i + 1] == 2) {
					return true;
				}
				if (i > 0 && pet_Array[p][i - 1] == 2) {
					return true;
				}
				break;
			}
		}
		return false;
	}

	public boolean case11(int p, int s) { // 养马的人住抽Dunhill香烟的人隔壁
		for (int i = 0; i < 5; i++) {
			if (pet_Array[p][i] == 3) {
				if (i < 4 && sm_Array[s][i + 1] == 1) {
					return true;
				}
				if (i > 0 && sm_Array[s][i - 1] == 1) {
					return true;
				}
				break;
			}
		}
		return false;
	}

	public boolean case12(int s, int d) { // 抽BlueMaster的人喝啤酒
		for (int i = 0; i < 5; i++) {
			if (sm_Array[s][i] == 2) {
				if (dr_Array[d][i] == 3) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case13(int cy, int s) { // 德国人抽Prince香烟
		for (int i = 0; i < 5; i++) {
			if (pe_Array[cy][i] == 4) {
				if (sm_Array[s][i] == 3) {
					return true;
				} else
					break;
			}
		}
		return false;
	}

	public boolean case14(int c) { // 挪威人住蓝色房子隔壁
		if (co_Array[c][1] == 3)
			return true;
		else
			return false;
	}

	public boolean case15(int s, int d) { // 抽Blends香烟的人有一个喝水的邻居
		for (int i = 0; i < 5; i++) {
			if (sm_Array[s][i] == 4) {
				if (i < 4 && dr_Array[d][i + 1] == 4) {
					return true;
				}
				if (i > 0 && dr_Array[d][i - 1] == 4) {
					return true;
				}
				break;
			}
		}
		return false;
	}

	public void answer(int n1, int n2, int n3, int n4, int n5) {// 显示计算之后的每个数组找出对应答案
		System.out.println("第" + total + "组答案->:");
		System.out.println("1\t\t2\t\t3\t\t4\t\t5\t\t");
		for (int i = 0; i < 5; i++)
			// 循环显示房子数组数据
			System.out.print(FIVEHOUSES[co_Array[n1][i]] + "\t\t");
		System.out.println();
		for (int i = 0; i < 5; i++)
			// 循环显示人员数组数据
			System.out.print(FIVEPERSONS[pe_Array[n2][i]] + "\t\t");
		System.out.println();
		for (int i = 0; i < 5; i++)
			// 循环显示饮料数组数据
			System.out.print(FIVEDRINKS[dr_Array[n3][i]] + "\t\t");
		System.out.println();
		for (int i = 0; i < 5; i++)
			// 循环显示烟数组数据
			System.out.print(FIVESMOKES[sm_Array[n4][i]] + "\t\t");
		System.out.println();
		for (int i = 0; i < 5; i++)
			// 循环显示宠物数组数据
			System.out.print(FIVEPETS[pet_Array[n5][i]] + "\t\t");
		System.out.println();
	}

}

 

　　实例218 使用Collections类对List的排序操作

package list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class ComparatorNum  implements Comparator {
/** 因为在Comparator中定义的compare(T o1, T o2)方法中，-1表示o1<o2,1表示o1>o2 0表示o1=o2 */
	public int compare(Object OA, Object OB) {
// 重写Comparator接口中的compare方法，若OA比OB大，返回-1；OA比OB小，返回1。否则返回0
// 获取int型数据
		int int1 = ((Integer) OA).intValue();
		int int2 = ((Integer) OB).intValue();
		if (int1 < int2) {
			return 1;
		}
		if (int1 > int2) {
			return -1;
		}
		return 0;
	}
}
public class MySortList {
	public static void output(List list) {
		if (list == null) {
			return;
		}
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i).toString() + " ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Integer(12));
		list.add(new Integer(5));
		list.add(new Integer(41));
		list.add(new Integer(23));
		list.add(new Integer(10));
		System.out.println("list列表中的初始数据如下：");
		MySortList.output(list);
		// Collections.sort方法将用默认比较器排列list的元素
		Collections.sort(list);
		System.out.println("list被Collections类的sort方法排序后的数据如下：");
		MySortList.output(list);
		// 下面将list的元素按降序排列
		Collections.sort(list, new ComparatorNum());
		System.out.println("list被自定义的降序比较器排序后的数据如下：");
		MySortList.output(list);
	}
}

 

　　实例219 LinkedList的添加删除操作

import java.util.LinkedList;

public class JiHe6 {
	public static void main(String[] args) {
		// 创建一个LinkedList对象
		LinkedList liList = new LinkedList(); 	// 参数与返回值都必须为String类型
		for (int i = 65; i < 70; i++) { 		// 循环加入5个字符串对象
			liList.add(String.valueOf((char) i));
		}
		System.out.println("LinkedList中的初始数据：" + liList); // 输出liList对象中的元素
		System.out.println("输出此LinkedList列表中下标为3的元素为：" + liList.get(3)); // 输出liList对象位置3的元素
		liList.set(3, "中国人"); 	// 设置位置3的元素为"aaa"
		System.out.println("替换下标为3的元素后：" + liList);
		System.out.println("LinkedList列表的表头元素为：" + liList.peek())	;// 找到列表的头元素
		liList.poll(); 			// 找到列表的头元素并删除
		System.out.println("删除表头元素后的LinkedList列表：" + liList);
		System.out.println("第一个元素是：" + liList.getFirst());			// 获取第一个元素并输出
		System.out.println("最后一个元素是：" + liList.getLast());			// 获取最后一个元素并输出
	}
}

 

 

　　实例220 运用Vector

package list;

import java.util.Vector;

public class MyVector {
	public Vector create() { // 生成一个4*4的二维Vector
		Vector vector = new Vector(); // 创建向量对象
		for (int i = 0; i < 4; i++) { // 双重循环往向量集合中添加数据
			Vector v = new Vector();
			for (int j = 0; j < 4; j++) {
				v.addElement("向量集合[" + i + "][" + j + "]");
			}
			vector.addElement(v);
		}
		return vector;
	}

	public Vector insertData(Vector vector, int index, Object obj) {// 在指定位置插入元素
		if (index > vector.size()) {
			print("参数index的值一定要大于向量集合长度!");
			return null;
		} else {
			vector.insertElementAt(obj, index); // 调用方法在指定位置插入元素
		}
		return vector;
	}

	public Vector deleteData(Vector vector, int index) { // 移除指定位置的元素
		if (index > vector.size()) {
			print("参数index的值一定要大于向量集合长度!");
			return null;
		} else {
			vector.removeElementAt(index); // 移除指定位置的元素
		}
		return vector;
	}

	public Vector updateData(Vector vector, int index, Object obj) {// 修改向量集合数据
		if (index > vector.size()) {
			print("参数index的值一定要大于向量集合长度!");
			return null;
		} else {
			vector.setElementAt(obj, index);
		}
		return vector;
	}

	public void print(String str, Vector vector) { // 输出信息
		System.out.println(str + "数据：->");
		this.print(vector);
	}

	public void print(Object obj) { // 打印输出重载
		System.out.println(obj);
	}

	public void print(Vector vector) { // 输出信息(重载)
		for (int i = 0; i < vector.size(); i++) {
			System.out.println(vector.elementAt(i));
		}
	}

	public static void main(String[] args) { // java程序主入口处
		MyVector ov = new MyVector(); // 实例化对象
		Vector vector = ov.create(); // 调用方法获得向量集合
		ov.print("1.显示向量集合的二维数组", vector); // 调用方法显示集合的信息
		Vector iResult = ov.insertData(vector, 2, "[我是刚才被新增加进来的元素]");
		ov.print("2.显示插入后向量集合数组", iResult); // 调用方法显示集合的信息
		Vector uResult = ov.updateData(iResult, 3, "[我是刚才被重新修改后的元素]");
		ov.print("3.显示修改后向量集合数组", uResult); // 调用方法显示集合的信息
		Vector dResult = ov.deleteData(uResult, 1);
		ov.print("4.显示删除后向量集合数组", dResult); // 调用方法显示集合的信息
	}

}

 

　　实例221 改变Properties文件中的键值

package list;

import java.io.*;
import java.util.*;

public class MyProperties extends ArrayList {
	private static final long UID = 1L;

	private String code = "GBK"; // 设置编码方式

	private String fileName; // 文件名包括路径和后缀

	public static void main(String[] args) throws Exception {// java程序主入口处
		String path = "D:/proper.properties";
		MyProperties proper = new MyProperties(path, "GBK");
		proper.setTitle("测试用Properties设置键-值对的值");
		proper.setProperties("studentName", "珍妮");
		proper.setNotes("studentName", "学生姓名"); // 设置用户名备注
		proper.setProperties("room", "三年一班");
		proper.setNotes("room", "所在年级"); // 设置密码备注
		proper.setProperties("score", "98.5");
		proper.setNotes("score", "数学分数"); // 设置用户地址备注
		proper.saveFile();// 将内容写入属性文件
		System.out.println(readFile(path, "GBK")); // 读取属性文件内容
		proper.getValue();// 读取项目中的属性文件的键值
	}

	public String getFileName() { // 获得文件名字
		return fileName;
	}

	private void setFileName(String fileName) { // 设置文件名字
		this.fileName = fileName;
	}

	// 带参数的构造方法
	public MyProperties(String fileName, String code) {
		try {
			this.setFileName(fileName); // 设置文件
			// 调用方法设置编码方式
			this.setCharacterEncoding(code);
			if (!isExist(fileName)) // 判断文件是否存在
				this.writeFile("");
			// 调用方法将元素放入集合中
			this.addAll(Arrays.asList(readFile(fileName, code).split("\n")));
		} catch (Exception ex) { // 捕获异常
			ex.printStackTrace();
		}
	}

	private void setCharacterEncoding(String code)
			throws UnsupportedEncodingException { // 设置编码方式
		new String("".getBytes("iso8859_1"), code);// 编码转换
		this.code = code;
	}

	public static boolean isExist(String fileName) { // 判断文件是否存在
		return new File(fileName).isFile(); // 是否是一个文件
	}

	public static String readFile(String fileName, String code)
			throws IOException { // 读取信息
		StringBuffer sb = new StringBuffer(); // 创建字符缓冲流
		BufferedReader in = new BufferedReader( // 创建缓冲读对象
				new FileReader(fileName));
		String s;
		while ((s = in.readLine()) != null) { // 循环读取文件中的信息
			sb.append(s); // 字符串拼接
			sb.append("\n"); // 换行
		}
		in.close(); // 释放资源
		return sb.toString(); // 返回读取的字符串
	}

	public void writeFile(String proper) throws IOException { // 字符串写入文件
		PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
				fileName))); // 创建文本输出流打印对象
		out.print(proper); // 将字符串写入指定文件
		out.close(); // 释放资源
	}

	public void saveFile() throws IOException { // 数据保存到文件中
		PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
				fileName))); // 创建文本输出流打印对象
		String tmp;
		for (int i = 0; i < size(); i++) { // 循环显示集合信息输出到控制台
			tmp = get(i) + "";
			out.println(tmp);
		}
		out.close();
	}

	public void setProperties(String key, String val) { // 设置Properties键值
		int pro = lookForKey(key);
		if (pro >= 0)
			this.set(pro, key + "=" + val);
		else
			this.add(key + "=" + val);
	}

	public int lookForKey(String key) { // 查找键序号
		try {
			String temp;
			for (int i = 0; i < size(); i++) { // 循环显示集合信息
				temp = get(i) + "";
				temp = new String(temp.getBytes("iso8859_1"), code);// 编码转换
				if (temp.indexOf(key) == 0) { // 没有找到键值
					return i;
				}
			}
		} catch (Exception e) { // 捕获异常
		}
		return -1;
	}

	public void setNotes(String key, String memo) { // 增加备注
		if ("".equals(key)) {
			this.add("#" + memo);
			return;
		}
		String temp;
		int result = lookForKey(key);
		if (result == -1) { // 如果没有找到
			this.add("#" + memo);
			this.add(key + "=");
		} else {
			int position = result - 1;
			if (position < 0) {
				this.add(position, "#" + memo);
			} else {
				temp = this.get(position) + " ";
				if ("#".equals(temp.substring(0, 1))) // 判断截取值是否与#相同
					this.set(position, "#" + memo);
				else {
					this.add(position + 1, "#" + memo);
				}
			}
		}
	}

	public void setTitle(String title) { // 设置注释内容
		String tmp = this.get(0) + "";
		if (tmp == null || tmp.length() == 0)
			tmp = "";
		else
			tmp = tmp.substring(0, 1); // 截取第一个元素
		if ("#".equals(tmp)) // 判断第一个元素是否是#
			this.set(0, "#" + title); // 增加注释内容
		else {
			this.add(0, "");
			this.add(0, "#" + title);
		}
	}

	public String getProperties(String key) { // 获取键对应的值
		return getProperties(key, "");
	}

	public String getProperties(String key, String defaultStr) {
		String temp, result;
		try {
			for (int i = 0; i < size(); i++) { // 循环显示集合信息
				temp = get(i) + ""; // 获得元素
				temp = new String(temp.getBytes("iso8859_1"), code);// 编码转换
				if (temp.indexOf(key) == 0) { // 找到指定的键
					result = temp.substring(key.length() + 1);// 截取获得键对应的值
					return result;
				}
			}
		} catch (Exception e) { // 捕获异常
		}
		return defaultStr;
	}

	public void getValue() {// 获得项目中的properties文根据键取得相应的值
		try {
			InputStream in = new BufferedInputStream(new FileInputStream(
					"proper.properties")); // 创建输入流对象
			Properties p = new Properties(); // 创建属性对象
			p.load(in); // 加载输入流对象
			String s = (String) p.get("studentName"); // 获得键值
			if(s!=null){
				// 编码转换
				String name = new String(s.getBytes("iso8859_1"), "GBK");
				System.out.println("输出studentName的值：" + name);

				String a = (String) p.get("room");
				String room = new String(a.getBytes("iso8859_1"), "GBK");
				System.out.println("输出room的值：" + room);
			}
			
		} catch (IOException e) { // 捕获异常
			e.printStackTrace();
		}
	}

}