ORALE HAUS: aiuto
Clicca QUI per vedere il messaggio nel forum |
| publi |
Chi mi risponde a queste due domande?
- Descrivete la gestione della memoria, così come è implementata nella JVM, durante l'esecuzione di un programma Java
- Sviluppate una applicazione Java che legga da tastiera una serie di lunghezza non determinata di parole; ordini in modo crescente tali parole e visualizzi sullo schermo l'elenco ordinato.
Grazie mille...
:D :-D :) :-) |
| korn |
il programma ORDINAPAROLE già esiste nell'area files, l'unica differenza è che in questo caso non sono 100 ma X parole da inserire, quindi invece di dichiarare l'array in questo modo:
code:
String[] parole = new String[100];
si fa cosi' (ci sono altri metodi, questo è uno):
code:
int quante = Integer.parseInt(JOptionPane.showInputDialog("Quante parole?"));
String parole[] = new String[quante];
e poi esegui il ciclo di input come sempre:
code:
for (int i = 0; int < parole.length; i++) {
// lettura dati da tastiera
}
:) |
| publi |
Così può funzionare?
import javax.swing.*;
class applicazione {
public static void main(String[] args) {
String vettore[] = creaArray (); //invocazione del metodo per la creazione del vettore
for ( int i=0; i<vettore.length; i++ ) //lettura da tastiera delle parole
vettore[i] = Double.parseDouble(JOptionPane.showInputDialog( null, "Scrivi la "+(i+1)+" parola"));
bubbleSort ( vettore ); //invocazione del metodo per l'ordinamento degli elementi
System.out.println ("Parole ordinate in senso crescente");
for ( int i=0; i<vettore.length ; i++ )
System.out.println ( vettore [i] );
System.exit ( 0 ); // termina il programma
}
//metodo che crea un array di n elementi di tipo double (numeri frazionari a doppia precisione)
public static double[] creaArray( int size ) {
String vettore[];
vettore = new String[size];
for ( int i=0; i<size ; i++ )
vettore[i] = 0; //inizializzazione di tutti gli elementi a zero
return vettore;
}
// ordina gli elementi dell'array utilizzando un algoritmo di ordinamento a bolle
public static void bubbleSort( double b[] ) {
for ( int pass = 1; pass < b.length; pass++ ) // primo ciclo for
for ( int i = 0; i < b.length - 1; i++ ) // secondo ciclo for
if ( ( b[ i ] > b[ i + 1 ] ) ) // confronto
swap( b, i, i + 1 ); // scambio
}
// metodo per lo scambio dei 2 elementi
public static void swap( double c[], int primo, int secondo ) {
double hold; // variabile temporanea per lo swap
hold = c[ primo ];
c[ primo ] = c[ secondo ];
c[ secondo ] = hold;
} }
:idea: :?: :!: :wink: |
| korn |
eh, temo proprio di no!!!!
hai cercato di fondere DoubleSort e OrdinaParole eh???? :)
ok, ti dò la soluzione, ma prima:
DOVUTA PRECISAZIONE: il seguente programma non è opera mia, l'autore originale è WEBNOISE! io l'ho solo modificato per accettare un numero indefinito di parole e non 100 fisse come in origine.
:)
ecco il risultato:
code:
import javax.swing.*;
public class Ordinaparole {
public static void main(String[] args)
{
// creiamo il nostro array
int quante = Integer.parseInt(JOptionPane.showInputDialog("Quante parole vuoi inserire?"));
String a[] = new String [quante]; //vettore di 100 elementi di tipo Stringa
//ciclo for per l'input delle x parole da tastiera
for (int i=0; i<a.length ; i++ )
a[i] = JOptionPane.showInputDialog( null, "Inserisci la " + (i+1) + " parola");
//richiama il metodo per l'ordinamento a bolle ( bubbleSort )
//input il vettore (array) da ordinare
bubbleSort( a );
String output =""+ "\n\nParole ordinate lessicograficamente\n";
// buffer stringa: inizializzazione e titolazione
// **************** FILTRO ELIMINAZIONE DUPLICATI *****************************
for ( int i = 0; i < a.length; i++ )
if (a[i]!="~")
output += "\n" + a[ i ]; //concatena le parole e le mette nel
//buffer stringa: se trova il carattere ~ (duplicati) li ignora
System.out.println(output); //visualizza le parole ordinate lessicograficamente
System.exit (0); //esce
}
// ordina gli elementi dell'array utilizzando un algoritmo di ordinamento
// a bolle (BubbleSort).
//Vedi capitolo 7 libro Java - Fondamenti di programmazione Deitel&Deitel
public static void bubbleSort( String b[] )
{
for ( int pass = 1; pass < b.length; pass++ ) // primo ciclo for
for ( int i = 0; i < b.length - 1; i++ ) // secondo ciclo for
if ( (b[ i ].compareTo(b[ i + 1 ])==0)) // primo confronto: se esistono
//parole uguali le contrassegna con ~
b [ i ] = "~" ;
else
{
if ( (b[ i ].compareTo(b[ i + 1 ])>0) ) // confronto e ordinamento lessicografico
swap( b, i, i + 1 ); // scambio
}
}
// metodo che scambia due stringhe nell'array di stringhe
public static void swap( String c[], int primo, int secondo )
{
String temp; // variabile String temporanea per effettuare lo scambio
temp = c[ primo ];
c[ primo ] = c[ secondo ];
c[ secondo ] = temp;
}
}
compilalo e vedi se funge!! |
| publi |
Ok ti ringrazio veramente tanto...
Java sarà il mio incubo!
:? :? :? :? |
|
|
|
