※JAVA范例 12-1 【上】Java高级开发技术 集合

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); // 准备从键盘输入 Scanner检测装置; 扫描器
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(); // 关闭输入流入
}
}

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){
RandomSort rs = new RandomSort(3,12);
System.out.println("<1> 运用排除法生成不重复的随机数序列");
printArray(rs.exclusionSort(6));  //exclusionSort 排除法
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(); // 换行
}
}

package list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class MyMapClass {

public static void main(String[] args){
printHashMap();  // 操作HashMap显示图书种类
printHashtable(); // 操作Hashtable显示图书种类
printTreeMap();  // 操作TreeMap显示图书种类
printArrayList();  // 操作ArrayList显示图书种类
}

public static void printHashMap(){
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();
}

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

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

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

package list;
import java.util.*;

public class MySetClass {
public static void main(String[] args) {
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);
// 获取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使用treeSetResult存储的数据元素如下->： ");
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()) {
System.out.print(it.next() + " ");
}
}else {
System.out.println("没有元素！");
}
System.out.println();  //换行
}
}