Java 什么'；收集有什么问题吗？_Java_Arrays_Sorting_Collections_Arraylist

Java 什么'；收集有什么问题吗？

java arrays sorting collections

Java 什么'；收集有什么问题吗？,java,arrays,sorting,collections,arraylist,Java,Arrays,Sorting,Collections,Arraylist,我在字符串的ArrayList中有这些字符串，没有特定的顺序，但是当我调用Collections.sort（listReference）时，排序的结果是不正确的，为什么10和11（最后2个字符）出现在07、08和09之前 12880 20090506054200001 12880 20090506054200002 12880 20090513070200003 12880 20090513070200004 12880 20090520202600005 12880 2009052

我在字符串的ArrayList中有这些字符串，没有特定的顺序，但是当我调用Collections.sort（listReference）时，排序的结果是不正确的，为什么10和11（最后2个字符）出现在07、08和09之前

12880  20090506054200001
12880  20090506054200002
12880  20090513070200003
12880  20090513070200004
12880  20090520202600005
12880  20090520202600006
12880  20090520232900010
12880  20090520232900011
12880  20090520232900007
12880  20090520232900008
12880  20090520232900009

这对我来说很好：

import java.util.*;

public class Test {

      public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("12880  20090506054200001");
        list.add("12880  20090506054200002");
        list.add("12880  20090513070200003");
        list.add("12880  20090513070200004");
        list.add("12880  20090520202600005");
        list.add("12880  20090520202600006");
        list.add("12880  20090520232900010");
        list.add("12880  20090520232900011");
        list.add("12880  20090520232900007");
        list.add("12880  20090520232900008");
        list.add("12880  20090520232900009");

        Collections.sort(list);

        for (String x : list) {
          System.out.println(x);
        }
      }
    }

您是否绝对确定您的7/8/9条目在其他地方没有“奇怪”的内容（例如12880和时间戳之间的不同空格元素）

如果没有，您能否制作一个简短但完整的程序来演示问题？

对我来说效果很好：

import java.util.*;

public class Test {

      public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("12880  20090506054200001");
        list.add("12880  20090506054200002");
        list.add("12880  20090513070200003");
        list.add("12880  20090513070200004");
        list.add("12880  20090520202600005");
        list.add("12880  20090520202600006");
        list.add("12880  20090520232900010");
        list.add("12880  20090520232900011");
        list.add("12880  20090520232900007");
        list.add("12880  20090520232900008");
        list.add("12880  20090520232900009");

        Collections.sort(list);

        for (String x : list) {
          System.out.println(x);
        }
      }
    }

您是否绝对确定您的7/8/9条目在其他地方没有“奇怪”的内容（例如12880和时间戳之间的不同空格元素）

如果没有，您能否生成一个简短但完整的程序来演示问题？

以10和11结尾的两个程序可能有制表符，而不是空格。制表符排序在空格之前

更新：我真的试过了，标签排在最前面，这很有道理。因此，制表符理论实际上并不能解释观察到的行为。

以10和11结尾的两个可能有制表符，而不是空格。制表符排序在空格之前

更新：我真的试过了，标签排在最前面，这很有道理。因此，标签理论实际上并不能解释观察到的行为。

好的，让我们从基本前提开始，即

Collections.sort

有效（请参阅）

您的字符串不应该按这种方式排序，到目前为止，有几个人已经确认它们不应该按这种方式排序。那么，是什么原因导致您的排序像这样呢

您是否将自定义的

比较器传递给排序（）


琴弦真的和你表演的一模一样吗？空格字符都是空格吗


您能发布生成此结果的确切代码吗？
好的，让我们从基本前提开始，即Collections.sort
有效（请参阅）
您的字符串不应该按这种方式排序，到目前为止，有几个人已经确认它们不应该按这种方式排序。那么，是什么原因导致您的排序像这样呢

您是否将自定义的比较器传递给排序（）

琴弦真的和你表演的一模一样吗？空格字符都是空格吗

您可以发布产生此结果的确切代码吗？
适用于此单元测试
import static org.junit.Assert.*;

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

import org.junit.Test;

public class SortTest {

    List<String> expectedList = Arrays.asList(
            "12880  20090506054200001",
            "12880  20090506054200002",
            "12880  20090513070200003",
            "12880  20090513070200004",
            "12880  20090520202600005",
            "12880  20090520202600006",
            "12880  20090520232900007",
            "12880  20090520232900008",
            "12880  20090520232900009",
            "12880  20090520232900010",
            "12880  20090520232900011");

    @Test
    public void testSort() {
        List<String> stringList = new ArrayList(expectedList);
        Collections.shuffle(stringList);
        // comment following line out, for the rare case that shuffle returns the original list
        // assertFalse(stringList.equals(expectedList));
        Collections.sort(stringList);
        assertTrue(stringList.equals(expectedList));        
    }
}

import static org.junit.Assert.*；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
导入org.junit.Test；
公共类分类测试{
List expectedList=Arrays.asList(
"12880  20090506054200001",
"12880  20090506054200002",
"12880  20090513070200003",
"12880  20090513070200004",
"12880  20090520202600005",
"12880  20090520202600006",
"12880  20090520232900007",
"12880  20090520232900008",
"12880  20090520232900009",
"12880  20090520232900010",
"12880  20090520232900011");
@试验
公共void testSort（）{
List stringList=新的ArrayList（expectedList）；
集合。洗牌（stringList）；
//注释在第行之后，对于shuffle返回原始列表的罕见情况
//assertFalse（stringList.equals（expectedList））；
Collections.sort（stringList）；
assertTrue（stringList.equals（expectedList））；
}
}
是否适合此单元测试
import static org.junit.Assert.*;

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

import org.junit.Test;

public class SortTest {

    List<String> expectedList = Arrays.asList(
            "12880  20090506054200001",
            "12880  20090506054200002",
            "12880  20090513070200003",
            "12880  20090513070200004",
            "12880  20090520202600005",
            "12880  20090520202600006",
            "12880  20090520232900007",
            "12880  20090520232900008",
            "12880  20090520232900009",
            "12880  20090520232900010",
            "12880  20090520232900011");

    @Test
    public void testSort() {
        List<String> stringList = new ArrayList(expectedList);
        Collections.shuffle(stringList);
        // comment following line out, for the rare case that shuffle returns the original list
        // assertFalse(stringList.equals(expectedList));
        Collections.sort(stringList);
        assertTrue(stringList.equals(expectedList));        
    }
}

import static org.junit.Assert.*；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
导入org.junit.Test；
公共类分类测试{
List expectedList=Arrays.asList(
"12880  20090506054200001",
"12880  20090506054200002",
"12880  20090513070200003",
"12880  20090513070200004",
"12880  20090520202600005",
"12880  20090520202600006",
"12880  20090520232900007",
"12880  20090520232900008",
"12880  20090520232900009",
"12880  20090520232900010",
"12880  20090520232900011");
@试验
公共void testSort（）{
List stringList=新的ArrayList（expectedList）；
集合。洗牌（stringList）；
//注释在第行之后，对于shuffle返回原始列表的罕见情况
//assertFalse（stringList.equals（expectedList））；
Collections.sort（stringList）；
assertTrue（stringList.equals（expectedList））；
}
}
我发现了它为什么会这样
在执行String.format（“%03d”，sequence）
之前，我正在对集合进行排序。其中，序列是上面每行的最后3个字符
总之
在最后一个字符被删除时对字符串进行排序。。。7891（0）1（1）
（完成排序后）将其写入表格007、008、009、010、011
我发现了它为什么会这样
在执行String.format（“%03d”，sequence）
之前，我正在对集合进行排序。其中，序列是上面每行的最后3个字符
总之
在最后一个字符被删除时对字符串进行排序。。。7891（0）1（1）
（完成排序后）将其写入表格007、008、009、010、011
请给我们看更多的代码？在进行比较之前将毫秒舍入到最接近的秒数（可能只是以秒为单位）？请给我们看更多的代码？在进行比较之前将毫秒舍入到最接近的秒数（可能只是以秒为单位）？同意。在这里工作正常，我怀疑同样的问题。等一下，我看看情况是否如此。谢谢，我同意。在这里工作正常，我怀疑同样的问题。等一下，我看看这是否是问题所在