Um das erste größte und zweitgrößte Element in einer Zeichenfolge zu drucken

Question

Unten ist der Code, den ich implementiert habe. Meine Zweifel hier ist: Wenn ich versuche, die ersten größten und zweiten größten Werte in der Zeichenfolge zu drucken, ist die Ausgabe, die ich bekomme, in der Reihenfolge [second biggest, first biggest]. Hier ist die Ausgabe von dem, was ich habe für den folgenden Code:

The output of the map is: real--6 
The output of the map is: to--2 
The output of the map is: world--1 
The output of the map is: hello--0 
The list after insertion is: [to, real] 
The list inserted as [biggest,secondBiggest] after calling main is: [to, real] 
...... 

aber ich The list after insertion to be: [real, to] wollen.

public class ReadString { 
    static String input = "This is a real project with real code to do real things to solve real problems in real world real"; 

    public static void main(String[] args) { 
     List<String> lst = ReadString.RepeatedString("This is a real project with real " 
       + "code to do real things to solve real " + "problems in real world real"); 
     System.out.println("The list inserted as [biggest,secondBiggest] after calling main is: " + lst); 
    } 

    public static List<String> RepeatedString(String s) { 

     String[] s2 = input.split(" "); 
     String[] key = { "real", "to", "world", "hello" }; 
     int count = 0; 
     Integer biggest = 0; 
     Integer secondBiggest = 1; 
     Map<String, Integer> map = new HashMap<String, Integer>(); 
     for (int j = 0; j < key.length; j++) { 
      count = 0; 
      for (int i = 0; i < s2.length; i++) { 
       if (s2[i].equals(key[j])) { 
        count++; 
       } 
      } 
      map.put(key[j], count); 
      System.out.println("The output of the map is: " +key[j] + "--" + count); 

     } 

     /* 
     * To find the top two most repeated values. 
     */ 
     List<Integer> values = new ArrayList<Integer>(map.values()); 
     Collections.sort(values); 
     for (int n : map.values()) { 
      if (biggest < n) { 
       secondBiggest = biggest; 
       biggest = n; 
      } else if (secondBiggest < n) 
       secondBiggest = n; 
     } 
     /* To get the top most repeated strings. */ 

     List<String> list = new ArrayList<String>(); 
     for (String s1 : map.keySet()) { 
      if (map.get(s1).equals(biggest)) 
       list.add(s1); 
      else if (map.get(s1).equals(secondBiggest)) 
       list.add(s1); 
     } 
     System.out.println("The list after insertion is: " +list); 
     return list; 
    } 
} 

Answer 1

Das Problem scheint zu sein, wenn Sie Elemente zur Liste hinzufügen. Während Sie die map.keySet() -Methode durchlaufen, gibt es keine Garantie, dass Sie zuerst das größte Element erhalten. Die kleinste Änderung, die ich vornehmen würde, würde darin bestehen, das größte Element zuerst in der Liste hinzuzufügen.

for (String s1 : map.keySet()) { 
     if (map.get(s1).equals(biggest)) 
      list.add(0, s1); 
     else if (map.get(s1).equals(secondBiggest)) 
      list.add(s1); 
    }

Auf diese Weise, wenn SecondBiggest zuerst hinzugefügt wird, wird der größte am Anfang der Liste sein.

Answer 2

Wir können Ihren Ansatz ein wenig vereinfachen, wenn wir die word und count in ein einfaches POJO extrahieren. Etwas wie,

Dann können wir das in repeatedString verwenden. Zählen Sie zuerst die Wörter in der String; Dann baue einen List von WordCount (s). Sortieren Sie es (da es Comparable ist, hat es natürliche Ordnung). Erstellen Sie dann die List, um durch wiederholte Iteration der sortierten ListWordCount (s) zurückzukehren (für zwei Elemente). Wie,

static List<String> repeatedString(String s) { 
    Map<String, Integer> map = new HashMap<>(); 
    for (String word : s.split("\\s+")) { 
     map.put(word, !map.containsKey(word) ? 1 : 1 + map.get(word)); 
    } 
    List<WordCount> al = new ArrayList<>(); 
    for (Map.Entry<String, Integer> entry : map.entrySet()) { 
     al.add(new WordCount(entry.getKey(), entry.getValue())); 
    } 
    Collections.sort(al); 
    List<String> ret = new ArrayList<>(); 
    for (int i = al.size() - 1; i >= al.size() - 2; i--) { 
     ret.add(al.get(i).word); 
    } 
    return ret; 
} 

Schließlich sollte Ihre main Methode, um Ihre Verwendung static input (oder static input entfernt werden sollte)

static String input = "This is a real project with real code to do " 
     + "real things to solve real problems in real world real"; 
public static void main(String[] args) { 
    List<String> lst = repeatedString(input); 
    System.out.println("The list inserted as [biggest," 
      + "secondBiggest] after calling main is: " + lst); 
} 

Und ich (wie gewünscht)

The list inserted as [biggest,secondBiggest] after calling main is: [real, to] 

Answer 3

Wenn Sie nur besorgt über größte und zweitgrößte, Sie können den Code unten beziehen.
Anstatt die Liste direkt zu erstellen, habe ich ein Array erstellt und erforderliche Elemente an bestimmten Positionen hinzugefügt. (So ​​wird es besser lesbar)
und schließlich das Array in eine Liste konvertieren.

 /* To get the top most repeated strings. */ 
     String[] resultArray = new String[2]; 
     for (String s1 : map.keySet()) { 
      if (map.get(s1).equals(biggest)) 
      resultArray[0]=s1; 
      else if (map.get(s1).equals(secondBiggest)) 
      resultArray[1]=s1; 
     } 
     List<String> list = Arrays.asList(resultArray);