Question

我正在尝试解决一个应该向我学习Comparable<T>接口的驱动器。它告诉我在字符串数组中找到最短和最长的字符串。

我认为我应该制作自己的compareTo()方法，因为String.compareTo()方法按字母顺序排序。但我无法得到我的方法应该是什么样的。

到目前为止，这是我的代码：

class ComparableTest implements Comparable<String> {

    public static void main(String[] args) {
        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};
        String tempSto = arr[0]; //long string
        String tempLit = arr[0]; //short string
        for(String e : arr) {
            if(e.compareTo(tempSto) > 0) {
                tempSto = e;
            }
            if(e.compareTo(tempLit) < 0) {
                tempLit = e;
            }
        }
        System.out.println("Longest string is: " + tempSto);
        System.out.println("Shortest string is: " + tempLit);
    }
}

Answer 1

正如您所提到的，您应该根据字符串的长度而不是字母内容来实现自己的Comparator。 E.g：

public class StringLengthComaprator extends Comaprator<String> {
    @Override
    public int compare (String s1, String s2) {
        return Integer.compare(s1.length(), s2.length();
    }
}

完成后，您可以使用它来查找数组中最短的字符串，或者只是重复使用Collections#min(Collection, Comparator)来为您做繁重的工作：

String shortest = 
    Collections.min(Arrays.asList(arr), new StringLengthComaprator());

Answer 2

如果你的类实现了Comparable接口，我猜你必须覆盖compareTo方法，并比较两个String的长度。

Answer 3

您可以根据自己的需要使用类似的排序列表。在您的情况下，这意味着字符串中的最高和最低字符数与比较相关。因此，您在比较函数中相互减去这些值。如果您有house和dog，则您有两个值5和3.通过相互减去这些值，您可以看出这些值的接近程度。因此，只需返回订购函数中两个参数长度的差异。然后，列表中的第一个和最后一个元素将是最大和最小的单词（取决于您从中减去哪个值）。

Answer 4

在Java 8中：

import java.util.Arrays;

public class Example {

    public static void main(String[] args) {

        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        String minLengthStr = Arrays.stream(arr)
                                    .min((str1, str2) -> Integer.compare(str1.length(), str2.length()))
                                    .get();

        String maxLengthStr = Arrays.stream(arr)
                                    .max((str1, str2) -> Integer.compare(str1.length(), str2.length()))
                                    .get();

        System.out.println("Longest string is: " + maxLengthStr);
        System.out.println("Shortest string is: " + minLengthStr);
    }
}

输出：

Longest string is: hvordan
Shortest string is: a

说明：

Stream类中的min方法将Comparator作为参数。由于Comparator是一个功能接口，我们可以使用lambda表达式作为实现它的简写。

所以不要写：

Comparator<String> lengthComparator = new Comparator<String>() {
    @Override
    public int compare(String str1, String str2) {
        return Integer.compare(str1.length(), str2.length());
    }
};

你可以写：

Comparator<String> lengthComparator = (str1, str2) -> Integer.compare(str1.length(), str2.length());

你也可以在没有溪流的情况下使用它：

public class Example {

    public static void main(String[] args) {

        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        String minLengthStr = arr[0], maxLengthStr = arr[0];

        Comparator<String> lengthComparator = (str1, str2) -> Integer.compare(str1.length(), str2.length());

        for(String str : arr) {
            if(lengthComparator.compare(str, minLengthStr) == -1) {
                minLengthStr = str;
            } else if(lengthComparator.compare(str, maxLengthStr) == 1) {
                maxLengthStr = str;
            }
        }

        System.out.println("Longest string is: " + maxLengthStr);
        System.out.println("Shortest string is: " + minLengthStr);
    }
}

Answer 5

我希望，这会有所帮助

public class Test implements Comparator<String>{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        Set<String> set = new TreeSet<String>(new Test());
        set.add("hei");
        set.add("hvordan");
        set.add("gaar");
        set.add("med");
        set.add("deg");
        set.add("a");

        System.out.println(set);
    }

    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        if(o1.length()>o2.length())
            return 1;
        else if(o1.length()<o2.length())
            return -1;
        else
            return 0;

    }

Answer 6

如果您想使用String，Comparable和compareTo这是一个例子。

ideone.com

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

public class Test {
    String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

    /**
     * Use composition.
     */
    class MyComparableString implements Comparable<MyComparableString> {
        String myString;

        MyComparableString(String s) {
            myString = s;
        }

        @Override
        public int compareTo(MyComparableString other) {
            // Compare the lengths of the strings in this and other.
            Integer l1 = myString.length();
            Integer l2 = other.myString.length();
            return l1.compareTo(l2);
        }

        // String representation.
        public String toString() {
            return myString;
        }
    }

    void go() {
        // Convert the String array into a List (Collection) of MyComparableString.
        List<MyComparableString> l = new ArrayList<>();
        for (String s: arr) {
            l.add(new MyComparableString(s));
        }
        // Print longest and shortest.
        System.out.println("Shortest: " + Collections.min(l));
        System.out.println("Longest: " + Collections.max(l));
    }

    public static void main(String[] args) {
        new Test().go();
    }
}

CompareTo（）用于查找数组中最短/最长的字符串

6 个答案: