Split und Loop in Java 8

Question

Ich habe dieses Problem, das ich 8 in Java lösen will,

Ich habe eine Zeichenfolge, die von .

A.B.C.D 

Anzahl der Zeichen in der Zeichenkette verkettet wird, kann variieren .

Ich habe diese Methode, die die Zeichenfolge als Eingabe und Anzahl der Ebene dauert tief, es muss gehen, Ich muss durchlaufen die Nummer, die ich nach dem Anwenden einer Teilung auf Zeichenfolge mit "." und gehen Sie gerade gegeben Ebene tief

private String getResponse (String str, int level) { 
// for now, simply print the entire string first and then start removing last alphabet of it one by one till the value of level 
// ex : str = A.B.C.D 
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C.D 
// Apply logic of split 
// System.out.println("Doing a call with key as = " + str); => should give me A.B.C 
// Split again 
// System.out.println("Doing a call with key as = " + str); => should give me A.B 
// this should go in loop till we reach the level 
} 

Kann dies in Java 8 getan werden?

Answer 1

Hier ist Java-8-Lösung:

static void getResponse(String input, int level) { 
    Stream.iterate(input, str -> { 
     int pos = str.lastIndexOf('.'); 
     return pos == -1 ? "" : str.substring(0, pos); 
    }).limit(level+1).forEach(System.out::println); 
} 

Wenn Sie sicher sind, dass level überschreitet nicht die Anzahl von d OTS, können Sie die Prüfung auslassen:

static void getResponseUnsafe(String input, int level) { 
    Stream.iterate(input, str -> str.substring(0, str.lastIndexOf('.'))) 
      .limit(level + 1).forEach(System.out::println); 
} 

Answer 2

Hinweis: Lösung nicht mit Java 8

public class StringLoop { 

    public static void main(String[] args) { 

     getResponse("A.B.C.D", 2); 

     System.out.println(); 
     getResponse("A.B.C.D", 3); 

    } 

    // Recursive function 
    private static void getResponse (String str, int level) { 

     if(level < 0 || str.equals("")) 
      return; 

     // Prints out the current string 
     System.out.println(str); 

     int lastIndex = str.lastIndexOf("."); 
     if(lastIndex == - 1) 
      lastIndex = 0; 

     // Remove content after last connector 
     // Decrement level 
     getResponse(str.substring(0, lastIndex), level - 1); 
    } 
} 

Ausgang:

A.B.C.D 
A.B.C 
A.B 

A.B.C.D 
A.B.C 
A.B 
A 

Answer 3

Ihre Kommentare erwähnen split() verwenden, also hier ist ein Beispiel für split() verwenden, Arrays.copyOfRange() (um die letzten Buchstaben zu entfernen) und String.Join() das Ergebnis Arrays.copyOfRange() wieder zusammen für das setzen nächster rekursiver Aufruf.

public static void main(String[] args) { 
    String string = "A.B.C.D"; 
    getResponse(string, 3); 
    System.out.println(); 

    getResponse(string, 2); 
    System.out.println(); 

    getResponse(string, 1); 
    System.out.println(); 
} 

private static void getResponse(String str, int level) { 
    if (level < 0 || str.isEmpty()) 
     return; 

    System.out.println(str); 

    String[] strPieces = str.split("\\."); 
    if (strPieces.length > level) { 
     getResponse(String.join(".", Arrays.copyOfRange(strPieces, 0, strPieces.length - 1)), level - 1); 
    } 
} 

Ergebnisse:

A.B.C.D 
A.B.C 
A.B 
A 

A.B.C.D 
A.B.C 
A.B 

A.B.C.D 
A.B.C 

Answer 4

Kein Looping ist erforderlich, kann da String in ein Array in einem einzigen String.split Aufruf aufgeteilt werden. (Beachten Sie, dass String.split eine Regex verwendet.) Um die "Ebene" zu behandeln, subtrahieren Sie sie einfach von der Länge des Splitter-Arrays. Anstatt das Array subrange zu kopieren, konvertieren sie in eine Liste und Verwendung subList():

String getResponse(String str, int level) { 
    String[] splits = str.split("\\."); 
    if (level < 0 || level > splits.length) { 
     throw new IllegalArgumentException(); 
    } 
    return String.join(".", Arrays.asList(splits).subList(0, splits.length - level)); 
} 

Die Ausgabe von

for (int level = 0; level < 5; level++) { 
     System.out.printf("level %d: %s%n", level, getResponse("A.B.C.D", level)); 
    } 

level 0: A.B.C.D 
level 1: A.B.C 
level 2: A.B 
level 3: A 
level 4: 

Hinweis sein, dass diese Java benötigt 8, weil es String.join() erfordert. (Aber es erfordert keine Streams oder sogar lambdas!)

Answer 5

Wenn Sie nur an dem Ergebnis String interessiert sind, gibt es keine Notwendigkeit, Zwischenprodukt String s noch in mehrere Teile zu spalten, nur um sie anschließend zusammen zu heften.iterieren nur über den Matching-Index innerhalb der String und schaffen ein Ergebnis String:

static String getResponse(String str, int level) { 
    for(int index=str.length(); index>0; index=str.lastIndexOf('.', index-1)) 
     if(level-- == 0) return str.substring(0, index); 
    if(level==0) return ""; 
    throw new IllegalArgumentException(str+" has not enough dots"); 
} 

Diese verwendet kein Java 8 Feature, aber es ist auch schwer vorstellbar, wie Java 8 Merkmale diese einfache Bedienung verbessern können ...