arraylist中的Java排序数

我已经创建了这样一个arraylist

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");

ArrayList entries=new ArrayList（）；
条目。添加（“0-名称1”）；
条目。添加（“1000-名称2”）；
条目。添加（“1004-名称4”）；
条目。添加（“1002-名称3”）；
条目。添加（“10000-名称5”）；
条目。添加（“2000-名称5”）；

列表总是以一个介于0和15000之间的数字开始，所以当我排序时，我希望它只是根据数字进行排序，没有一个数字会匹配，它们应该按照升序进行分类

如何使用java实现这一点我可以使用比较器吗

我能用比较仪吗

是的，你可以：）

语法：

Collections.sort（条目、比较器）-您需要导入java.util.Collections并编写比较器来生成所需的内容。您也可以尝试使用默认比较器对（条目）进行排序（但在这里它不起作用：）

以下是完整的解决方案：

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);
        }

    }
}

import java.util.Comparator；
公共类MyComparator实现了Comparator{
@凌驾
公共整数比较（字符串arg0、字符串arg1）{
int indexOf=arg0.indexOf（“-”）；
String substring=arg0.substring（0，indexOf-1）；
int indexOf1=arg1.indexOf（“-”）；
字符串substring1=arg1.子字符串（0，indexOf1-1）；
返回Integer.valueOf（substring）-Integer.valueOf（substring1）；
}
}
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公开课跑者{
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
列表项=新的ArrayList（）；
条目。添加（“0-名称1”）；
条目。添加（“1000-名称2”）；
条目。添加（“1004-名称4”）；
条目。添加（“1002-名称3”）；
条目。添加（“10000-名称5”）；
条目。添加（“2000-名称5”）；
Comparator Comparator=新的MyComparator（）；
集合。排序（条目、比较项）；
for（字符串e：条目）{
系统输出打印ln（e）；
}
}
}

另外-Istrong建议声明如下列表：
List entries=new ArrayList（）
稍后，您可能会发现使用
LinkedList
代替
ArrayList
的好处-然后更改已用列表的实现将是最简单的

Plz google“程序到接口，而不是实现”。）编写一个
比较器
，将
-
处的输入分开。使用
Integer.parseInt
解析第一个元素（必要时进行修剪）。然后与优化整数值进行比较。

代码：

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

类mycop实现了Comparator{
公共整数比较（字符串s1、字符串s2）{
intv1=Integer.parseInt（s1.split（“-”[0]）；
int v2=Integer.parseInt（s2.split（“-”[0]）；
返回v1-v2；
}

}
是的，可以使用比较器进行比较，但效率不高，因为需要不断解析数据以提取数字，然后需要将数字转换为整数并进行比较

更好的方法是创建一个具有两个属性（编号和名称）的自定义对象。然后你可以按数字排序。这方面的比较将是直截了当的。您可以在论坛中搜索示例。
您可以使用默认的比较器，前提是您使用的数字格式为
01
和
02
，而不是
1
和
2

否则，您可以创建自己的比较器，但我认为@camickr建议使用不同的表示形式更好
 您对ArrayList的依赖程度如何？我不太确定您的整个应用程序，但是ArrayList条目的“数字字符串”格式向我表明您实际上需要一个映射。将其实现为树映射，您可以免费获得键的排序

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 ) ) );
    }
}

也许你想试试我的数字排序算法：

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());
        }
    }
}

package-drawFramePackage；
导入java.awt.geom.AffineTransform；
导入java.util.ArrayList；
导入java.util.ListIterator；
导入java.util.Random；
公共类快速排序算法{
ArrayList affs；
列表迭代器李；
整数计数，count2；
/**
*@param args
*/
公共静态void main（字符串[]args）{
新的QuicksortAlgorithm（）；
}
公共QuicksortAlgorithm（）{
计数=新整数（0）；
count2=新整数（1）；
affs=新的ArrayList（）；
对于（int i=0；i 1&&count！=list.size（）-1）{
if（list.get（count2.getTranslateX（）>list.get（count.getTranslateX（））{
list.add（count，list.get（count2））；
列表。删除（count2+1）；
}
if（count2==list.size（）-1）{
计数++；
count2=count+1；
}
否则{
count2++；
}
}
退货清单；
}
公共数字（）{
li=affs.listIterator（）；
while（li.hasNext（））{
System.out.println（li.next（））；
}
}
}
是的，这是一个更好的选择，但是知道如何编写能够处理以这种方式给出的“数字”的比较器是非常必要的知识：）工作得很好，谢谢你的回答，我是一个快乐的露营者：）哈，我还将使用你的建议学习lot@GFlam很乐意帮忙。无论如何，如果您想学习更多内容，请按照@camickr所说的做，创建您自己的类来保存这些值，在新的比较器中只需使用
entry.getNumber（）
，并将其与
nextEntry.getNumber（）
进行比较。写它会给你带来很多乐趣，还有更多的东西可以使用：）@dantuch，是的，正如你在我的回答中所评论的那样，知道如何编写一个比较器是很重要的。但是，填鸭式的代码如何帮助海报？他们学到了什么？有数百个例子说明了如何在
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());
        }
    }
}