arraylist中的Java排序数字

Question

I've created an arraylist like this

ArrayList<String> entries = new ArrayList<String>();
entries.add("0 - name1");
entries.add("1000 - name2");
entries.add("1004 - name4");
entries.add("1002 - name3");
entries.add("10000 - name5");
entries.add("2000 - name5");

The list always starts with a number between 0 and 15,000 so when i sort i would like it to just sort based on the number none of the numbers will ever match and they should be assorted in an ascending order.

How can this be done with java can i use a comparator?

Answer 1

Yes, it can be done with a Comparator but it won't be very efficient because you will need to keep parsing the data to extract out the number and then you will need to convert the number to an Integer and do your comparison.

A better approach is to create a custom Object with two properties, number and name. Then you can sort on the number. The Comparator for this will be straight forward. You can search the forum for examples.

Answer 2

can i use a comparator?

yes, you can :)

with syntax : Collections.sort(entries,comparator); - you need to import java.util.Collections and write comparator that makes what you want. You may as well try .sort(entries) using default comparator (but here it will not work :) ).

here's complete solution:

import java.util.Comparator;

public class MyComparator implements Comparator<String> {

    @Override
    public int compare(String arg0, String arg1) {

        int indexOf = arg0.indexOf("-");
        String substring = arg0.substring(0, indexOf-1);
        int indexOf1 = arg1.indexOf("-");
        String substring1 = arg1.substring(0, indexOf1-1);
        return Integer.valueOf(substring) - Integer.valueOf(substring1);
    }

}


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Runner {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String> entries = new ArrayList<String>();
        entries.add("0 - name1");
        entries.add("1000 - name2");
        entries.add("1004 - name4");
        entries.add("1002 - name3");
        entries.add("10000 - name5");
        entries.add("2000 - name5");

        Comparator<String> comparator = new MyComparator();
        Collections.sort(entries, comparator );

        for (String e : entries){
            System.out.println(e);
        }

    }
}

Also - I strongly suggest to declare lists likes this: List<String> entries = new ArrayList<String>(); Later you may find benefits of using LinkedList in place of ArrayList - then changing implementation of used list would be simplest possible.

Plz google "Program to interface not to implementation". :)

Answer 3

Write a Comparator<String> that splits the inputs at - . Parse the first element with Integer.parseInt (trim if necessary). Than do the comparation with the refined integer values.
Code:

class MyComp implements Comparator<String> {
     public int compare(String s1, String s2) {
           int v1 = Integer.parseInt(s1.split("-")[0]);
           int v2 = Integer.parseInt(s2.split("-")[0]);
           return v1 - v2;
     }

}

Answer 4

Maybe you would like to try my number sorting algorithm:

package drawFramePackage;
import java.awt.geom.AffineTransform;
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Random;
public class QuicksortAlgorithm {
    ArrayList<AffineTransform> affs;
    ListIterator<AffineTransform> li;
    Integer count, count2;
    /**
     * @param args
     */
    public static void main(String[] args) {
        new QuicksortAlgorithm();
    }
    public QuicksortAlgorithm(){
        count = new Integer(0);
        count2 = new Integer(1);
        affs = new ArrayList<AffineTransform>();
        for (int i = 0; i <= 128; i++){
            affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0));
        }
        affs = arrangeNumbers(affs);
        printNumbers();
    }
    public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){
        while (list.size() > 1 && count != list.size() - 1){
            if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){
                list.add(count, list.get(count2));
                list.remove(count2 + 1);
            }
            if (count2 == list.size() - 1){
                count++;
                count2 = count + 1;
            }
            else{
            count2++;
            }
        }
        return list;
    }
    public void printNumbers(){
        li = affs.listIterator();
        while (li.hasNext()){
            System.out.println(li.next());
        }
    }
}

Answer 5

You could use the default comparator using Collections#sort provided that you use numbers of the form 01 and 02 and not 1 and 2 .

Otherwise you can create your own comparator, but I think @camickr suggestion to use a different representation is better.

Answer 6

How dependent are you upon that ArrayList? I'm not so sure of your whole application, but the the "number - string" format of your ArrayList entries suggests to me that you actually need a Map here. Implement this as a TreeMap and you get the sorting of the keys for free.

public static void main( String[] args ) {
    Map<Integer , String> map = new TreeMap<Integer , String>();
    map.put( 1, "name1" );
    map.put( 1000, "name2" );
    map.put( 1004, "name4" );
    map.put( 1002, "name3" );
    map.put( 10000, "name5" );
    map.put( 2000, "name5" );

    for ( Integer key : map.keySet() ) {
        System.out.println( String.format( "key: %d, value: %s", key, map.get( key ) ) );
    }
}

...produces...

key: 1, value: name1
key: 1000, value: name2
key: 1002, value: name3
key: 1004, value: name4
key: 2000, value: name5
key: 10000, value: name5