黑马程序员技术交流社区

标题: 做练习题的疑问？？？ [打印本页]
作者: HM汪磊    时间: 2013-3-18 11:43
标题: 做练习题的疑问？？？
本帖最后由 HM汪磊 于 2013-3-18 15:02 编辑

题目：
写一个集合，集合存放的是整形的数据。写一个帮助类，帮组类中有两个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;//返回临时集合
        }
}
作者: 谢波    时间: 2013-3-18 13:03
  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);

  14.         System.out.print("原数组为：");
  15.         System.out.println(al);

  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. }



  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. }
复制代码
作者: 宋耀冬    时间: 2013-3-18 13:09
这是我做的 ， 希望对你有帮助  能服用的代码都给他封装成函数



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);
                                }
                        }
                }
        }
}
作者: HM汪磊    时间: 2013-3-18 13:28
谢波 发表于 2013-3-18 13:03

很好，学习啦！！！谢谢
作者: 杨玉辉    时间: 2013-3-18 13:33
兄弟 这个代码 顺序，是老毕特意 循序渐进 慢慢来做的，旨在让大家理解里面的逻辑思路。

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

不过也别急着去看，毕竟里面的东西需要集合的思想和方法，搞定这些也就多了认识，以后有的用
作者: 陈丽莉    时间: 2013-3-18 14:45
若还有问题，请继续追问，没有的话，请将帖子分类改成【已解决】~



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2