CompareTo() для поиска кратчайшей/длинной строки в массиве

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, основываясь на длину строки, а не его алфавитных содержание. Например:

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 и сравнить длину двух строк.

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 

Пояснение:

Минимальный метод в классе потока принимает компаратор в качестве параметра. Поскольку Comparator является функциональным интерфейсом, мы можем использовать выражение лямбда в качестве короткой руки для его реализации.

Таким образом, вместо того, чтобы писать:

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