题目：
写一个集合，集合存放的是整形的数据。写一个帮助类，帮组类中有两个static方法，
一个方法为从大到小的顺序排序，一个方法为从小到大的顺序排序。实现上述的代码。


我编写出的程序实现了此功能，但是觉得麻烦，各为看看有简便的方法吗？请写出具体代码。互相学习

我写的代码：完全是按自己思想写的，我觉得应该用集合排序的方法，所以请教各位。
import java.util.*;
class  Test9
{
        public static void main(String[] args)
        {
                ArrayList<Integer> al = new ArrayList<Integer>();
                al.add(5);
                al.add(4);
                al.add(6);
                al.add(8);
                al.add(10);
                al.add(1);

                System.out.print("原数组为：");
                Iterator<Integer> it2 = al.iterator();
                while(it2.hasNext())
                {
                     System.out.print(it2.next()+" ");
                }

                System.out.println();//换行作用

                System.out.print("按从小到大排序后数组为：");
        ArrayList a3=Setarray.minToMax(al);
                Iterator<Integer> it = a3.iterator();
                while(it.hasNext())
                {
                     System.out.print(it.next()+" ");
                }
                System.out.println();//换行作用

                System.out.print("按从大到小排序后数组为：");
                ArrayList a4=Setarray.maxToMin(al);
                Iterator<Integer> it1 = a4.iterator();
                while(it1.hasNext())
                {
                     System.out.print(it1.next()+" ");
                }
               
        }
}



class Setarray
{
        //定义方法，作用：使集合中元素从小到大排序
        public static ArrayList<Integer> minToMax(ArrayList tt)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();
                Integer[] arr = (Integer[])tt.toArray(new Integer[tt.size()]);//将集合中元素转换为数组中元素
                int k;
                //对数组中元素按从小到大排序
                for(int x=0;x<arr.length;x++)
                {
                      for(int y=x+1;y<arr.length;y++)
                                {
                                        if(arr[y]<arr[x])
                                        {
                                            k=arr[y];
                                                arr[y]=arr[x];
                                                arr[x]=k;
                                        }
                                }
                }
                //将排序后元素按顺序存储在临时集合中
                for(int x=0;x<arr.length;x++)
                {
                        newAl.add(arr[x]);
                }
                return newAl;//返回临时集合
        }
        //定义方法，作用：使集合中元素从大到小排序
        public static ArrayList<Integer> maxToMin(ArrayList tt)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();
                Integer[] arr = (Integer[])tt.toArray(new Integer[tt.size()]);//将集合中元素转换为数组中元素
                int k;
                //对数组中元素按从大到小排序
                for(int x=0;x<arr.length;x++)
                {
                      for(int y=x+1;y<arr.length;y++)
                                {
                                        if(arr[y]>arr[x])
                                        {
                                            k=arr[y];
                                                arr[y]=arr[x];
                                                arr[x]=k;
                                        }
                                }
                }
                //将排序后元素按顺序存储在临时集合中
                for(int x=0;x<arr.length;x++)
                {
                        newAl.add(arr[x]);
                }
                return newAl;//返回临时集合
        }
}

1. import java.util.*;
   
2. public class  Test9
   
3. {
   
4.     public static void main(String[] args)
   
5.     {
   
6.         ArrayList<Integer> al = new ArrayList<Integer>();
   
7.         al.add(5);
   
8.         al.add(4);
   
9.         al.add(6);
   
10.         al.add(8);
    
11.         al.add(10);
    
12.         al.add(1);
    
13. 
    
14.         System.out.print("原数组为：");
    
15.         System.out.println(al);
    
16. 
    
17.         Setarray.minToMax(al);
    
18.         System.out.print("按从小到大排序后数组为：");
    
19.         System.out.println(al);
    
20.         
    
21.         Setarray.maxToMin(al);
    
22.         System.out.print("按从大到小排序后数组为：");
    
23.         System.out.println(al);
    
24.     }
    
25. }
    
26. 
    
27. 
    
28. 
    
29. class Setarray
    
30. {
    
31.     //定义方法，作用：使集合中元素从小到大排序
    
32.     public static void minToMax(ArrayList<Integer> al)
    
33.     {
    
34.             for(int x=0;x<al.size()-1;x++)
    
35.             {
    
36.                     for(int y=0;y<al.size()-x-1;y++)
    
37.                     {
    
38.                             if(al.get(y)>al.get(y+1))
    
39.                                     al.set(y,al.set(y+1,al.get(y)));
    
40.                     }
    
41.             }
    
42.     }
    
43.     //定义方法，作用：使集合中元素从大到小排序
    
44.     public static void maxToMin(ArrayList<Integer> al)
    
45.     {
    
46.             for(int x=0;x<al.size()-1;x++)
    
47.             {
    
48.                     for(int y=0;y<al.size()-x-1;y++)
    
49.                     {
    
50.                             if(al.get(y)<al.get(y+1))
    
51.                                     al.set(y,al.set(y+1,al.get(y)));
    
52.                     }
    
53.             }
    
54.     }
    
55. }

复制代码

这是我做的 ， 希望对你有帮助  能服用的代码都给他封装成函数



class ArrayT
{
        public static void main(String[] args)
        {
                int[] arr = {5,1,6,4,2,8,9};//定义数组
                //排序前
                printArray(arr);
                //升序排序
                bubbleSort(arr);
                //排序后
                printArray(arr);
                //降序排序
                bubbleSort_2(arr);
                //排序后
                printArray(arr);
        }

        //打印数组方法
        public static void printArray(int[] arr)
        {
                System.out.print("[");

                for (int x=0; x<arr.length; x++)
                {
                        if (x != arr.length - 1)
                        {
                                System.out.print(arr[x]+", ");
                        }
                        else
                                System.out.println(arr[x]+"]");
                }
        }

        //比较数据，交换位置方法
        public static void swap(int[] arr,int a,int b)
        {
                int temp = arr[a];
                arr[a] = arr[b];
                arr[b] = temp;
        }

        //算法冒泡升序排列
        public static void bubbleSort(int[] arr)
        {
                for (int x=0; x<arr.length ; x++)
                {
                        for (int y=0; y<arr.length-x-1; y++)//-x:让每一比较的元素减少，-1：避免角标越界。
                        {
                                if (arr[y]>arr[y+1])
                                {
                                        swap(arr,y,y+1);
                                }
                        }
                }
        }

        //冒泡算法降序排列
        public static void bubbleSort_2(int[] arr)
        {
                for (int x=0; x<arr.length ; x++)
                {
                        for (int y=0; y<arr.length-x-1; y++)//-x:让每一比较的元素减少，-1：避免角标越界。
                        {
                                if (arr[y]<arr[y+1])
                                {
                                        swap(arr,y,y+1);
                                }
                        }
                }
        }
}

谢波 发表于 2013-3-18 13:03

很好，学习啦！！！谢谢

兄弟 这个代码 顺序，是老毕特意 循序渐进 慢慢来做的，旨在让大家理解里面的逻辑思路。

所以，慢慢看，到后面讲到 Collections 的时候，里面有专门的方法，直接调用方法排序。

不过也别急着去看，毕竟里面的东西需要集合的思想和方法，搞定这些也就多了认识，以后有的用

若还有问题，请继续追问，没有的话，请将帖子分类改成【已解决】~