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