重赏之下，必有勇夫！

Question

我有个题目，是这样的。用Arrilist 进行排序。
import java.util.*;public class ListHome {

public static void main(String args[])
{

  ArrayList<Integer> arrayList=new ArrayList<Integer>();
  arrayList.add(1);
  arrayList.add(2);
  arrayList.add(3);
  arrayList.add(4);
  Collections.sort(List<Integer> arrayList);


}
}
目的要求使用：Collections 里面的  sort方法进行排序，感觉很复杂 又要用到泛型和接口 实在不会了。
   static <T extends Comparable<? super T>>   void        sort(List<T> list) 
          根据元素的自然顺序 对指定列表按升序进行排序。
或者   static <T> void   sort(List<T> list, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定列表进行排序。 实在不会了，请高手将字符  升序排。要代码。 我写到上面就不会了。

Answer 1

import java.util.ArrayList;
import java.util.Collections;public class ListHome {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(5);
arrayList.add(4);
arrayList.add(3);
arrayList.add(2);
arrayList.add(1);
Collections.sort(arrayList);

for (int i:arrayList) {
System.out.print(i+"\t");
}
}
}
你帖到Eclipse里面看一下吧。

Answer 2

我是要做按照 字符串排序  不是用 Integer 排序。

Answer 3

String Integer 等这些常见的不是都实现了Comparable了吗？
类 String
java.lang.Object
  java.lang.String
所有已实现的接口： 
Serializable, CharSequence, Comparable<String> 

Answer 4

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class CompareTest { public static void main(String args[]) { List<String> arrayList = new ArrayList<String>();
arrayList.add("7adfakfd");
arrayList.add("1dffakfd");
arrayList.add("3adeakfd");
arrayList.add("4adfdkfd");
arrayList.add("adfekfd");
arrayList.add("qdfakfd");
arrayList.add("adfakfd");
System.out.println(arrayList);
Collections.sort(arrayList);
System.out.println(arrayList);
Collections.reverse(arrayList);
System.out.println(arrayList);

List<Integer> arrayList2 = new ArrayList<Integer>();
arrayList2.add(1243634);
arrayList2.add(254);
arrayList2.add(745);
arrayList2.add(4);
arrayList2.add(6795);
arrayList2.add(32454545);
arrayList2.add(654353);
System.out.println(arrayList2);
Collections.sort(arrayList2);
System.out.println(arrayList2);
Collections.reverse(arrayList2);
System.out.println(arrayList2); }}

Answer 5

所以，很郁闷啊。  请各位把题目 看清楚。  要用泛型接口的 Collections 里面的 sort方法进行排序
 对字符升序排列，可能用到的API 方法 我已经贴出来了，另外 我还发了一个加分 帖子。  所以，帮我搞出来了的 有200分奖励。

Answer 6

arrayList.add(1);
  arrayList.add("aa");
  arrayList.add("bb");
  arrayList.add("cc");举个例子 对这个降序排列

Answer 7

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;public class ListHome { /**
 * @param args
 */
public static void main(String[] args) {
// TODO 自动生成方法存根
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("vss");
arrayList.add("sad");
arrayList.add("asd");
arrayList.add("das");
arrayList.add("gdss");
Collections.sort(arrayList);

for (String i:arrayList) {
System.out.print(i+"\t");
}
}
}
好像这样就可以了。自己试一下吧

Answer 8

Collections.reverse() 这个方法也不能用？

Answer 9

 Collections类部分源代码：
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
    i.next();
    i.set((T)a[j]);
}
    }

Answer 10

Collections.sort();
Collections.reverse();
这两个方法结合起来用可以实现降序排序。

Answer 11

Collections.sort(list,new Comparator(){ public int compare(Object o1, Object o2){
　　　　　　　　　　　　　　　　　　　　return (o1.hashCode()-o2.hashCode());}}); 

Answer 12

试试吧import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;public   class   TestSort   { 
        public   static   void   main(String   args[]){ 
           ArrayList<Integer> arrayList=new ArrayList<Integer>();
   arrayList.add(1);
   arrayList.add(12);
   arrayList.add(3);
   arrayList.add(2);
   Collections.sort(arrayList,new MyComparator());
   for(int i=0;i<arrayList.size();i++){
   System.out.println(arrayList.get(i));
   }
        } 
} class   MyComparator   implements   Comparator{ 
        public   MyComparator(){ 
                super(); 
        } 
        public   int   compare(Object   o1,   Object   o2)   { 
         return (Integer)o1-(Integer)o2;
        } 
}

Answer 13

不知道，是不是这个意思。这种排序方法，应该是对一些复杂对象进行排序的。对于Integer这类的，可能看不太出来。感觉不出威力。主要就是实现compare这个方法。使两个对象具有“可比性”，也就是告诉电脑，这种复杂对象应该怎么比。

Answer 14

o1-o2就是升序。换个位置，就是降序。
挺有意思吧。
        public   int   compare(Object   o1,   Object   o2)   { 
         return (Integer)o2-(Integer)o1;
        } 

Answer 15

还没成功接过分，对这道题倒时有点信心，楼主成全我吧，如果有凝问可以Q我 402279001ArrayList<String> strs= new ArrayList<String>();
//省略添加元素的步聚，也就是strs.add();
Comparator<String> strsComparator = new Comparator<String>(){
public int compare(String str1,String str2){
         //这里可以根据你想要的方式排序，因为String已经实现了Comparable 原因
//return str1.compareTo(str2); //升序
//return str2.compareTo(str1)  //降序


//这里再比如String 是个自定义的类没被Comparable 接口

//示例1 ：根据String 的长度升序排序   降序只需要将str1 和 str2 前后调一下就行了
//return str1.length() - str2.length();

//示例2 ：根据String 里面的字符升序排序
int end = str1.length() > str2.length() ? str2.length() : str1.length();
for(int i=0; i<end ; i++){
if(str1.charAt(i)-str2.charAt(i)!=0){
         return str1.charAt(i)-str2.charAt(i);
}
}
return str1.length() - str2.length();

}
};
Collections.sort(strs,strsComparator);

Answer 16

100分，要勇一下：import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class ListHome {    public static void main(String args[]) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        Collections.sort(arrayList, new Comparator<Integer>() {            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }        });
        System.out.println("正序排列后：\n"+arrayList);
        
        Collections.sort(arrayList, new Comparator<Integer>() {            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }        });
        System.out.println("逆序序排列后：\n"+arrayList);
    }}

Answer 17

你可以继承Comparator接口，然后自己重写compare方法，方法交给你了，规则自己是实现吧！！我前几天刚学习的，肯定可以！！！

Answer 18

import java.util.*;public class ListHome {
    
    public static void main(String args[])
    {
    
  ArrayList<Integer> arrayList=new ArrayList<Integer>();
  arrayList.add(1);
  arrayList.add(2);
  arrayList.add(3);
  arrayList.add(4);
  Collections.sort(arrayList);
    }
}不就是这样了吗？？貌似楼主不太勇敢啊··

Answer 19

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Test {
public static void main(String[] args) {


ArrayList<String> as=new ArrayList<String>();
as.add("B");
as.add("A");
as.add("C");
as.add("E");
//用这个方法，排完序后就是升序,如果相要降序，那么还要接着调用reverse方法
Collections.sort(as);//升序
System.out.println(as);
//这个方法可以让集合中的元素按相反的顺序重排
Collections.reverse(as);
System.out.println(as);
//这个方法，可以控制是按升序排还是用降序排
Collections.sort(as, new Comparator<String>(){ public int compare(String a, String b) {
return b.compareTo(a);//降序
//return a.compareTo(b);//升序
}

});
System.out.println(as);
}
}冲着你的高分，我来给个全面的解答，把上面的代码贴到eclips里执行试试

Answer 20

看我写过的一个排序，跟你那个几乎一样的嘛travels = new ArrayList<Map>();
Map map = new HashMap();
map.put("traffic", travel.getTraffic());
map.put("content", travel.getContent());
map.put("hotel", travel.getHotel());
map.put("type", travel.getType());
map.put("opid", travel.getOpid());
map.put("upymd", travel.getUpymd());
travels.add(map);
//对加入了新元素的集合按行程日期重新排序
Collections.sort(travels, new Comparator(){
/* (non-Javadoc)
 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 */
public int compare(Object o1, Object o2) {
Object obj = ((Map)o1).get("tdate");
Integer tdate1 = null;
if(obj instanceof BigDecimal) {
BigDecimal bd1 = (BigDecimal) obj;
tdate1= Integer.valueOf(bd1.toString());
}else if(obj instanceof Integer) {
tdate1 = (Integer) obj;
}
tdate1 = tdate1!=null?tdate1:0;
obj = ((Map)o2).get("tdate");
Integer tdate2 = null;
if(obj instanceof BigDecimal) {
BigDecimal bd2 = (BigDecimal) obj;
tdate2= Integer.valueOf(bd2.toString());
}else if(obj instanceof Integer) {
tdate2 = (Integer) obj;
}
tdate2 = tdate2!=null?tdate2:0;
return tdate1-tdate2;
}
});

Answer 21

在内部类的compare方法里重写排序规则

Answer 22

import java.util.*;    public class ListHome {         
public static void main(String args[])   {      
ArrayList <Integer> arrayList=new ArrayList <Integer>();    
arrayList.add(1);    
arrayList.add(2);    
arrayList.add(3);    
arrayList.add(4);    
Collections.sort(List <Integer> arrayList,new Comparator() {
public int compare(Object o1, Object o2) {
return (Integer)o2-(Integer)o1
}
});        
}      
}

Answer 23

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class TestComparator { public static void main(String args[]) { ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
Collections.sort(arrayList, new Comparator<Integer>() { @Override
public int compare(Integer o1, Integer o2) {
// return o1-o2;
return o2 - o1;
} });
System.out.println(arrayList); }}

Answer 24

这个其实很简单的 就是有点麻烦  试试这个应该没有问题import java.util.*;
public class SortTest { List<TestVo> list = new ArrayList<TestVo>();
public SortTest() {
for (int i = 0; i < 10; i++) {
TestVo vo = new TestVo();
vo.setName("name" + i);
vo.setAge(i);
if(i==6){
vo.setAge(5);
}
if(i==7){
vo.setName("name" + 6);
}
list.add(vo);
}
}
public static void main(String[] args) {
SortTest st = new SortTest();
List<TestVo> list = st.list;

System.out.println("字符串升序排序开始.................");
Collections.sort(list, st.new ScoreStrAsc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("name="+vo.getName()+"  age="+vo.getAge());
}
System.out.println("字符串降序排序开始.................");
Collections.sort(list, st.new ScoreStrDesc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("name="+vo.getName()+"  age="+vo.getAge());
}

System.out.println("int 升序排序开始.................");
Collections.sort(list, st.new ScoreIntAsc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("age="+vo.getAge()+"  name="+vo.getName());
}

System.out.println("int 降序排序开始.................");
Collections.sort(list, st.new ScoreIntDesc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("age="+vo.getAge()+"  name="+vo.getName());
}

} class TestVo {
private String name;
private int age ; public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
}
   // 字符串降序排序
class ScoreStrDesc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
return creditTemp2.getName().compareTo(creditTemp1.getName());
}
}
 // 字符串升序排序
class ScoreStrAsc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
return creditTemp1.getName().compareTo(creditTemp2.getName());
}
}

// int 降序排序
class ScoreIntDesc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
if (creditTemp2.getAge() == creditTemp1.getAge()) {
return 0;
}
if (creditTemp2.getAge() > creditTemp1.getAge()) {
return 1;
}else{
return -1;
}
}
}
// int 升序排序
class ScoreIntAsc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
if (creditTemp1.getAge() == creditTemp2.getAge()) {
return 0;
}
if (creditTemp1.getAge() > creditTemp2.getAge()) {
return 1;
}else{
return -1;
}
}
}
}

Answer 25

public int compare(Integer o1, Integer o2) {              
    return o1.compareTo(o2); 我真没弄懂其中o1 和o2 是什么意思，为啥这样就可以排序了呢？

Answer 26

public class ListHome {
public static void main(String[] args) {
// TODO 自动生成方法存根
ArrayList arrayList = new ArrayList();
arrayList.add(4);
arrayList.add(3);
arrayList.add(2);
arrayList.add("a");
arrayList.add("b");
sort(arrayList);
for (Object i:arrayList) {
System.out.print(i+"\t");
}
}

    public static <T extends Comparable<? super T>> void sort(List<T> list) {
     Object[] a = list.toArray();
     sort(a);
     ListIterator<T> i = list.listIterator();
     for (int j=0; j<a.length; j++) {
         i.next();
         i.set((T)a[j]);
     }
        }
    public static void sort(Object[] a) {
        Object[] aux = (Object[])a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }
    
    private static void mergeSort(Object[] src,
  Object[] dest,
  int low,
  int high,
  int off) {
     int length = high - low;     // Insertion sort on smallest arrays
     if (length < 7) {
     for (int i=low; i<high; i++)
     for (int j=i; j>low &&
     (dest[j-1].toString()).compareTo(dest[j].toString())>0; j--)
              swap(dest, j, j-1);
     return;
     }     // Recursively sort halves of dest into src
     int destLow  = low;
     int destHigh = high;
     low  += off;
     high += off;
     int mid = (low + high) >> 1;
     mergeSort(dest, src, low, mid, -off);
     mergeSort(dest, src, mid, high, -off);     // If list is already sorted, just copy from src to dest.  This is an
     // optimization that results in faster sorts for nearly ordered lists.
     if ((src[mid-1].toString()).compareTo(src[mid].toString()) <= 0) {
     System.arraycopy(src, low, dest, destLow, length);
     return;
     }     // Merge sorted halves (now in src) into dest
     for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
     if (q >= high || p < mid && (src[p].toString()).compareTo(src[q].toString())<=0)
     dest[i] = src[p++];
     else
     dest[i] = src[q++];
     }
    }
    private static void swap(Object[] x, int a, int b) {
     Object t = x[a];
     x[a] = x[b];
     x[b] = t;
        }
}
呵呵，重写了一下Collections类里的sort方法，可以实现了。

Answer 27

public class ListHome {
public static void main(String[] args) {
// TODO 自动生成方法存根
ArrayList arrayList = new ArrayList();
arrayList.add(4);
arrayList.add(3);
arrayList.add(2);
arrayList.add("a");
arrayList.add("b");
sort(arrayList);
for (Object i:arrayList) {
System.out.print(i+"\t");
}
}

    public static <T extends Comparable<? super T>> void sort(List<T> list) {
     Object[] a = list.toArray();
     sort(a);
     ListIterator<T> i = list.listIterator();
     for (int j=0; j<a.length; j++) {
         i.next();
         i.set((T)a[j]);
     }
        }
    public static void sort(Object[] a) {
        Object[] aux = (Object[])a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }
    
    private static void mergeSort(Object[] src,
  Object[] dest,
  int low,
  int high,
  int off) {
     int length = high - low;     // Insertion sort on smallest arrays
     if (length < 7) {
     for (int i=low; i<high; i++)
     for (int j=i; j>low &&
     (dest[j-1].toString()).compareTo(dest[j].toString())>0; j--)
              swap(dest, j, j-1);
     return;
     }     // Recursively sort halves of dest into src
     int destLow  = low;
     int destHigh = high;
     low  += off;
     high += off;
     int mid = (low + high) >> 1;
     mergeSort(dest, src, low, mid, -off);
     mergeSort(dest, src, mid, high, -off);     // If list is already sorted, just copy from src to dest.  This is an
     // optimization that results in faster sorts for nearly ordered lists.
     if ((src[mid-1].toString()).compareTo(src[mid].toString()) <= 0) {
     System.arraycopy(src, low, dest, destLow, length);
     return;
     }     // Merge sorted halves (now in src) into dest
     for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
     if (q >= high || p < mid && (src[p].toString()).compareTo(src[q].toString())<=0)
     dest[i] = src[p++];
     else
     dest[i] = src[q++];
     }
    }
    private static void swap(Object[] x, int a, int b) {
     Object t = x[a];
     x[a] = x[b];
     x[b] = t;
        }
}
呵呵，重写了一下Collections类里的sort方法，可以实现了。

Answer 28

楼主还是多去看看api吧，楼上的答案已经给的这么多了，还不知道咋回事啊，可以结贴了

Answer 29

试试吧我昨天才学的
import java.util.*;
public class SortTest {List<TestVo> list = new ArrayList<TestVo>();
public SortTest() {
for (int i = 0; i < 10; i++) {
TestVo vo = new TestVo();
vo.setName("name" + i);
vo.setAge(i);
if(i==6){
vo.setAge(5);
}
if(i==7){
vo.setName("name" + 6);
}
list.add(vo);
}
}
public static void main(String[] args) {
SortTest st = new SortTest();
List<TestVo> list = st.list;System.out.println("字符串升序排序开始.................");
Collections.sort(list, st.new ScoreStrAsc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("name="+vo.getName()+" age="+vo.getAge());
}
System.out.println("字符串降序排序开始.................");
Collections.sort(list, st.new ScoreStrDesc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("name="+vo.getName()+" age="+vo.getAge());
}System.out.println("int 升序排序开始.................");
Collections.sort(list, st.new ScoreIntAsc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("age="+vo.getAge()+" name="+vo.getName());
}System.out.println("int 降序排序开始.................");
Collections.sort(list, st.new ScoreIntDesc());
for (int i = 0;i< list.size(); i++) {
TestVo vo = list.get(i);
System.out.println("age="+vo.getAge()+" name="+vo.getName());
}}class TestVo {
private String name;
private int age ;public int getAge() {
return age;
}public void setAge(int age) {
this.age = age;
}public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}
}
  // 字符串降序排序
class ScoreStrDesc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
return creditTemp2.getName().compareTo(creditTemp1.getName());
}
}
// 字符串升序排序
class ScoreStrAsc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
return creditTemp1.getName().compareTo(creditTemp2.getName());
}
}// int 降序排序
class ScoreIntDesc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
if (creditTemp2.getAge() == creditTemp1.getAge()) {
return 0;
}
if (creditTemp2.getAge() > creditTemp1.getAge()) {
return 1;
}else{
return -1;
}
}
}
// int 升序排序
class ScoreIntAsc implements Comparator {
public int compare(Object o1, Object o2) {
TestVo creditTemp1 = (TestVo) o1;
TestVo creditTemp2 = (TestVo) o2;
if (creditTemp1.getAge() == creditTemp2.getAge()) {
return 0;
}
if (creditTemp1.getAge() > creditTemp2.getAge()) {
return 1;
}else{
return -1;
}
}
}
}

Answer 30

大哥，直接重写你List里面装的元素的equals方法即可
api里的ArrayList.sort()会自动调用那个equals方法