Java集合框架2

8. 枚举（Enum）使用示例

声明一个枚举类型的简单形式如下：

访问类型 enum 枚举类名{值1[，值2，......]};

例8. 为枚举类添加辅助方法。

package set;

public enum Size {
    SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");
    private String num;
    //定义私有构造器，无传入参数
    private Size(){
        this(null);
    }
    //定义私有构造器，传入字符串num作为参数
    private Size(String num){
        this.num = num;
    }
    //定义公有的getNum方法，获得num的值
    public String getNum(){
        return num;
    }
}

例9. 根据用户输入的型号输出相应的价格。

package set;

public enum size {
    SMALL(18.8), MEDIUM(26.8), LARGE(32.8), EXTRA_LARGE(40.8);
    private double cost;
    //定义私有构造器，无传入参数
    private size(){
        this(0);
    }
    //定义私有构造器，传入字符串num作为参数
    private size(double cost){
        this.cost = cost;
    }
    //定义公有的getNum方法，获得num的值
    public double getCost(){
        return cost;
    }
}

package set;
import java.util.Scanner;
public class showClothCost {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        size si;
        String type;
        boolean goon = true;
        System.out.println("请输入衣服型号，包括：SMALL,MEDIUM,LARGE,EXTRA_LARGE，空行表示结束！");
        while(goon){
            type = in.nextLine().toUpperCase();
            if(type.length()>0){
                si = (size)Enum.valueOf(size.class, type);
                System.out.println(type+"的价格为："+si.getCost());
            }
            else
                goon = false;
        }
        in.close();
    }

}

程序运行结果为：

请输入衣服型号，包括：SMALL,MEDIUM,LARGE,EXTRA_LARGE，空行表示结束！
small
SMALL的价格为：18.8
medium
MEDIUM的价格为：26.8
large
LARGE的价格为：32.8
extra_large
EXTRA_LARGE的价格为：40.8

9. 枚举集（EnumSet）使用示例

EnumSet没有定义构造方法，要创建一个该类的对象，必须通过它的工厂方法来实现。用于创建一个枚举集的方法很多，而且都是静态方法，它们被称为工厂方法。

例10. 创建EnumSet示例。

下面的程序要使用上面例9中的size类。

package set;

import java.util.EnumSet;
import java.util.Iterator;

public class demoEnumSet {

    public static void main(String[] args) {
        EnumSet<size> enumSet = EnumSet.of(size.SMALL, size.MEDIUM);
        System.out.println("集合创建时拥有的元素：");
        showEnumSet(enumSet);
        System.out.println("补集拥有的元素：");
        showEnumSet(EnumSet.complementOf(enumSet));
        enumSet.add(size.LARGE);
        enumSet.add(size.EXTRA_LARGE);
        System.out.println("添加后拥有的元素为：");
        showEnumSet(enumSet);
        System.out.println("添加后补集拥有的元素为：");
        showEnumSet(EnumSet.complementOf(enumSet));

    }

    private static void showEnumSet(EnumSet<size> enumSet) {
        Iterator<size> it = enumSet.iterator();
        while(it.hasNext())
            System.out.print(it.next()+" ");
        System.out.println();        
    }

}

程序运行结果如下：

集合创建时拥有的元素：
SMALL MEDIUM 
补集拥有的元素：
LARGE EXTRA_LARGE 
添加后拥有的元素为：
SMALL MEDIUM LARGE EXTRA_LARGE 
添加后补集拥有的元素为：

10. 常用算法

例11. Collections中简单算法使用示例。

package set;
import java.util.*;
public class demoAlgorithom {

    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        Integer elem;
        for(int i=0;i<10;i++)
            al.add((int)(Math.random()*1000));
        System.out.println("生成的数据为：");
        showList(al);
        
        elem = Collections.max(al);
        System.out.println("最大数据是："+elem);
        
        elem = Collections.min(al);
        System.out.println("最小数据是："+elem);
        
        Collections.reverse(al);
        System.out.println("反转后的数据为：");
        showList(al);

    }

    private static void showList(ArrayList<Integer> al) {
        for(Integer elem:al)
            System.out.print(elem+" ");
        System.out.println();
        
    }

}

程序运行结果如下：

生成的数据为：
767 235 533 336 563 474 654 881 733 342 
最大数据是：881
最小数据是：235
反转后的数据为：
342 733 881 654 474 563 336 533 235 767 

11. 排序

例12. 排序示例。

package set;

import java.util.ArrayList;
import java.util.Collections;

public class demoSort {

    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        Integer elem;
        for(int i=0;i<10;i++)
            al.add((int)(Math.random()*1000));
        System.out.println("生成的数据为：");
        showList(al);
        
        Collections.sort(al);
        System.out.println("排序后的数据为：");
        showList(al);

    }

    private static void showList(ArrayList<Integer> al) {
        for(Integer elem:al)
            System.out.print(elem+" ");
        System.out.println();
        
    }

}

程序运行结果为：

生成的数据为：
967 847 714 896 288 836 784 994 923 749 
排序后的数据为：
288 714 749 784 836 847 896 923 967 994 

12. 二分查找

例13. 二分查找示例。

package set;
import java.util.*;
public class demoBinSearch {

    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        Integer key;
        boolean goon = true;
        int index;
        Scanner in = new Scanner(System.in);
        for(int i=0;i<10;i++)
            al.add((int)(Math.random()*1000));
        Collections.sort(al);
        System.out.println("排序后的数据为：");
        showList(al);
        System.out.println("请输入要查找的关键字，小于0表示结束！");
        while(goon){
            key = in.nextInt();
            if(key>0){
                index = Collections.binarySearch(al, key);
                if(index>=0)
                    System.out.println("关键字"+key+"的索引为："+index);
                else
                    System.out.println("关键字"+key+"没找到！");
            }else
                goon = false;        
        }
        in.close();
    }

    private static void showList(ArrayList<Integer> al) {
        for(Integer elem:al)
            System.out.print(elem+" ");
        System.out.println();
        
    }

}

程序运行结果为：

排序后的数据为：
60 76 192 213 303 381 409 761 858 931 
请输入要查找的关键字，小于0表示结束！
60
关键字60的索引为：0
381
关键字381的索引为：5
100
关键字100没找到！
-1

13. 向量类（Vector）使用示例

例14. Vector使用示例。

package set;
import java.util.*;
public class demoVector {

    public static void main(String[] args) {
        Vector<String> v = new Vector<String>(4);
        v.add("Test0");
        v.add("Test1");
        v.add("Test0");
        v.add("Test2");
        v.add("Test2");
        System.out.println("向量中的元素为：");
        showVector(v);
        v.remove("Test0");
        v.remove(0);
        System.out.println("现在向量中元素个数为："+v.size());
        System.out.println("删除后向量中的元素为：");
        showVector(v);
    }

    private static void showVector(Vector<String> v) {
        Iterator it = v.iterator();
        while(it.hasNext())
            System.out.print(it.next()+" ");
        System.out.println();
        
    }

}

程序的运行结果为：

向量中的元素为：
Test0 Test1 Test0 Test2 Test2
现在向量中元素个数为：3
删除后向量中的元素为：
Test0 Test2 Test2

14. 栈（Stack）使用示例

例15. 利用栈将字符串逆序输出。

package set;
import java.io.*;
import java.util.*;
public class reverseString {

    public static void main(String[] args) {
        FileInputStream fin;
        FileOutputStream fout;
        Stack<Character> stack = new Stack<Character>();
        char ch;
        try {
            fin = new FileInputStream(FileDescriptor.in);
            System.out.println("请输入一行字符：");
            while((ch=(char)fin.read())!='
')
                stack.push(ch);
            fin.close();
            System.out.println("逆序输出为：");
            fout= new FileOutputStream(FileDescriptor.out);
            while(!stack.empty())
                fout.write(stack.pop());
            fout.close();
        } catch (Exception e) {
            System.out.println("输入输出流有误！");
        }
        
    }

}

程序运行结果为：

请输入一行字符：
Hello world!
逆序输出为：
!dlrow olleH