9、 定义一个静态方法，该方法可以接收一个List<Integer>，方法内对List进行排序。
我的思路：将集合中的元素取出，存入arr[]数组中，再对arr[]进行排序，再将排序后arr[]数组中的元素存入集合。
请问这个思路是否可行，如果可行，那么如何将集合中的元素存入数组？又如何将数组中的元素存入集合呢？

sunshine9091 发表于 2014-9-6 22:29
纯手工打造！

import java.util.ArrayList;

6666666666

scoto263 发表于 2014-11-16 01:43
public class timu9 {
        public static void main(String args[]){
                List list =new ArrayList();

谢谢大神,终于把这个问题解决了

niucha,

      好棒好棒....

大概看懂了

piaoguoaaa

sunshine9091 发表于 2014-9-6 22:29
纯手工打造！

import java.util.ArrayList;

你排序后并没有赋值给集合

public class timu9 {
        public static void main(String args[]){
                List list =new ArrayList<Integer>();
                list.add(11);
                list.add(33);
                list.add(22);
                list.add(8);
                list.add(3);
                System.out.println("排序前的集合为"+list);
               
                System.out.println("排序后的集合为"+sort(list).toString());
               
        }

        private static List sort(List<Integer> list) {
                int[] in=new int[list.size()];
                for(int i=0;i<in.length;i++){
                        in[i]=list.get(i);
                       
                }
               
//                对数组进行排序
                for(int x=0;x<in.length-1;x++){
                        for(int y=x+1;y<in.length;y++){
                                if(in[x]>in[y]){
                                        int temp;
                                        temp=in[x];
                                        in[x]=in[y];
                                        in[y]=temp;
                                       
                                }
                        }
                }
               
//                对LIST 元素重新进行赋值
                System.out.println();
                for(int i=0;i<in.length;i++){
                        list.set(i, in[i]);
                }
                return list;
                // TODO 自动生成的方法存根
               
        }

}

public class Test9 {
        public static void main(String[] args) {
                //创建集合对象
                List<Integer> list = new ArrayList<Integer>();
                //向集合中添加元素
                list.add(12);
                list.add(15);
                list.add(8);
                list.add(35);
                list.add(82);
                list.add(54);
                list.add(69);
                //调用方法，对集合进行排序
                sortDemo(list);
        }
        //定义一个静态方法，接收一个List集合，集合中的元素为Integer类型
        public static void sortDemo(List<Integer> list) {
                System.out.println("排序前的集合为：");
                //使用增强for遍历这个集合
                for (Integer i : list) {
                        //把这个集合中的元素变为字符串输出
                        System.out.print(String.valueOf(i) + " ");
                }
                //换行
                System.out.println();
                System.out.println("排序后的集合为：");
                //对集合进行排序
                Collections.sort(list);
                //遍历集合
                Iterator<Integer> it=list.iterator();
                //判断集合中是否有下一个元素
                while(it.hasNext()){
                        //输出排序后的集合
                        System.out.print(String.valueOf(it.next()) + " ");
                }
               
        }
}

纯手工打造！

import java.util.ArrayList;
import java.util.List;

public class Test9{  
        public static void main(String[] args) {  
                //新建一个集合向集合中添加 元素
                List<Integer> list=new ArrayList<Integer>();
                list.add(1);
                list.add(9);
                list.add(2);
                list.add(8);
                list.add(3);
                list.add(7);
                list.add(6);
                //输出排序前的集合
                System.out.println("排序前："+list);
                //调用自定义的排序函数
               
                getList(list);  
        }
        //自定义一个对集合中元素排序的函数
        public static void getList(List<Integer> list){
                int a=list.size();
                int[] arr=new int[a];
                //将集合转换成数组
                for(int i=0;i<a;i++){
                        arr[i]=list.get(i);
                }
                //遍历数组中的元素，比较大小，并交换位置
                for(int i=0;i<arr.length-1;i++){
                   for(int j=0;j<arr.length-i-1;j++){
                        if(arr[j]>arr[j+1]){
                                        int temp= arr[j];
                                        arr[j] =arr[j+1];
                                        arr[j+1] = temp;
                        }
                   }
                }
                //创建一个缓存，用于存放排序后的元素
                StringBuffer sb=new StringBuffer();
                for(int i=0;i<arr.length;i++){
                        if(i==0){
                                sb.append("排序后：["+arr[i]);
                        }else{
                                sb.append(", "+arr[i]);
                        }
                }
                sb.append("]");
                //打印出缓存中的数据
                System.out.println(sb.toString());
               
        }
}

直接用TreeSet集合便是，可自定义一个比较器进行元素的排序。

Collections是Collection的工具集，看看API就知道用了

1. //9、 定义一个静态方法，该方法可以接收一个List<Integer>，方法内对List进行排序。
   
2. package com.itheima;
   
3. import java.util.ArrayList;
   
4. import java.util.Collections;
   
5. import java.util.List;
   
6. public class ListSort {
   
7.         /**
   
8.          * @param args
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 List<Integer> list=new ArrayList<Integer> ();
    
12.                 list.add(9);
    
13.                 list.add(1);
    
14.                 list.add(5);
    
15.                 list.add(6);
    
16.                 list.add(2);               
    
17.                 sort(list);
    
18.                 /*Iterator<Integer> it=list.iterator();
    
19.                 while(it.hasNext())
    
20.                 {
    
21.                         System.out.println(it.next());
    
22.                 }*/
    
23.                 System.out.println(list);               
    
24.         }
    
25.         private static void sort(List<Integer> list) {
    
26.                 // TODO Auto-generated method stub
    
27.                 Collections.sort(list);
    
28.         }
    
29. }
    

复制代码

这个不用这么麻烦的，使用Collections.sort 就可以排序了~

简单排序，查看 Collections 类。

先对集合进行迭代
创建一个等长数组
迭代的过程中对数组的元素进行赋值
对数组进行排序
然后再对集合进行迭代
把数组的值赋值给迭代到集合元素的值
基本OK

嘿嘿  不用那么麻烦