※JAVA范例 12-1 【上】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); // 准备从键盘输入 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(); // 关闭输入流入
	}
}

实例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){
		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(); // 换行  
	}
}

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

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

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

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