Espressione lambda per invertire una stringa - Java

Question

String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
        "Jupiter", "Saturn", "Uranus", "Neptune" }; 

Ho una semplice matrice di nomi di pianeta e voglio invertire ogni nome che è stato aggiunto alla matrice (non l'ordine di stringa).
mi continuano a lottare con la sintassi lambda:

Arrays.sort(planets, (first, second) -> new StringBuilder(first).reverse().toString()); 
System.out.println(Arrays.toString(planets)); 

Attualmente ottengo:

Multiple markers at this line

• The method reverse() in the type StringBuilder is not applicable for the arguments (String)
• Type mismatch: cannot convert from String to int

Risposta:

Grazie a tutti per i suggerimenti ... asList mi ha stretta. Non ho ancora ordinato correttamente.

Quindi ho bisogno di trovare un modo per far funzionare array.sort perché questo era il compito (prendere array.sort e lambda it).

Ho inviato un ping all'istruttore per chiedere chiarimenti qui, ma sto per scadere.

Ecco il mio lavoro cercando di tenere Array.sort

  // lambda expression , long to short 
     System.out.println("5) Sorted by length (descending):"); 
     Arrays.sort(planets, (first, second) -> second.length() - first.length()); 
     System.out.println(Arrays.toString(planets)); 

     // lambda expression , reverse the name , then sort in ascending order 
     // hint use new StringBuilder(first).reverse().toString() to reverse the string 
     System.out.println("6) Sorted in dictionary order of the reversed name (ascending)"); 
     Arrays.sort(planets, (first, second) -> new StringBuilder(first).reverse().toString().compareTo(second)); 
     System.out.println(Arrays.toString(planets)); 

     // lambda expression , reverse the name , then sort in descending order 
     System.out.println("7) Sorted in dictionary order of the reversed name (descending)"); 
     Arrays.sort(planets, (first, second) -> new StringBuilder(second).reverse().toString().compareTo(first)); 
     System.out.println(Arrays.toString(planets)); 

Quello che non posso per la vita di me a capire è che tutte e 3 le espressioni me ottenere esattamente lo stesso risultato ... ciascuno di questi dà io l'array originale è stato ordinato dal più lungo al più breve.

Questo è il mio risultato:

5) In ordine di lunghezza (decrescente): [Nettuno, Mercurio, Giove, Urano, Saturno, Venere, Terra, Marte]

6) In ordine al fine dizionario del nome invertito (ascendente) [Nettuno, Mercurio, Giove, Urano, Saturno, Venere, Terra, Marte]

7) in ordine al fine dizionario del nome invertito (discendente) [Nettuno, Mercurio, Giove, Urano, Saturno, Venere, Terra, Marte]

Answer 1

Una soluzione alternativa che non utilizza Flusso API e aggiorna le stringhe sul posto:

Arrays.asList(planets).replaceAll(s -> new StringBuilder(s).reverse().toString()); 

Dimostrazione:

String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
     "Jupiter", "Saturn", "Uranus", "Neptune" }; 
Arrays.asList(planets).replaceAll(s -> new StringBuilder(s).reverse().toString()); 
System.out.println(Arrays.toString(planets)); 
// [yrucreM, suneV, htraE, sraM, retipuJ, nrutaS, sunarU, enutpeN] 

Answer 2

Questo lo farà per voi:

public static void main(String[] args) { 
    String[] arr = {"earth", "mars", "mercury"}; 
    List<String> ll = Arrays.stream(arr).map(s -> new StringBuilder(s).reverse().toString()).collect(Collectors.toList()); 
    System.out.println(ll); 
} 

O/P:

[htrae, sram, yrucrem] 

Oppure, se si desidera solo per stampare, utilizzare questo:

String[] arr = {"earth", "mars", "mercury"}; 
Arrays.stream(arr).map(s -> new StringBuilder(s).reverse().toString()).forEach(System.out::println); 

O/P:

htrae 
sram 
yrucrem 

Answer 3

Arrays.sort richiede un comparatore come secondo argomento. Può essere implementato con un'espressione lambda che prende due stringhe come parametri (nel tuo caso) e restituisce un intero (questo è il requisito del SAM definito nell'interfaccia Comparator).

(first, second) -> new StringBuilder(first).reverse().toString() 

è un'espressione lambda che prende due stringhe (il tipo è desumere dal compilatore), ma restituisce una stringa e non un numero intero, quindi l'errore:

java: incompatible types: cannot infer type-variable(s) T 
    (argument mismatch; bad return type in lambda expression 
     java.lang.String cannot be converted to int) 

I have a simple array of planet names and I want to reverse each name that was added to the array

In questo caso si può semplicemente utilizzare Arrays.setAll per modificare l'array in posizione:

Arrays.setAll(planets, i -> new StringBuilder(planets[i]).reverse().toString());