java中的字符串排序

我有一个

列表

，其中的对象值是

字符串

。这些字符串看起来像“这是1”，“这是10”，“这是2”，“这是11”
我的问题是如何使用番石榴将它们按顺序1、2、10、11进行排序

List<Bean> orderedList = new ArrayList<>();
    Function<Bean, String> getNameFunction = new Function<Bean, String>() {
        @Override
        public String apply(Bean from) {
            return from.getShape();
        }
    };
    Ordering<Bean> nameOrdering = Ordering.natural().onResultOf(getNameFunction);
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(
            nameOrdering).addAll(lb).build();
    orderedList.addAll(sortedShapes);
    return orderedList;

List orderedList=new ArrayList（）；
函数getNameFunction=新函数（）{
@凌驾
公共字符串apply（Bean来自）{
从.getShape（）返回；
}
};
Ordering nameOrdering=Ordering.natural（）.onResultOf（getNameFunction）；
ImmutableSortedSet-sortedShapes=ImmutableSortedSet.orderedBy(
nameOrdering.addAll（lb.build（）；
orderedList.addAll（分拣形状）；
返回订单列表；

这不是我想要的那样，它将它们按1、10、11、2排序
你能帮帮我吗？

---

谢谢大家!

Java中

字符串

s的自然顺序是字典式的。您需要创建或找到一个符合您需要的

比较器

实现。如果你自己写的话，你可以只做一个

Ordering

的子类。然后你可以做：

Ordering<Bean> nameOrdering = myStringOrdering.onResultOf(getNameFunction);

排序名称排序=myStringOrdering.onResultOf（getNameFunction）；

---

Java中
字符串
s的自然顺序是字典式的。您需要创建或找到一个符合您需要的
比较器
实现。如果你自己写的话，你可以只做一个
Ordering
的子类。然后你可以做：

Ordering<Bean> nameOrdering = myStringOrdering.onResultOf(getNameFunction);

排序名称排序=myStringOrdering.onResultOf（getNameFunction）；
Java中
字符串
s的自然顺序是字典式的。您需要创建或找到一个符合您需要的
比较器
实现。如果你自己写的话，你可以只做一个
Ordering
的子类。然后你可以做：

Ordering<Bean> nameOrdering = myStringOrdering.onResultOf(getNameFunction);

排序名称排序=myStringOrdering.onResultOf（getNameFunction）；
Java中
字符串
s的自然顺序是字典式的。您需要创建或找到一个符合您需要的
比较器
实现。如果你自己写的话，你可以只做一个
Ordering
的子类。然后你可以做：

Ordering<Bean> nameOrdering = myStringOrdering.onResultOf(getNameFunction);

排序名称排序=myStringOrdering.onResultOf（getNameFunction）；
Java
字符串的默认（自然）顺序是，这意味着
字符串
按其组成字母的字母顺序排列（逐字符比较）。从
String.compareTo
文档：

[…]如果它们（字符串）在一个或多个索引位置具有不同的字符，
设k为此类指数的最小值；然后，其字符位于位置k的字符串具有

较小的值，通过使用<运算符按字典顺序确定
在另一个字符串之前

正如ColinD所建议的，您将需要一个
比较器的实现，该比较器支持
字符串的字母数字排序。以下是一个例子：

    List<Bean> lb = new ArrayList<Bean>() {{
            add(new Bean("This is 1"));
            add(new Bean("This is 10"));
            add(new Bean("This is 11"));
            add(new Bean("This is 2"));
        }};
    final AlphaNumericComparator comparator= new AlphaNumericComparator();
    Ordering<Bean> nameOrdering = new Ordering<Bean>() {
        @Override public int compare(Bean left, Bean right) {
            return comparator.compare(left.getShape(),right.getShape());
        }
    };
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(nameOrdering).addAll(lb).build();
    List<Bean> orderedList = new ArrayList<>();
    orderedList.addAll(sortedShapes);
    System.out.println("orderedList:" + orderedList);

Java
字符串
的默认（自然）顺序为，这意味着
字符串
按其组成字母的字母顺序排列（逐字符比较）。从
String.compareTo
文档：

[…]如果它们（字符串）在一个或多个索引位置具有不同的字符，
设k为此类指数的最小值；然后，其字符位于位置k的字符串具有

较小的值，通过使用<运算符按字典顺序确定
在另一个字符串之前

正如ColinD所建议的，您将需要一个
比较器的实现，该比较器支持
字符串的字母数字排序。以下是一个例子：

    List<Bean> lb = new ArrayList<Bean>() {{
            add(new Bean("This is 1"));
            add(new Bean("This is 10"));
            add(new Bean("This is 11"));
            add(new Bean("This is 2"));
        }};
    final AlphaNumericComparator comparator= new AlphaNumericComparator();
    Ordering<Bean> nameOrdering = new Ordering<Bean>() {
        @Override public int compare(Bean left, Bean right) {
            return comparator.compare(left.getShape(),right.getShape());
        }
    };
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(nameOrdering).addAll(lb).build();
    List<Bean> orderedList = new ArrayList<>();
    orderedList.addAll(sortedShapes);
    System.out.println("orderedList:" + orderedList);

Java
字符串
的默认（自然）顺序为，这意味着
字符串
按其组成字母的字母顺序排列（逐字符比较）。从
String.compareTo
文档：

[…]如果它们（字符串）在一个或多个索引位置具有不同的字符，
设k为此类指数的最小值；然后，其字符位于位置k的字符串具有

较小的值，通过使用<运算符按字典顺序确定
在另一个字符串之前

正如ColinD所建议的，您将需要一个
比较器的实现，该比较器支持
字符串的字母数字排序。以下是一个例子：

    List<Bean> lb = new ArrayList<Bean>() {{
            add(new Bean("This is 1"));
            add(new Bean("This is 10"));
            add(new Bean("This is 11"));
            add(new Bean("This is 2"));
        }};
    final AlphaNumericComparator comparator= new AlphaNumericComparator();
    Ordering<Bean> nameOrdering = new Ordering<Bean>() {
        @Override public int compare(Bean left, Bean right) {
            return comparator.compare(left.getShape(),right.getShape());
        }
    };
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(nameOrdering).addAll(lb).build();
    List<Bean> orderedList = new ArrayList<>();
    orderedList.addAll(sortedShapes);
    System.out.println("orderedList:" + orderedList);

Java
字符串
的默认（自然）顺序为，这意味着
字符串
按其组成字母的字母顺序排列（逐字符比较）。从
String.compareTo
文档：

[…]如果它们（字符串）在一个或多个索引位置具有不同的字符，
设k为此类指数的最小值；然后，其字符位于位置k的字符串具有

较小的值，通过使用<运算符按字典顺序确定
在另一个字符串之前

正如ColinD所建议的，您将需要一个
比较器的实现，该比较器支持
字符串的字母数字排序。以下是一个例子：

    List<Bean> lb = new ArrayList<Bean>() {{
            add(new Bean("This is 1"));
            add(new Bean("This is 10"));
            add(new Bean("This is 11"));
            add(new Bean("This is 2"));
        }};
    final AlphaNumericComparator comparator= new AlphaNumericComparator();
    Ordering<Bean> nameOrdering = new Ordering<Bean>() {
        @Override public int compare(Bean left, Bean right) {
            return comparator.compare(left.getShape(),right.getShape());
        }
    };
    ImmutableSortedSet<Bean> sortedShapes = ImmutableSortedSet.orderedBy(nameOrdering).addAll(lb).build();
    List<Bean> orderedList = new ArrayList<>();
    orderedList.addAll(sortedShapes);
    System.out.println("orderedList:" + orderedList);

我对番石榴了解不多，但请仔细阅读编写自己的
Comparator
实现。这是实现这一点的标准方法，因此排序将按照您期望的方式进行。您不是在尝试对字符串而不是数字进行排序吗？我认为顺序1、10、11、2似乎是正确的。您正在订购字符串。我不认为您是否使用番石榴对您的实际问题有任何影响。我对番石榴了解不多，但请阅读编写您自己的
Comparator
实现。这是实现这一点的标准方法，因此排序将按照您期望的方式进行。您不是在尝试对字符串而不是数字进行排序吗？我认为顺序1、10、11、2似乎是正确的。你在点字符串。我不认为你是否使用番石榴对你的实际问题有任何影响。我对Gu了解不多