如何随机获得数组String s[] = {"abc1","abc2","abc3","abc4","abc5"};中的字符串打印出来，并且不重复。

1. package test;
   
2. public class Demo
   
3. {
   
4.   public static void main(String[] args)
   
5.   {
   
6.          //int[] a = new int[]{1,2,3,4,5};
   
7.          String a[] = {"abc1","abc2","abc3","abc4","abc5"};
   
8.          int n = 1;
   
9.          for (int a1 = 0; a1<a.length; a1++)
   
10.          {
    
11.               for (int a2 = 0; a2<a.length; a2++)
    
12.               {
    
13.                     for (int a3 = 0; a3<a.length; a3++)
    
14.                     {
    
15.                           for (int a4 = 0; a4<a.length; a4++)
    
16.                           {
    
17.                               for (int a5 = 0; a5<a.length; a5++)
    
18.                               {
    
19.                                 if((a[a1] != a[a2]) && (a[a1] != a[a3]) && (a[a1] != a[a4]) && (a[a1] != a[a5]) && (a[a2] != a[a3]) && (a[a2] != a[a4]) && (a[a2] != a[a5]) && (a[a3] != a[a4]) && (a[a3] != a[a5]) && (a[a4] != a[a5]))
    
20.                                    {
    
21.                                           System.out.println(n+":" + "\t" + a[a1] + "\t" + a[a2] + "\t" + a[a3] + "\t" + a[a4] + "\t" + a[a5]);
    
22.                                           n++;
    
23.                                    }
    
24.                               }
    
25.                           }
    
26.                     }
    
27.                         
    
28.               }
    
29.          }
    
30.   }     
    
31. }
    
32. <div class="blockcode"><blockquote>
    

复制代码

运行结果：

1. 1:        abc1        abc2        abc3        abc4        abc5
   
2. 2:        abc1        abc2        abc3        abc5        abc4
   
3. 3:        abc1        abc2        abc4        abc3        abc5
   
4. 4:        abc1        abc2        abc4        abc5        abc3
   
5. 5:        abc1        abc2        abc5        abc3        abc4
   
6. 6:        abc1        abc2        abc5        abc4        abc3
   
7. 7:        abc1        abc3        abc2        abc4        abc5
   
8. 8:        abc1        abc3        abc2        abc5        abc4
   
9. 9:        abc1        abc3        abc4        abc2        abc5
   
10. 10:        abc1        abc3        abc4        abc5        abc2
    
11. 11:        abc1        abc3        abc5        abc2        abc4
    
12. 12:        abc1        abc3        abc5        abc4        abc2
    
13. 13:        abc1        abc4        abc2        abc3        abc5
    
14. 14:        abc1        abc4        abc2        abc5        abc3
    
15. 15:        abc1        abc4        abc3        abc2        abc5
    
16. 16:        abc1        abc4        abc3        abc5        abc2
    
17. 17:        abc1        abc4        abc5        abc2        abc3
    
18. 18:        abc1        abc4        abc5        abc3        abc2
    
19. 19:        abc1        abc5        abc2        abc3        abc4
    
20. 20:        abc1        abc5        abc2        abc4        abc3
    
21. 21:        abc1        abc5        abc3        abc2        abc4
    
22. 22:        abc1        abc5        abc3        abc4        abc2
    
23. 23:        abc1        abc5        abc4        abc2        abc3
    
24. 24:        abc1        abc5        abc4        abc3        abc2
    
25. 25:        abc2        abc1        abc3        abc4        abc5
    
26. 26:        abc2        abc1        abc3        abc5        abc4
    
27. 27:        abc2        abc1        abc4        abc3        abc5
    
28. 28:        abc2        abc1        abc4        abc5        abc3
    
29. 29:        abc2        abc1        abc5        abc3        abc4
    
30. 30:        abc2        abc1        abc5        abc4        abc3
    
31. 31:        abc2        abc3        abc1        abc4        abc5
    
32. 32:        abc2        abc3        abc1        abc5        abc4
    
33. 33:        abc2        abc3        abc4        abc1        abc5
    
34. 34:        abc2        abc3        abc4        abc5        abc1
    
35. 35:        abc2        abc3        abc5        abc1        abc4
    
36. 36:        abc2        abc3        abc5        abc4        abc1
    
37. 37:        abc2        abc4        abc1        abc3        abc5
    
38. 38:        abc2        abc4        abc1        abc5        abc3
    
39. 39:        abc2        abc4        abc3        abc1        abc5
    
40. 40:        abc2        abc4        abc3        abc5        abc1
    
41. 41:        abc2        abc4        abc5        abc1        abc3
    
42. 42:        abc2        abc4        abc5        abc3        abc1
    
43. 43:        abc2        abc5        abc1        abc3        abc4
    
44. 44:        abc2        abc5        abc1        abc4        abc3
    
45. 45:        abc2        abc5        abc3        abc1        abc4
    
46. 46:        abc2        abc5        abc3        abc4        abc1
    
47. 47:        abc2        abc5        abc4        abc1        abc3
    
48. 48:        abc2        abc5        abc4        abc3        abc1
    
49. 49:        abc3        abc1        abc2        abc4        abc5
    
50. 50:        abc3        abc1        abc2        abc5        abc4
    
51. 51:        abc3        abc1        abc4        abc2        abc5
    
52. 52:        abc3        abc1        abc4        abc5        abc2
    
53. 53:        abc3        abc1        abc5        abc2        abc4
    
54. 54:        abc3        abc1        abc5        abc4        abc2
    
55. 55:        abc3        abc2        abc1        abc4        abc5
    
56. 56:        abc3        abc2        abc1        abc5        abc4
    
57. 57:        abc3        abc2        abc4        abc1        abc5
    
58. 58:        abc3        abc2        abc4        abc5        abc1
    
59. 59:        abc3        abc2        abc5        abc1        abc4
    
60. 60:        abc3        abc2        abc5        abc4        abc1
    
61. 61:        abc3        abc4        abc1        abc2        abc5
    
62. 62:        abc3        abc4        abc1        abc5        abc2
    
63. 63:        abc3        abc4        abc2        abc1        abc5
    
64. 64:        abc3        abc4        abc2        abc5        abc1
    
65. 65:        abc3        abc4        abc5        abc1        abc2
    
66. 66:        abc3        abc4        abc5        abc2        abc1
    
67. 67:        abc3        abc5        abc1        abc2        abc4
    
68. 68:        abc3        abc5        abc1        abc4        abc2
    
69. 69:        abc3        abc5        abc2        abc1        abc4
    
70. 70:        abc3        abc5        abc2        abc4        abc1
    
71. 71:        abc3        abc5        abc4        abc1        abc2
    
72. 72:        abc3        abc5        abc4        abc2        abc1
    
73. 73:        abc4        abc1        abc2        abc3        abc5
    
74. 74:        abc4        abc1        abc2        abc5        abc3
    
75. 75:        abc4        abc1        abc3        abc2        abc5
    
76. 76:        abc4        abc1        abc3        abc5        abc2
    
77. 77:        abc4        abc1        abc5        abc2        abc3
    
78. 78:        abc4        abc1        abc5        abc3        abc2
    
79. 79:        abc4        abc2        abc1        abc3        abc5
    
80. 80:        abc4        abc2        abc1        abc5        abc3
    
81. 81:        abc4        abc2        abc3        abc1        abc5
    
82. 82:        abc4        abc2        abc3        abc5        abc1
    
83. 83:        abc4        abc2        abc5        abc1        abc3
    
84. 84:        abc4        abc2        abc5        abc3        abc1
    
85. 85:        abc4        abc3        abc1        abc2        abc5
    
86. 86:        abc4        abc3        abc1        abc5        abc2
    
87. 87:        abc4        abc3        abc2        abc1        abc5
    
88. 88:        abc4        abc3        abc2        abc5        abc1
    
89. 89:        abc4        abc3        abc5        abc1        abc2
    
90. 90:        abc4        abc3        abc5        abc2        abc1
    
91. 91:        abc4        abc5        abc1        abc2        abc3
    
92. 92:        abc4        abc5        abc1        abc3        abc2
    
93. 93:        abc4        abc5        abc2        abc1        abc3
    
94. 94:        abc4        abc5        abc2        abc3        abc1
    
95. 95:        abc4        abc5        abc3        abc1        abc2
    
96. 96:        abc4        abc5        abc3        abc2        abc1
    
97. 97:        abc5        abc1        abc2        abc3        abc4
    
98. 98:        abc5        abc1        abc2        abc4        abc3
    
99. 99:        abc5        abc1        abc3        abc2        abc4
    
100. 100:        abc5        abc1        abc3        abc4        abc2
     
101. 101:        abc5        abc1        abc4        abc2        abc3
     
102. 102:        abc5        abc1        abc4        abc3        abc2
     
103. 103:        abc5        abc2        abc1        abc3        abc4
     
104. 104:        abc5        abc2        abc1        abc4        abc3
     
105. 105:        abc5        abc2        abc3        abc1        abc4
     
106. 106:        abc5        abc2        abc3        abc4        abc1
     
107. 107:        abc5        abc2        abc4        abc1        abc3
     
108. 108:        abc5        abc2        abc4        abc3        abc1
     
109. 109:        abc5        abc3        abc1        abc2        abc4
     
110. 110:        abc5        abc3        abc1        abc4        abc2
     
111. 111:        abc5        abc3        abc2        abc1        abc4
     
112. 112:        abc5        abc3        abc2        abc4        abc1
     
113. 113:        abc5        abc3        abc4        abc1        abc2
     
114. 114:        abc5        abc3        abc4        abc2        abc1
     
115. 115:        abc5        abc4        abc1        abc2        abc3
     
116. 116:        abc5        abc4        abc1        abc3        abc2
     
117. 117:        abc5        abc4        abc2        abc1        abc3
     
118. 118:        abc5        abc4        abc2        abc3        abc1
     
119. 119:        abc5        abc4        abc3        abc1        abc2
     
120. 120:        abc5        abc4        abc3        abc2        abc1
     

复制代码

五个for循环解决问题！{:soso_e130:}

贾永长 发表于 2013-6-26 00:38
运行结果：五个for循环解决问题！

你这不是随机获取吧。

贾永长 发表于 2013-6-26 00:38
运行结果：五个for循环解决问题！

import java.util.*;
class Random{
        public static void main(String[] args){
                String s[] = {"abc1","abc2","abc3","abc4","abc5"};
                method(s);
               
       
        }
        public  static void method(Object[] news2){
                if(news2.length==0)
                        return;
                List<Object>list = new ArrayList<Object>();
                for(Object str : news2)
                {
                        list.add(str);
                }
                int len = list.size();
                int x = (int)(Math.random()*len);
//                System.out.println(x);
                Object  str = list.remove(x);
                System.out.println(str);
                Object[] news =null;
                news = list.toArray();
//                for(Object obj :news)
//                {
//                        System.out.println(obj);
//                }
                method(news);
               
               
               
        }
}
这个可以随机获取哦

1. import java.util.*;
   
2. 
   
3. class Random {
   
4.         public static void main(String[] args) {
   
5.                 Object s[] = { "abc1", "abc2", "abc3", "abc4", "abc5" };
   
6.                 method(s);
   
7. 
   
8.         }
   
9. 
   
10.         public static void method(Object[] news2) {
    
11.                 if (news2.length == 0)
    
12.                         return;
    
13.                 List<Object> list = new ArrayList<Object>();
    
14.                 for (Object str : news2) {
    
15.                         list.add(str);
    
16.                 }
    
17.                 int len = list.size();
    
18.                 int x = (int) (Math.random() * len);
    
19. 
    
20.                 Object str = list.remove(x);
    
21.                 System.out.println(str);
    
22.                 Object[] news = null;
    
23.                 news = list.toArray();
    
24. 
    
25.                 method(news);
    
26. 
    
27.         }
    
28. }

复制代码

王靖远 发表于 2013-6-26 01:18

原来如此啊 随机获取 不错！赶紧保存下来:)

王靖远 发表于 2013-6-26 01:18

这里的for (Object str : news2) 不明白，这是一个普通的for循环语句吗？最简单的for语句不是for(;;);这样写的吗?

王广亚 发表于 2013-6-26 08:57
这里的for (Object str : news2) 不明白，这是一个普通的for循环语句吗？最简单的for语句不是for(;;);这 ...

这是增强for循环！
格式：
for（type 变量名：集合变量名）{... ...}

L.I.F.E 发表于 2013-6-26 09:03
这是增强for循环！
格式：
for（type 变量名：集合变量名）{... ...}

谢谢你的解答，但是还是不明白怎样循环的，能详细点吗？

王广亚 发表于 2013-6-26 09:10
谢谢你的解答，但是还是不明白怎样循环的，能详细点吗？

就是说 如果你想遍历一个集合或一个数组 ，采用增强for循环。

1. int[] arr = new int[]{1,2,3,4,5};
   
2. //增强for
   
3. for(int i : arr){
   
4.     System.out.println(i);
   
5. }
   
6. //传统for
   
7. for(int i = 0; i < arr.length; i++){
   
8. System.out.println(arr[i]);
   
9. }

复制代码

用随机函数Random     详细信息查API

王广亚 发表于 2013-6-26 08:57
这里的for (Object str : news2) 不明白，这是一个普通的for循环语句吗？最简单的for语句不是for(;;);这 ...

这是高级for循环，学到后面毕老师会说哦。这种for循环有局限性只能遍历。比普通for循环少了个变量。

王靖远 发表于 2013-6-26 11:14
这是高级for循环，学到后面毕老师会说哦。这种for循环有局限性只能遍历。比普通for循环少了个变量。 ...

哦，谢谢。我再往后看看那教程。

王靖远 发表于 2013-6-26 01:16
import java.util.*;
class Random{
        public static void main(String[] args){

有种更加简洁的方法

1. class RandomTest {
   
2.         public static void main(String[] args) {
   
3.                 String s[] = { "abc1", "abc2", "abc3", "abc4", "abc5" };
   
4.                 String s2[] = s;                                                                                //拷贝一份字符串
   
5.                 Random ran = new Random();       
   
6.                 for (int i = 0; i < s2.length;) {                                                //计数器在循环中根据条件改变
   
7.                         int index = ran.nextInt(s2.length);                                       
   
8.                         if (!s2[index].isEmpty()) {                                                        //判断是随机到的下标对应值是否为空
   
9.                                 System.out.println(s2[index]);                                        //输出值并把对应值设为空
   
10.                                 s2[index] ="";                                                                        //自增计数器
    
11.                                 i++;
    
12.                         }
    
13. 
    
14.                 }
    
15. 
    
16.         }
    
17. }

复制代码

这个是在《编程珠玑》上看到的，原题是说：如何获得一万个不重复的电话号码？ 解题思路就是，先有序的输出一个电话号码列表，然后随机的去取其中的某个号码，并且在取出后删除这个号码。

秩宇 发表于 2013-6-26 11:31
有种更加简洁的方法这个是在《编程珠玑》上看到的，原题是说：如何获得一万个不重复的电话号码？ 解题思 ...

这样也可以，方法大同小异，有思路就好了，我用递归做的。

王靖远 发表于 2013-6-26 12:01
这样也可以，方法大同小异，有思路就好了，我用递归做的。

我们算法老师说，能用迭代最好不用递归，因为要考虑栈溢出。所以我一般很少写递归。

秩宇 发表于 2013-6-26 12:13
我们算法老师说，能用迭代最好不用递归，因为要考虑栈溢出。所以我一般很少写递归。 ...

递归效率也低，能不用则不用吧，不过这种思想还是要掌握的。

L.I.F.E 发表于 2013-6-26 09:27
就是说 如果你想遍历一个集合或一个数组 ，采用增强for循环。

明白了谢谢

王靖远 发表于 2013-6-26 12:23
递归效率也低，能不用则不用吧，不过这种思想还是要掌握的。

嗯，其实有种叫“尾递归”的技术，据说可以改进递归的效率，有兴趣可以去了解下。

学习了，呵呵