Java 按长度对字符串的ArrayList排序

我想按长度对字符串的ArrayList进行排序，但不仅仅是按数字顺序

例如，该列表包含以下单词：

cucumber
aeronomical
bacon
tea
telescopic
fantasmagorical

它们需要按长度差排序为特殊字符串，例如：

intelligent

因此，最终列表如下所示（括号中的差异）：

---

使用自定义比较器：

public class MyComparator implements java.util.Comparator<String> {

    private int referenceLength;

    public MyComparator(String reference) {
        super();
        this.referenceLength = reference.length();
    }

    public int compare(String s1, String s2) {
        int dist1 = Math.abs(s1.length() - referenceLength);
        int dist2 = Math.abs(s2.length() - referenceLength);

        return dist1 - dist2;
    }
}

公共类MyComparator实现java.util.Comparator{
私有整数参考长度；
公共MyCompariator（字符串引用）{
超级（）；
this.referenceLength=reference.length（）；
}
公共整数比较（字符串s1、字符串s2）{
int dist1=Math.abs（s1.length（）-referenceLength）；
int dist2=Math.abs（s2.length（）-referenceLength）；
返回dist1-dist2；
}
}

---

然后使用

java.util.Collections.sort（list，Comparator）

对列表进行排序。您可以使用具有显式

按升序排列的字符串

类StringLengthListSort实现了Comparator{
@凌驾
公共整数比较（字符串s1、字符串s2）{
返回s1.length（）-s2.length（）；
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
StringLengthListSort ss=新StringLengthListSort（）；
列表。添加（“ram”）；
列表。添加（“rahim”）；
列表。添加（“ramshyam”）；
集合。排序（列表，ss）；
系统输出打印项次（列表）；
}
}

如果您使用的是Java 8+，那么可以使用lambda表达式来实现（@Barend's answer as）比较器

List<String> strings = Arrays.asList(new String[] {"cucumber","aeronomical","bacon","tea","telescopic","fantasmagorical"});
strings.sort((s1, s2) -> Math.abs(s1.length() - "intelligent".length()) - Math.abs(s2.length() - "intelligent".length()));

List strings=Arrays.asList（新字符串[]{“cumber”、“aeronomic”、“bacon”、“tea”、“伸缩”、“fantasmagorical”}）；
strings.sort（（s1，s2）->Math.abs（s1.length（）-“intelligent.length（））-Math.abs（s2.length（）-“intelligent.length（））；

使用自定义比较器是正确的。这是实现它的一种方法：

    Comparator c = new Comparator<String>()
    {
        public int compare(String s1, String s2) {
            return Integer.compare(s1.length(), s2.length());
        }
    };
    Collections.sort(results, c);
    return results;

比较器c=新比较器（） { 公共整数比较（字符串s1、字符串s2）{ 返回整数.compare（s1.length（），s2.length（））； } }; 集合。排序（结果，c）； 返回结果；

---

如果您使用的是java 8，也可以尝试使用此lambda

packages.sort(Comparator.comparingInt(String::length));

---

仅带比较器和方法参考的简单Java8解决方案：

---

Stream.of（list）.flatMap（Collection:：Stream）.sorted（Comparator.comparing（String:：length））.collect（toList（））

我用lambda表达式解决了一个类似的问题：

listBeforeSorting.sort((s1, s2) -> s1.length() - s2.length());

这样，我们将按长度（升序）列表进行排序。

list list list=Arrays.asList（“geeksforgeks”、“geeksfor”、“geeks”）；
Collections.sort（list，newcomparator（）{
公共整数比较（字符串s1、字符串s2）{
返回s1.length（）-s2.length（）；
}
});

如果您使用的是Kotlin，则可以使用此代码

    var A = ArrayList<String>()
    A.add("Alen")
    A.add("Nymar")
    A.add("Ronaldo")
    A.add("Totianas")
    A.add("Ted")
    A.add("Sara")

    Collections.sort(A, object : Comparator<String?> {
        override fun compare(p0: String?, p1: String?): Int {
            return (p1!!.length - p0!!.length)
        }
    })

    System.out.println(A)

var A=ArrayList（）
A.添加（“阿伦”）
A.添加（“纽约商品交易所”）
A.加上（“罗纳尔多”）
A.添加（“托蒂亚纳斯”）
A.添加（“Ted”）
A.添加（“Sara”）
排序（A，对象：Comparator）{
覆盖有趣的比较（p0:String？，p1:String？）：Int{
返回值（p1！！.length-p0！！.length）
}
})
系统输出打印LN（A）

正差异的优先级可以通过将正差异乘以2，负差异乘以负2，然后再加上1来确定。您应该将referenceLength设置为final。Java 8+的最佳解决方案。简短而精确。如果您只想按长度排序：

strings.sort（（s1，s2）->s1.length（）-s2.length（））如仅链接回答中所述，这可以通过，这需要一个明确的
The shortest code for this-

public static void main(String... str) {
        List.of("am", "I", "Best", "the").stream().sorted((a, b) -> a.length() - b.length())
                .forEach(System.out::println);
    }

List<String> list = Arrays.asList("geeksforgeeks", "geeksfor", "geeks");
Collections.sort(list, new Comparator<String>(){
       public int compare(String s1, String s2){
                return s1.length() - s2.length();
       }
});

Collections.sort(list, (a, b)->Integer.compare(a.length(), b.length()));

    var A = ArrayList<String>()
    A.add("Alen")
    A.add("Nymar")
    A.add("Ronaldo")
    A.add("Totianas")
    A.add("Ted")
    A.add("Sara")

    Collections.sort(A, object : Comparator<String?> {
        override fun compare(p0: String?, p1: String?): Int {
            return (p1!!.length - p0!!.length)
        }
    })

    System.out.println(A)