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

import java.util.ArrayList;
public class Demo1
{
/**
  * @param args
  */
public static void main(String[] args)
{
  /*写一个集合，集合存放的是整形的数据。写一个帮助类，
  帮组类中有两个static方法，
  一个方法为从大到小的顺序排序，一个方法为从小到大的顺序排序。
  实现上述的代码 用集合中的工具类实现
*/
  ArrayList<Integer> al=new ArrayList<Integer>();
  al.add(5);
  al.add(3);
  al.add(6);
  al.add(3);
  al.add(1);
  al.add(19);
  al.add(12);
  al.add(8);
  
  
  HelpDemo.sortMax(al);
  System.out.println(al);
  
  HelpDemo.sortMIn(al);
  System.out.println(al);
  
  
}
}

帮助类：
mport java.util.ArrayList;
import java.util.Collections;

public class HelpDemo
{
public static void sortMax(ArrayList<Integer> al)
{
  Collections.sort(al);           
  
}
public static void sortMIn(ArrayList<Integer> al)
{
  Collections.reverse(al);
}

}
这上面是一种简单的方法
如果你自己写排序方法的话：我把主要的地方给你：
   用的思想就是选择排序或是冒泡排序，
   在排序中交换值时，这个地方是关键点：
  你可以这样 定义一个temp，然后使用set通过角标来修改。

public static void main(String[] args)
        {
                //定义一个整型数组对象
                Integer[] arr = { 3, 4, 8, 1, 6, 2, 5, 45, 12, 33 };
                List<Integer> list = Arrays.asList(arr);//将数组对象转换为List集合
                System.out.println("排序之前:");
                for(Iterator<Integer> it=list.iterator();it.hasNext();)//排序前打印List集合
                {
                        System.out.print(it.next()+" ");
                }
               
                //从大到小排序
                list = Test9_Help.bigToSmall(list);
                System.out.println();//换行
                System.out.println("从大到小排序之后:");
                for(Iterator<Integer> it=list.iterator();it.hasNext();)//排好序后打印List集合
                {
                        System.out.print(it.next()+" ");
                }
               
                //从小到大排序
                list = Test9_Help.smallToBig(list);
                System.out.println();//换行
                System.out.println("从小到大排序之后:");
                for(Iterator<Integer> it=list.iterator();it.hasNext();)//排好序后打印List集合
                {
                        System.out.print(it.next()+" ");
                }
        }
}
class Test9_Help
{
        /**
         * 从小到大排序
         * @param list 原始的集合
         * @return 排好序的集合
         */
        public static List<Integer> smallToBig(List<Integer> list)
        {
                Integer[] arr = (Integer[]) list.toArray();
                int k;
                for (int i = 0; i < arr.length - 1; i++)
                {
                        int temp = i;
                        for (int j = i + 1; j < arr.length; j++)
                        {
                                if (arr[temp] > arr[j])
                                {
                                        temp = j;
                                }
                        }
                        if(temp!=i)
                        {
                                k=arr[temp];
                                arr[temp]=arr[i];
                                arr[i]=k;
                        }
                }
                return Arrays.asList(arr);
        }
       
        /**
         * 从大到小排序
         * @param list 原始的集合
         * @return 排序后的集合
         */
        public static List<Integer> bigToSmall(List<Integer> list)
        {
                Integer[] arr = (Integer[]) list.toArray();
                int k;
                for (int i = 0; i < arr.length - 1; i++)
                {
                        int temp = i;
                        for (int j = i + 1; j < arr.length; j++)
                        {
                                if (arr[temp] < arr[j])
                                {
                                        temp = j;
                                }
                        }
                        if(temp!=i)
                        {
                                k=arr[temp];
                                arr[temp]=arr[i];
                                arr[i]=k;
                        }
                }
                return Arrays.asList(arr);
        }

直接上代码：
package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Demo {

       
        public static void main(String[] args) {
                ArrayList<Integer> c=new ArrayList<Integer>();//创建集合对象
                c.add(34);//增加元素
                c.add(56);
                c.add(23);
                c.add(45);
                HelpClass.minToMax(c);//调用方法，升序
                System.out.println(c);//测试
                HelpClass.maxToMin(c);//调用方法，降序
                System.out.println(c);//测试
               

        }

}
class HelpClass{//帮助类
        public static void minToMax(ArrayList<Integer> c){//升序方法
                int [] arr=new int[c.size()];//创建数组
                for(int i=0;i<c.size();i++){//遍历集合
                        arr[i]=c.get(i);//把集合中的元素的值赋给数组中的元素
                }
                c.clear();//清除集合中的元素
                Arrays.sort(arr);//对数组进行排序
                for(int x=0;x<arr.length;x++){
                        c.add(arr[x]);//把数组中的元素添加到集合
                }
        }
        public static void maxToMin(ArrayList<Integer> c){//降序方法
                int [] arr=new int[c.size()];
                for(int i=0;i<c.size();i++){
                        arr[i]=c.get(i);
                }
                c.clear();
                Arrays.sort(arr);
                for(int x=arr.length-1;x>0|x==0;x--){
                        c.add(arr[x]);
                }
        }
}

我去，用集合的工具类呀，看错了{:soso_e127:}