加分了 《---继续请教 如何随机挑选数组中的元素，而且保证每个元素都被选过 请问 paullbm 还在吗 ---》

Question

就是s={a,b,c,d,e}
随机生成相同的数字串，可以字符有重复，但是一定要确保串中每个数字都有出现
请问怎么搞？上次是任意长度的，这次是定长度的，怎么办比如 length=7
就必须是abcedab
or
abdecae
..........
谢谢

Answer 1

还要定长的？那如果length的值小于数组的长度算什么呢？

Answer 2

.length方法不足以满足LZ的需求？for(int i=0;int i<*.length;i++){get(i)}都不行？

Answer 3

class Test {  public static void main(String[] args) throws Exception { 
String[] letter={"a","b","c","d"}; 
for (int i = 5; i < 10; i++) { 
System.out.println (Test.getRandomString(letter, i)); 
} 
}  public static String getRandomString(String[] letter, int length) { 
Random random = new Random(); 
StringBuffer sb = new StringBuffer(); 
for (int i = 0; i < length; i++) { 
sb.append(letter[random.nextInt(4)]); 
} 
return sb.toString(); 
} 
}
不论定长与否都可以

Answer 4

可以随机abcde的一个排列（abcde全排列中的一个），
然后在a到e随机取两个，再在abcde中的六个空随机选两个，
把之前选中的两个元素插入到随机选中的空中。
不固定的也差不多，不过length太大的话这种方法可能效率太低，
期待更好的办法。

Answer 5

<code>
package com.mimo.test.reg;import java.util.Random;public class RandomTest { final int KMAX = 7;
char[] s = { 'a', 'b', 'c', 'd', 'e' };
char[] pre = new char[5];
char[] last = new char[KMAX - 5];
char[] t = new char[KMAX];
int[] index = new int[KMAX]; /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < 10; i++) {
RandomTest rt = new RandomTest();
rt.randomPrePart();
rt.randomLastPart();
rt.merge();
} } public void randomPrePart() {
boolean[] b = new boolean[s.length];
int seed = s.length;
for (int i = 0; i < s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
while (b[k]) {
k++;
}
pre[i] = s[k];
b[k] = true;
seed--;
}
} public void randomLastPart() {
boolean[] b = new boolean[s.length];
int seed = s.length;
for (int i = 0; i < KMAX - s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
while (b[k]) {
k++;
}
b[k] = true;
last[i] = s[k];
}
} public void merge() {
boolean[] b = new boolean[KMAX];
int seed = KMAX;
for (int i = 0; i < KMAX - s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
while (b[k]) {
k++;
}
b[k] = true;
for (int j = 0; j < i; j++) {
if (index[j] > k) {
for (int ll = i - 1; ll >= j; ll--) {
index[ll + 1] = index[ll];
}
index[j] = k;
k = -1;
break;
}
}
if (k > 0) {
index[i] = k;
}
seed--;
}
int j = 0, k = 0;
for (int i = 0; i < KMAX; i++) {
if (i == index[j]) {
t[i] = last[j++];
} else {
t[i] = pre[k++];
}
System.out.print(t[i]);
}
System.out.println(); }
// public char[] random(char[] s, int l) {
//
// if (s.length == l) {
// boolean[] b = new boolean[l];
// int seed = l;
// for (int i = 0; i < l; i++) {
// int r = new Random().nextInt(seed);
// int k = r;
// while (b[k]) {
// k++;
// }
// m[i] = s[k];
// seed--;
// }
// } else if (s.length < l) {
// boolean[] b = new boolean[s.length];
// int seed = s.length;
// for (int i = 0; i < l; i++) {
// int r = new Random().nextInt(seed);
// int k = r;
// while (b[k]) {
// k++;
// }
// last[i] = s[k];
// }
// } else {
//
// }
// return s;
// }}</code>

Answer 6

import java.util.Random;public class RandomTest { final int KMAX = 7;
char[] s = { 'a', 'b', 'c', 'd', 'e' };
char[] pre = new char[5];
char[] last = new char[KMAX - 5];
char[] t = new char[KMAX];
int[] index = new int[KMAX];
public static void main(String[] args) {
//10测测试
for (int i = 0; i < 10; i++) {
RandomTest rt = new RandomTest();
rt.randomPrePart();
rt.randomLastPart();
rt.merge();
} } //得到排列  pre[]
public void randomPrePart() {
boolean[] b = new boolean[s.length];
int seed = s.length;
for (int i = 0; i < s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
while (b[k]) {
k++;
}
pre[i] = s[k];
b[k] = true;
seed--;
}
}
//得到剩下的字符 last[]
public void randomLastPart() {
boolean[] b = new boolean[s.length];
int seed = s.length;
for (int i = 0; i < KMAX - s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
last[i] = s[k];
}
}
// 随即位置 ，合并 t[],输出
public void merge() {
boolean[] b = new boolean[KMAX];
int seed = KMAX;
for (int i = 0; i < KMAX - s.length; i++) {
int r = new Random().nextInt(seed);
int k = r;
while (b[k]) {
k++;
}
b[k] = true;
for (int j = 0; j < i; j++) {
if (index[j] > k) {
for (int ll = i - 1; ll >= j; ll--) {
index[ll + 1] = index[ll];
}
index[j] = k;
k = -1;
break;
}
}
if (k > 0) {
index[i] = k;
}
seed--;
}
int j = 0, k = 0;
for (int i = 0; i < KMAX; i++) {
if (i == index[j]) {
t[i] = last[j++];
} else {
t[i] = pre[k++];
}
System.out.print(t[i]);
}
System.out.println(); }
}
改了一下。 楼主可以试一试； 是否满足要求

Answer 7

这个楼主可以提出一个参数来就行了P.S."为什么不好用啊？？" 是问 【code】[/code]为什么不好用，怎么不能插入code呢？ 

Answer 8

public class Test { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] s = { 1, 2, 3, 4, 5 };
int[] ed = new int[s.length];// 整形数组，记录已经输出的数组下标

int length = 7;// 要求输出长度

int i = 0;// 记录已经输出的字符个数
loop: while (i < s.length) {// 查看是否已经输出完毕
int a = (int) (Math.random() * s.length);// 产生0---all.length-1之间的随机数
for (int j = 0; j < i; j++) {
if (ed[j] == a) {// 判断是否该下标已经出现过
continue loop;
}
}
ed[i++] = a;// 没有将a的值加到ed数组中i++；
System.out.print(s[a]);// 输出
}
for(int k=0;k<length-s.length;k++){
int b= (int) (Math.random() * length);
System.out.print(s[b%s.length]);
}
}
}傻瓜型  但是能实现

Answer 9

public class PrintDigitByRandom
{
public static String printAllDigitWithRepeat(int digit[],int maxRondomTimes)
{
int len = digit.length;
if(maxRondomTimes<len)return "maxLength长度不能小于数组长度！"; //
int rand = 0;
byte b[] = new byte[len]; 
StringBuffer sb=new StringBuffer("");

for(int n=1;n<=maxRondomTimes;n++)
{//确定循环次数
int freeRondomTimes=0; //自由随机次数
while(true)
{
boolean flag = false;
for (int i = 0; i < len; i++)
{
if (b[i] == 0)
{
flag = true;
break;
}
}
if(flag==false)
break; //没有0了时退出外层循环
else
{//有0则继续在sb后添加
while(true)
{
rand = (int) Math.floor(Math.random() * len);
if(freeRondomTimes<(maxRondomTimes-len))
{//自由随机
sb.append(digit[rand]+" ");
}
else if(b[rand]==0)
{//指定随机
sb.append(digit[rand]+" ");
b[rand] ++; //统计每个数随机生成出现的次数
}
freeRondomTimes++;
break;
}
}
}
}

return sb.toString();
} public static void main(String[] args)
{
int digit[] = {1,2,3,4,5,6}; //可自己再添加数字
int n=7,maxTimes=7;
for(int i=0;i<n;i++) //测试n次
System.out.println(printAllDigitWithRepeat(digit,maxTimes));
}
}

Answer 10

可把15楼代码的第2个while(true)及break语句省略，顺便重新整理代码格式，如下：
public class PrintDigitByRandom
{
public static String printAllDigitWithRepeat(int digit[], int maxRondomTimes)
{
int len = digit.length;
if (maxRondomTimes < len)
return "maxRondomTimes不能小于数组长度！"; 
int rand = 0;
byte b[] = new byte[len];
StringBuffer sb = new StringBuffer(""); for (int n = 1; n <= maxRondomTimes; n++)
{// 确定循环次数
int freeRondomTimes = 0; // 自由随机次数
while (true)
{
boolean flag = false;
for (int i = 0; i < len; i++)
{
if (b[i] == 0)
{
flag = true;
break;
}
}
if (flag == false)
break; // 没有0了时退出外层循环
else
{// 有0则继续在sb后添加
rand = (int) Math.floor(Math.random() * len);
if (freeRondomTimes < (maxRondomTimes - len))
{// 自由随机
sb.append(digit[rand] + " ");
} 
else if (b[rand] == 0)
{// 指定随机
sb.append(digit[rand] + " ");
b[rand]++; // 统计每个数随机生成出现的次数
}
freeRondomTimes++;
}
}
} return sb.toString();
} public static void main(String[] args)
{
int digit[] =
{ 1, 2, 3, 4, 5, 6 }; // 可自己再添加数字
int n = 7, maxTimes = 7;
for (int i = 0; i < n; i++) // 测试n次
System.out.println(printAllDigitWithRepeat(digit, maxTimes));
}
}

Answer 11

补充一下，为了说明逻辑的严密性，将上述代码中
freeRondomTimes++;
应该提放到
if (freeRondomTimes < (maxRondomTimes - len))
{// 自由随机}
的代码块中(即大括号中)

Answer 12

xue xi  xia   ......

Answer 13

产生得不均匀吧
假设数组长为n
只等于前length-n个位置产生随机数
后n位置产生一个数组所有数的任意一个排列
例如abcde，length为7
acabccd就产生不了

Answer 14

CSDN真有点奇怪，代码缩进老是出问题！！顺便又改了一小点地方，来个最终版吧。
public class PrintDigitByRandom
{
public static String printAllDigitWithRepeat(int digit[], int maxRondomTimes)
{
int len = digit.length;
if (maxRondomTimes < len)
return "maxRondomTimes不能小于数组长度！";
int rand = 0;
byte b[] = new byte[len];
StringBuffer sb = new StringBuffer(""); int freeRondomTimes = maxRondomTimes - len; // 自由随机次数
for (int n = 1; n <= maxRondomTimes; n++)
{// 确定循环次数
while (true)
{
boolean flag = false;
for (int i = 0; i < len; i++)
{
if (b[i] == 0)
{
flag = true;
break;
}
}
if (flag == false)
break; // 没有0了时退出外层循环
else
{// 有0则继续在sb后添加
rand = (int) Math.floor(Math.random() * len);
if (freeRondomTimes > 0)
{// 自由随机
sb.append(digit[rand] + " ");
freeRondomTimes--;
} else if (b[rand] == 0)
{// 指定随机
sb.append(digit[rand] + " ");
b[rand]++;
}
}
}
} return sb.toString();
} public static void main(String[] args)
{
int digit[] = { 1, 2, 3, 4, 5 }; // 可自己再添加数字
int n = 20, maxTimes = 9;
for (int i = 0; i < n; i++) // 测试n次
System.out.println(printAllDigitWithRepeat(digit, maxTimes));
}
}

Answer 15

引用错了
产生得不均匀吧 
假设数组长为n 
只等于前length-n个位置产生随机数 
后n位置产生一个数组所有数的任意一个排列 
例如abcde，length为7 
acabccd就产生不了

Answer 16

汗，笔误
例如abcde，length为7 
ecabccd就产生不了

Answer 17

好吧，我明白你的意思。你的意思无非就是觉得那像伪随机数。看这段吧：
public class PrintDigitByRandom
{
    public static String printAllDigitWithRepeat(int digit[], int maxRondomTimes)
    {
        int len = digit.length;
        if (maxRondomTimes < len)
            return "maxRondomTimes不能小于数组长度！";
        int rand = 0;
        byte b[] = new byte[len];
        StringBuffer sb = new StringBuffer("");
        
        boolean isNext=true;
        while(isNext)
        {
            int i=0;
            for (i=0; i < maxRondomTimes; i++)
            {
                rand = (int) Math.floor(Math.random() * len);
                sb.append(digit[rand]+" ");
                b[rand]++;
            }
            for(i=0;i<len;i++)
            {
                if(b[i]==0)
                {//当某一个数出现的次数为0时
                    sb=new StringBuffer(""); //重置sb
                    b=new byte[len]; //重置记数数组全为0
                    break;
                }
            }
            if(i==len) //如果b数组中没有含0的元素，则退出外层循环
                 isNext=false;
        }
        
        //查看各个数出现的次数,楼主可注释掉
         for(int j=0;j<len;j++)
            System.out.print(b[j]+" ");
        
        return sb.toString();
    }    public static void main(String[] args)
    {
        int digit[] = { 1, 2, 3, 4, 5, 6 }; // 可自己再添加数字
         int n = 20, maxTimes = 10;
        for (int i = 0; i < n; i++) // 测试n次
            System.out.println("["+(i+1)+"] "+printAllDigitWithRepeat(digit, maxTimes));
    }
}

Answer 18

sb=new StringBuffer(""); //重置sb
可以改为
sb.setLength(0);后者好像效率高一点。

Answer 19

这个算法没问题，小点的数用这个方法比较简单，
不过数量大点，尤其数组大小越接近maxRondomTimes时效率可能会比较低，
就底看运气了，像20，20就挺困难

Answer 20

如果数组大小越接近maxRondomTimes，则就可用我20楼的方法，比较少的时候就用25楼的代码。
毕竟要保证每一个数字都要出现。如果用纯随机的话，那效率自然会低了。

Answer 21

也可以用别的方法间接产生一个随机的排列。
拿到数组以后，随机选取两个数交换位置，重复n回，
n随数组增大而递增，n越大就越均匀。
这方法的缺点就是n相对数组要足够大才能产生均匀的效果，
但可以保证每种序列都有产生的可能，关键看需求了

Answer 22

因此，完全可以把上述2种情况分别用2个函数写出来，再通过第3个函数根据数组的大小及maxRondomTimes的值进行条件判断。。自己设定一个区域，从而选择相应的函数进行输出。。

Answer 23

谁能给我一个j2ee框架做的事例啊

Answer 24

import java.util.*;
import java.util.Collections;
public class PrintDigitByRandom {    public static void main(String[] args)
    {
      List<Integer> a  = new ArrayList<Integer>();
      for ( int i = 0; i < 5; i++)
      {
       a.add(i+1);
      }
      
         int maxlen = 7;
         
         List<Integer> b = new ArrayList<Integer>();
         for ( int i = 0; i < a.size(); i++)
      {
       b.add(a.get(i));
      }
      
         
         //System.arraycopy(a, 0, b, 0, a.length);
         for ( int j = a.size(); j < maxlen; j++ )
         {
            b.add(a.get(new Random().nextInt(a.size())));
         }
         for ( int j = 0; j < 5; j++)
         {
          Collections.shuffle(b);
          System.out.println(b);
         
         }
    }
    
    
    
}

Answer 25

哈哈36的真是方便没想到Collections.shuffle的妙用啊
import java.util.*;
import java.util.Collections;public class PrintDigitByRondom
{
    public static String functionByGrellen(int digit[], int maxTimes)
    {
        List<Integer> a = new ArrayList<Integer>();
        int len = digit.length;
        for (int i = 0; i < len; i++)
        {
            a.add(digit[i]);
        }        List<Integer> b = new ArrayList<Integer>();
        for (int i = 0; i < len; i++)
        {
            b.add(a.get(i));
        }        for (int j = a.size(); j < maxTimes; j++)
        {
            b.add(a.get(new Random().nextInt(a.size())));
        }        Collections.shuffle(b);        return b.toString();
    }    public static void main(String[] args)
    {
        int n = 12, cnt = 5;
        int digit[] = new int[n];
        for (int i = 0; i < n; i++)
            digit[i] = i + 1;
        int maxTimes = 13; //小于n的话则在函数中自动以n为准
        for (int i = 0; i < cnt; i++)
            System.out.println(functionByGrellen(digit, maxTimes));
    }
}

Answer 26

谢谢各路高手指点
源代码我好好看看相助的高手都有分
Thanks ！！！
我自己修改了paullbm的算法，也能实现public static String getRandomString(String[] letter, int length) {
Random random = new Random();
byte b[] = new byte[letter.length];
StringBuffer sb = new StringBuffer();
int counter = 0;
while (true) {
boolean flag = false;
for (int i = 0; i < letter.length; i++) {
if (b[i] == 0) {// 0 denotes not used
flag = true;
break;
}
}
if (flag == false && counter >= length)
break;
else {
for (int i = 0; i < length; i++) {
int rand = random.nextInt(letter.length);
sb.append(letter[rand]);
if (b[rand] == 0)
b[rand] = 1;
++counter;
} } }
return sb.toString();
}

Answer 27

package sss;import java.util.ArrayList;
import java.util.List;
import java.util.Random;public class RandomTest {    //按需要设置范围
    public static int RANDOM_RANGE = 10;
    public static void main(String[] args) {
        //原始数据数组
        String[] orgData = {"a", "b", "c", "d", "e"};
        //记录已经用过的下标
        List<Integer> usedIndex = new ArrayList<Integer>();        //随即产生数据长度并判断
        Random needArrLength = new Random();
        int ranIntNeedArrLength = needArrLength.nextInt(RANDOM_RANGE);
System.out.println("ranIntNeedArrLength:    " + ranIntNeedArrLength);        //存储结果的字符串数组
        //List<String> result  = new ArrayList<String>();
        String[] result = new String[ranIntNeedArrLength];        if(orgData.length <= ranIntNeedArrLength) {
            Random ranIndex = new Random();            Integer rando = 0;
            while(rando < orgData.length) {
                int temp = ranIndex.nextInt(ranIntNeedArrLength);
System.out.println("temp:    " + temp);
                //判断随机到的下标是否重复
                boolean has = true;
                for (int j = 0; j < usedIndex.size(); j++) {
                    int usedIndexTemp = usedIndex.get(j);
                    if(usedIndexTemp == temp) {
                        has = false;
                        rando--;
                        break;
                    }
                }
                rando++;
                if(has) {
                     usedIndex.add(temp);
                }
            }
            //输出随机得到的下标
System.out.print("下标： ");
            for (int i : usedIndex) {
                System.out.print(i + " ");
            }            //赋值
            for (int i = 0; i < orgData.length; i++) {
                int a = usedIndex.get(i);
                String b = orgData[i];
                result[a] = b;
            }
          //print out result
System.out.println("结果：     ");
              for (int i = 0; i < result.length; i++) {
                System.out.println("xiabiao: " + i + "  zhi: " + result[i]);
              }
            if(ranIntNeedArrLength > orgData.length) {
                Random otherInd = new Random();
                for(int j = 0; j < result.length; j++) {
                    if(result[j] == null) {
                        result[j] = orgData[otherInd.nextInt(orgData.length)];
                    }
                }
            }
            //print out result
System.out.println("结果：     ");
          for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + " ");
          }
        }else {
            System.out.println("error~~~");
        }
    }
}运行结果：
ranIntNeedArrLength:    9
temp:    0
temp:    7
temp:    8
temp:    8
temp:    7
temp:    0
temp:    0
temp:    8
temp:    1
temp:    0
temp:    6
下标： 0 7 8 1 6
结果：     
xiabiao: 0  zhi: a
xiabiao: 1  zhi: d
xiabiao: 2  zhi: null
xiabiao: 3  zhi: null
xiabiao: 4  zhi: null
xiabiao: 5  zhi: null
xiabiao: 6  zhi: e
xiabiao: 7  zhi: b
xiabiao: 8  zhi: c
结果：     
a d c e c b e b c ERROR: JDWP Unable to get JNI 1.2 environment, jvm->GetEnv() return code = -2
JDWP exit error AGENT_ERROR_NO_JNI_ENV(183):  [../../../src/share/back/util.c:820]