[JAVA] Dubbio su procedimento esercizi

[GrayFin]

Ho svolto questo quesito, ma ho dei dubbi se il procedimento sia giusto. Allego il testo e il codice di svolgimento da me eseguito. Grazie in anticipo

"Lettura di una sequenza di stringhe inserite manualmente dall’utente. Dopo aver digitato tutti
i caratteri che compongono la stringe che si vuole inserire, l’utente dovrà premere invio.
L’utente può inserire una sequenza lunga a piacere ed il programma dovrà continuare a
leggere le stringhe inserite dall’utente; per indicare che la sequenza è terminata, l’utente
premerà invio senza aver inserito alcuna stringa"

Questo l'ho svolto così, sicuro del fatto che inserite manualmente dall'utente voglia significare da tastiera.

import java.util.*;

public class SequenzaStringhe {


    public static void main(String[] args) {
        
        String st;
        
        boolean number = true;
        
        Scanner in = new Scanner(System.in);
        
        while(number){
            System.out.print("Scrivi una stringa: ");
            st=in.next();
            
            //le stringhe da me inserite sono "animale", "parco", "balcone"
        }
            
    }
}

"Memorizzazione della lista di stringhe in una struttura di tipo LinkedList o in un array."

Qui è dove sorgono i miei maggiori dubbi. Non so se posso direttamente memorizzare in un array o farlo in un ArrayList e poi convertirla in array successivamente.

import java.util.*;

public class MemoSequenza {


    public static void main(String[] args) {
        
        ArrayList v = new ArrayList();
        
        v.add("animale");
        v.add("parco");
        v.add("balcone");
        
        System.out.println("Elementi in v: " + v.size());
        for(int i=0; i<v.size(); i++)
            System.out.println("Elemento " + i + ": " + v.get(i));
        
        
        String[] r = (String[]) v.toArray(new String[0]);
        
        System.out.println(r[0] + " " + r[1] + " " + r[2]);
        


    }


}

Terzo punto del quesito: "Ordinamento della lista mediante l’algoritmo BubbleSort."

public class bubble {


    public static void main (String[] args){
        String[] r = {"animale","parco","balcone"};
        System.out.println("Sequenza iniziale: " + r[0] + " " + r[1] + " " + r[2]);
        
        String tm = "";
        for(int i=0; i<r.length; i++){
            
            for(int j=0; j<r.length-1; j++){
                if(r[j].compareTo(r[j+1]) > 0){
                    tm = r[j];
                    r[j] = r[j+1];
                    r[j+1] = tm;
                    
                }
            }
        }
        System.out.println("Sequenza finale: " + r[0] + " " + r[1] + " " + r[2]);
    }
    
}

Infine ultimo punto che però non ricordo completamente, era quello di creare una seconda stringa che avesse gli stessi elementi della prima ma scritti al contrario. Ad esempio se nella prima stringa c'è "casa" nella seconda sarà "asac". Questo l'ho svolto così però vorrei sapere se c'è un metodo più semplice e meno lungo da usare nel caso.

public class SecondaStringa {
    
    public static void main (String[] args){
        String[] r = {"animale", "balcone", "parco"};
        StringBuffer sb;
        StringBuffer sb1;
        StringBuffer sb2;
        char ch;
        
        sb = new StringBuffer(r[0]);
        sb1 = new StringBuffer(r[1]);
        sb2 = new StringBuffer(r[2]);
        for (int i=0; i<sb.length()/2; i++)
        {
        ch = sb.charAt(i);
        sb.setCharAt(i,sb.charAt(sb.length()-i-1));
        sb.setCharAt(sb.length()-i-1,ch);
        }
        for (int i=0; i<sb1.length()/2; i++)
        {
        ch = sb1.charAt(i);
        sb1.setCharAt(i,sb1.charAt(sb1.length()-i-1));
        sb1.setCharAt(sb1.length()-i-1,ch);
        }
        for (int i=0; i<sb2.length()/2; i++)
        {
        ch = sb2.charAt(i);
        sb2.setCharAt(i,sb2.charAt(sb2.length()-i-1));
        sb2.setCharAt(sb2.length()-i-1,ch);
        }
         r[0] = sb.toString();
         r[1] = sb1.toString();
         r[2] = sb2.toString();
        System.out.println(r[0] + " " + r[1] + " " + r[2]);
    }
    
}

[minomic]

Ciao, per quanto riguarda l'inversione di una stringa mi sembra più semplice fare così:

        String stringaDaInvertire = "casa";
        String stringaInvertita = "";
        
        for(int i=stringaDaInvertire.length(); i>0; i--) {
            stringaInvertita += stringaDaInvertire.charAt(i-1);
        }
        
        System.out.println(stringaInvertita);

[LeleFT]

Meglio usare uno StringBuilder, che la concatenazione di stringhe:

String stringaDaInvertire = "blahblahblah";
StringBuilder invertita = new StringBuilder();

for(int i=0; i<stringaDaInvertire.length(); i++) {
   invertita.insert(0, stringaDaInvertire.charAt(i));
}

System.out.println( invertita );

Per quanto riguarda il resto, a parte il fatto che, secondo me, nella seconda consegna intendevano che le stringhe dovevano comunque essere inserite dall'utente e non hard-coded nel sorgente (ma potrei sbagliarmi, non avendo la consegna precisa), l'unica nota negativa è l'uso "very old style" dell'ArrayList (dove "very old style" significa, pre Java 5, ovvero l'uso dei raw-type). Gli ArrayList devono essere tipizzati:

ArrayList<String> v = new ArrayList<String>();

Ciao.

[zipangulu]

Riguardo l'ultimo punto, se arrivi ad usare uno StringBuilder e sempre che ti sia concesso fare ciò che sto per proporti, il metodo più semplice per ottenere la stringa invertita sarebbe tipo:

StringBuilder sb = new StringBuilder (tuaStringa);
String stringaInvertita = sb.reverse ().toString ();

Però ovviamente dell'inversione se ne occupa lo StringBuilder e non tu, motivo per cui penso non ti sia concessa dall'esercizio questa procedura.

[GrayFin]

L'ultimo punto l'ho sistemato così, grazie ad un utente.

String[] r = {"animale", "balcone", "parco"};

              for(int i=0; i<r.length; i++){            
                   int lung = r[i].length();
            
            for(int j=0; j<r[i].length(); j++){
                char c = r[i].charAt(lung-j-1);
                System.out.print(c);
            }
            System.out.print("\t");
        }

[Alex'87]

In questo modo però stampi la stringa al contrario ma non la salvi da nessuna parte (e l'esercizio mi pare chieda di creare una nuova stringa con l'originale al rovescio.)

Ah, il for più esterno lo puoi trasformare in un for-each, per maggior chiarezza.

[GrayFin]

In questo modo però stampi la stringa al contrario ma non la salvi da nessuna parte (e l'esercizio mi pare chieda di creare una nuova stringa con l'originale al rovescio.)

Ah, il for più esterno lo puoi trasformare in un for-each, per maggior chiarezza.

Si in effetti hai ragione, solo che non ricordo il testo preciso

EDIT:

String stringaDaInvertire ="animale";
........ //le altre stringhe
StringBuilder invertita =new StringBuilder();

for(int i=0; i<stringaDaInvertire.length(); i++){
invertita.insert(0, stringaDaInvertire.charAt(i));
}
........... //medesimo procedimento per le altre stringhe

System.out.println( invertita );

In questo modo però alla fine mi stampa, "ocrap atibib elamina" invece di "elamina atibib ocrap"

[LeleFT]

Si in effetti hai ragione, solo che non ricordo il testo preciso

EDIT:

String stringaDaInvertire ="animale";
........ //le altre stringhe
StringBuilder invertita =new StringBuilder();

for(int i=0; i<stringaDaInvertire.length(); i++){
invertita.insert(0, stringaDaInvertire.charAt(i));
}
........... //medesimo procedimento per le altre stringhe

System.out.println( invertita );

In questo modo però alla fine mi stampa, "ocrap atibib elamina" invece di "elamina atibib ocrap"

Beh... l'esempio che ti avevo postato io con lo StringBuilder era per una sola stringa... ovviamente, per ciascuna stringa lo StringBuilder va ricreato (o, meglio, svuotato)

Se vuoi avere tutte le stringhe invertite, ma stampate nell'ordine, devi avere uno StringBuilder dove andrai a fare ciascuna inversione e uno StringBuilder dove andrai, di volta in volta, a concatenare tutte le inversioni per il risultato finale:

String[] stringhe = {"Ciao", "Pippo", "Pluto"};
StringBuilder risultatoFinale = new StringBuilder();
StringBuilder invertita = new StringBuilder();
for(String s : stringhe) {
   // Svuotiamo il buffer
   invertita.setLength( 0 );

   // Invertiamo la stringa
   for(int i=0; i<s.length(); i++) {
      invertita.insert(0, s.charAt(i));
   }

   // Aggiungo al risultato finale
   risultatoFinale.append( invertita ).append(" ");
}

System.out.println( risultatoFinale );

Se, invece, ciascuna inversione la devi anche salvare, allora...

String[] stringhe = {"Ciao", "Pippo", "Pluto"};
ArrayList<String> risultatoFinale = new ArrayList<String>();
StringBuilder invertita = new StringBuilder();
for(String s : stringhe) {
   // Svuotiamo il buffer
   invertita.setLength( 0 );

   // Invertiamo la stringa
   for(int i=0; i<s.length(); i++) {
      invertita.insert(0, s.charAt(i));
   }

   // Aggiungo al risultato finale
   risultatoFinale.add( invertita.toString() );
}

for(String s : risultatoFinale) {
   System.out.println( s );
}

Ciao.