一道Java编程题

Java程序：

import java.util.Random;
   
public class HardWork {
    public static void main(String[] args) {
        RandomEX rand = new RandomEX();
        int n = 4;
       模掘 int group = 10;
         
        for(int i=0; i<group; i++) {
            System.out.printf("第 %2d 组：
", i + 1);
            System.out.printf("1~%d长度二进制字符串握明： 	%s
", n, rand.nextBinaryString1(n));
            System.out.printf("固定%d长度二进制字符串： 	%s
", n, rand.nextBinaryString2(n));
            System.out.printf("1~%d长度十六进制字符串：	%s
", n, rand.nextHexString1(n));
            System.out.printf("固定%d长度十六进制字符串：	%s
", n, rand.nextHexString2(n));
            System.out.println();
        }
    }
}
/**
 * 随机数类
 * @author 冯向科
 * @version 2016.05.07
 */
class RandomEX extends Random {
    private static final long serialVersionUID = 1L;
     
    /**
     * 产生随机长度为1~n的二进字符串
     * @param n 字符串最大长度
     * @return 长度为1~n的二进制字符串
     */
    public String nextBinaryString1 (int n) {
        long num;
        StringBuilder str = new StringBuilder();
        int len;
         
        do {
            num = this.nextLong();
            str.append(Long.toBinaryString(num));
            len = str.length();      
        } while(len < n);
         
        int size = this.nextInt(n) + 1;
         
        return str.substring(0, size);
    }
     
    /**
     * 产生固定长度为n的二进字符串
     * @param n 字符串固定长度
     * @return 固定长度为n的二进字符串
     */
    public String nextBinaryString2 (int n) {
        long num;
        StringBuilder str = new StringBuilder();
        int len;
         
        do {
            num = this.nextLong();
            str.append(Long.toBinaryString(num));
            len = str.length();      
        } while(len < n);
         
        return str.substring(0, n).toUpperCase();    
    }
     
    /**
     * 产生随机长度为1~n的十六进字符串
     * @param n 字符串最大长度
     * @return 长度为1~n的十六进制字符串
     */
    public String nextHexString1 (int n) {
        long num;
     段码告   StringBuilder str = new StringBuilder();
        int len;
         
        do {
            num = this.nextLong();
            str.append(Long.toHexString(num));
            len = str.length();      
        } while(len < n);
         
        int size = this.nextInt(n) + 1;
         
        return str.substring(0, size).toUpperCase();
    }
     
    /**
     * 产生固定长度为n的十六进字符串
     * @param n 字符串固定长度
     * @return 固定长度为n的十六进字符串
     */
    public String nextHexString2 (int n) {
        long num;
        StringBuilder str = new StringBuilder();
        int len;
         
        do {
            num = this.nextLong();
            str.append(Long.toHexString(num));
            len = str.length();      
        } while(len < n);
         
        return str.substring(0, n).toUpperCase();    
    }
}

运行测试：

第  1 组：

1~4长度二进制字符串： 11

固定4长度二进制字符串： 1010

1~4长度十六进制字符串： 44B

固定4长度十六进制字符串： A7C3

第  2 组：

1~4长度二进制字符串： 110

固定4长度二进制字符串： 1110

1~4长度十六进制字符串： E96D

固定4长度十六进制字符串： 61F1

第  3 组：

1~4长度二进制字符串： 101

固定4长度二进制字符串： 1111

1~4长度十六进制字符串： B1C

固定4长度十六进制字符串： A0F1

第  4 组：

1~4长度二进制字符串： 1101

固定4长度二进制字符串： 1010

1~4长度十六进制字符串： 1DC

固定4长度十六进制字符串： D38E

第  5 组：

1~4长度二进制字符串： 1

固定4长度二进制字符串： 1110

1~4长度十六进制字符串： 70D8

固定4长度十六进制字符串： 495B

第  6 组：

1~4长度二进制字符串： 1100

固定4长度二进制字符串： 1011

1~4长度十六进制字符串： F6

固定4长度十六进制字符串： 5086

第  7 组：

1~4长度二进制字符串： 100

固定4长度二进制字符串： 1100

1~4长度十六进制字符串： 86A

固定4长度十六进制字符串： 23A0

第  8 组：

1~4长度二进制字符串： 1

固定4长度二进制字符串： 1101

1~4长度十六进制字符串： 8

固定4长度十六进制字符串： F967

第  9 组：

1~4长度二进制字符串： 110

固定4长度二进制字符串： 1000

1~4长度十六进制字符串： F194

固定4长度十六进制字符串： 7C3D

第 10 组：

1~4长度二进制字符串： 1101

固定4长度二进制字符串： 1100

1~4长度十六进制字符串： 4

固定4长度十六进制字符串： FB2A