Java问题， 输出n个范围在1~10000的不同的随机数，并且以从大到小的顺序排列

为了让你看的清楚,取随即数的方法写的很仔细:看懂了这个方法,很多地方都用的到
package com.soft.bean;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class SortTest {
//从一个给定的数组arr中,随机返回num个不重复项
public Integer[] getArrayItems(Integer[] arr, int num) {
//新建一个数组,将传入的数组复制过来,用于运算,而不要直接操作传入的数组;
Integer[] temp_array = Arrays.copyOf(arr, arr.length);
//取出的数值项,保存在此数组
Integer[] return_array = new Integer[num];
for (int i = 0; i < num; i++) {
//判断如果数组还有可以取出的元素,以防下标越界
if (temp_array.length > 0) {
//在数组中产生一个随机索引
int arrIndex = (int) Math.floor(Math.random() * temp_array.length);
//将此随机索引的对应的数组元素值复制出来
return_array[i] = temp_array[arrIndex];
//然后删掉此索引的数组元素,这时候temp_array变为新的数组
//System.arraycopy(arr, 0, temp_array, 0, arrIndex);
//System.arraycopy(arr, arrIndex+1, temp_array, arrIndex, temp_array.length-arrIndex);
temp_array = removeArrayItem(temp_array,arrIndex);
} else {
//数组中数据项取完后,退出循环,比如数组本来只有10项,但要求取出20项.
break;
}
}
return return_array;
}
// 写一个泛型方法可以适应大部份类型的需求。
// ----------------------------------------------
/**
* @param 数组中的元素类型
* @param arrs 需要删除元素的数组。
* @param index 需要删除的元素的索引（出界时抛异常）。
* @return 指定类型的新数组。
*/
public static T[] removeArrayItem(T[] arrs, int index) {
int len = arrs.length;
if(index < 0 || index >= len) {
throw new IllegalArgumentException("索引出界");
}
List list = new LinkedList();
for(int i = 0; i < len; i++) {
if(i != index) {
list.add(arrs[i]);
}
}
// 这里将改变传入的数组参数 arrs 的值
arrs = list.toArray(arrs);
return java.util.Arrays.copyOf(arrs, arrs.length - 1);
}
public static void main(String[] args) {
Integer[] arr = new Integer[10000];
System.out.println("输入一个N值：");
Scanner reader = new Scanner(System.in);
int n = reader.nextInt();
for(int i=1;i<=10000;i++){
arr[i-1]=i;
}
SortTest st = new SortTest();
Integer[] my_array = st.getArrayItems(arr,n);
//用sort()方法排序
Arrays.sort(my_array,Collections.reverseOrder());
for(int i=0;i System.out.println(my_array[i]);
}

}
}

楼上那个朋友没有注意去掉重复的随机数，我用他的补充了一下。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
public class SortRandom {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//输入n
Scanner input = new Scanner(System.in);
int n = input.nextInt();
//为了去重复方便，创建一个链表
List tempList = new ArrayList();
for(int i = 1; i <= 10000; i++){
tempList.add(i);
}
List list = new ArrayList(n);
int nTemp = 0;
Random rd = new Random();
for (int i = 0; i < n; i++) {
nTemp = rd.nextInt(10000);
//通过随机出来的数得到一个下标，再通过下标到链表取值，对链表长度求余，防止下标越界。或者在上边随机的时候修改随机范围
int j = nTemp % tempList.size();
list.add(tempList.get(j));
//取到值之后从原来的链表删掉这个值，以防重复。如果n很小的时候这样做很麻烦，不如直接判断的好，但是如果n很大，比如说5000，要是判断去重就不知道要判断多少次了，影响效率。
tempList.remove(j);
}
for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println("\n-----After been sorted-----");
Collections.sort(list);
for (Integer i : list) {
System.out.print(i + " ");
}
}
}

我自己想的去重复的方法，可能不是最好的，你要是有好的咱们交流一下，呵呵。
我在eclipse里面试了，n输入的太大的话就显示不下了，不过debug可以看到，还是对的。

package com.king.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class SortRandom {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 10;
List list = new ArrayList(n);
int nTemp = 0;
Random rd = new Random();
for (int i = 0; i < n; i++) {
nTemp = rd.nextInt(10000);
list.add(nTemp);
}
for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println("\n-----After been sorted-----");
Collections.sort(list);
for (Integer i : list) {
System.out.print(i + " ");
}
}
}

冒泡排序，百度看看

来个数组，然后java.util.Array.sort()一排列不就好了吗