DOMANDA [JAVA] Copia multipla files e/ directory e altro

Pubblicità
Stato
Discussione chiusa ad ulteriori risposte.
S

Sergei

Utente Attivo
Messaggi
115
Reazioni
1
Punteggio
38
ok, ok... lo so che state pensando: "Ancora con questa domanda? Basta una semplice ricerca!"
Ok, forse è vero. Il fatto è che sono 2 giorni che faccio ricerche ma non ho trovato un cacchio di niente che mi soddisfi o almeno non ho capito molto, troppa ignoranza lo so :D

Il fatto è semplice. Io ho una cartella c:\documenti con dentro 30 files. Fin qui tutto chiaro. Ora dovrei fare un piccolissimo programma che automaticamente mi COPI (non sposti) i file presenti in documenti da un'altra parte (es. m:\backup). Il fatto è: COME SI FA?
Mi sono messo in rete a cercare, ma per i file multipli non ho trovato niente... o almeno non sono riuscito a capire niente :(

Ho visto sul sito della sun che c'è il il metodo files.copy, dove dai le due path e volendo l'opzione di copia (se il file già presente sovrascrivi). Il fatto è che devo specificare il nome del file d'orgine e il nome del file di destinazione e a me questo proprio non serve. Devo copiare tutti i files presenti nella cartella in un'altra cartella.
Per fare una cosa del genere credo di aver bisogno di un ciclo for, solo che come li copio i file? Per cancellarli c'è il delete() che ho provato e funziona alla grande, ma per la copia non c'è niente. Ho visto che da alcune parti si usano i FileInputStream e FileOutputStream, ho provato ma parliamo sempre di un singolo file. Per copiarli tutti come si fa? La cartella non dovrebbe essere un array (ma l'array in italiano è una parola maschile o femminile :asd:?)?

Sto leggermente impazzito... troppe informazioni mal digerite dal mio cervello :sisi:

EDIT: il mio intento era quello di creare un piccolo programmino con gui dove c'era una percentuale della copia in corso e sotto la lista dei nomi dei file con accanto "copiato" o "copia fallita".

EDIT 2: ho visto che esiste una libreria di apache che fa al caso mio. Ho utilizzato il metodo FileUtils ed effettivamente funge alla grande. Ma è giusto (ma che razza di domanda è? :D)? E può fare al caso mio?
 
Ultima modifica:
Sergei ha detto:
Ho visto che da alcune parti si usano i FileInputStream e FileOutputStream, ho provato ma parliamo sempre di un singolo file.
Clicca per espandere...
Parliamo di un singolo file fino a quando non lo mettiamo in un ciclo for! Anch'io utilizzerei quel metodo!
Codice: 
int n = 30; // numero file
int x;

for (x=0; x<n; x++)
{
    copia_file(array_file[x]);
}
dove copia_file è la funzione che ti scrivi tu utilizzando FileInputStream e FileOutputStream mentre array_file è il numero di file contenuti nella cartella.
Il codice si allunga nel momento uno di quei 30 file non è un file ma una cartella perchè in quel caso ai 29 file si aggiungono tutti quelli contenuti nella cartella. Quindi devi pensarlo bene l'algoritmo!
 
esatto, esatto. e la cosa più divertente è che l'avevo anche fatto... questo attesta che non sto del tutto bene :D
il problema è che mi dà accesso negato O___O Exception in thread "main" java.io.FileNotFoundException: C:\blabla\PATH(Accesso negato)
per quello ero andato a finire su altro. Ma com'è possibile?

EDITONE:
leggo che con il fileinputstream non è possibile passare una directory... quindi c'è qualcosa che mi sfugge. Come posso utilizzare un ciclo for sul totale degli elementi della cartella (array) se non posso utilizzare la cartella ma devo speficiare il file?
 
Ultima modifica:
Infatti non puoi passare una cartella, ma puoi passare tutti elementi facenti parte della cartella! Posta il codice ;)
 
ma il problema è che sia FileInputStream che FileOutputStream non prendono array, o no?

per copiare un file ho usato questo codice:
Codice: 
public class MetodoRapido {

    public void copiaDati() throws IOException {
        System.out.println("Inizio trasferimento...");
        File origine = new File("D:\\datrasferire\\");
        File destinazione = new File("D:\\copiato\\");
        byte[] buffer = new byte[4096]; // buffer di 4kb
        int byteLetti = 0;

        // apro il file di origine
        FileInputStream fis = new FileInputStream(
                origine);
        System.out.println(origine.length());
        
        // apro il file di destinazione
        FileOutputStream fos = new FileOutputStream(destinazione);
        
                
        //Leggo e scrivo
        for (int x = 0; x < origine.length(); x++){
            while((byteLetti = fis.read(buffer)) >= 0){
                fos.write(buffer, 0, byteLetti);
                System.out.println("Copia Riuscita!");
            }
        } 
        
        // chiudo il file d'origine
        fis.close();
        System.out.println("fis chiuso");
        
        //chiudo il file di destinazione
        fos.close();
        System.out.println("fos chiuso");
        
        System.out.println("Trasferimento ultimato");
        
    }
}

poi ho aggiunto inutilmente un ciclo for :D
Ho capito quello che vuoi dire, solo che non riesco a capire dove va metto :( e soprattutto come va messo... ok, troppi doppi giochi linguistici :D
 
Ad esempio:
Codice: 
//Io dichiarerei gli oggetti per l'input e l'output fuori...
File[] arrayFileSorgente; 
File[] arrayFileDestinazione;
//fai tutto quello che serve per inizializzare l'array di oggetti di tipo File cioé li riempi con i file che ti servono - Occhio alle eccezzioni da gestire,
//forse è meglio se usi una ArrayList o un vector....


Poi fai una funzione di questo tipo....

Codice: 
public void copia(File[] sorgente, File[] destinazione) throws IOException {
for (int i = 0; i < farray.lenght(); i++){
FileInputStream fis = new FileInputStream(sorgente[i]); //Ad ogni ciclo crei un FIS 
FileOutputStream fos = new FileOutputStream(destinazione[i]) //...e un FOS
//leggi e scrivi....
//Ricordati di chiudere i file....
}

}

Spero di averti aiutato. Ciao!
 
Tu non passi tanti file(array), passi UN file alla volta! Tu nella cartella principale hai file e cartella (facciamo che sono 30 in tutto), ma tu non invierai 30 file, ne invierai molti di più!! Infatti le cartelle conterranno altri file.. Il numero totale dei file che invierai corrisponderà alla somma dei file contenuti nella cartella principale più i file contenuti nelle cartelle che si trovano nella cartella principale!
 
@cawletto
Scusa, non ho capito il senso del tuo post. Ti riferisci a me? Se sì, ti spieghi meglio per favore? Ciao :)
 
No no cercavo di spiegare a Sergei la logica del programma..che in fin dei conti è quello che hai scritto anche tu! :sisi:
 
Ah ok :)

Comunque @Sergei java offre funzionalità niente male per la gestione dei file. Potresti anche fare una funzione ricorsiva che controlli se il file specificato è una cartella o un file normale e si comporti di conseguenza. Facci sapere. Ciao!
 
Ciao, mi permetto di aggiungere una cosetta. Affinché la copia sia davvero in contemporanea e multipla forse dovresti usare i thread, anche se credo siano un po' oltre il tuo livello. Vedi tu. Ciao ciao
 
lock3r ha detto:
Ah ok :)

Comunque @Sergei java offre funzionalità niente male per la gestione dei file. Potresti anche fare una funzione ricorsiva che controlli se il file specificato è una cartella o un file normale e si comporti di conseguenza. Facci sapere. Ciao!
Clicca per espandere...

eh, ho visto infatti :)

lock3r ha detto:
Ciao, mi permetto di aggiungere una cosetta. Affinché la copia sia davvero in contemporanea e multipla forse dovresti usare i thread, anche se credo siano un po' oltre il tuo livello. Vedi tu. Ciao ciao
Clicca per espandere...

Per il momento sono fuori dalla mia portata, ma potrebbe essere un motivo in più per capirne di più.
Comunque dopo mi applico per comprendere i vostri suggerimenti :)

La difficoltà che avevo era inserire l'array nel fileinputstream etc...

Comunque dopo provo, ci sentiamo più tardi di sicuro :asd:

Ah, un doveroso GRAZIE MILLE, eh :ok:
 
Per ringraziare usa gli appositi tastini Mi Piace/Ringrazia sotto ogni post. Ciao e facci sapere :)
 
Eh... niente, non capisco :D
Ho provato ad applicarmi ma c'è qualcosa che non mi torna nel mio cervello bacato.

Per copiare più file devo creare necessariamente un array. Praticamente devo copiare un file per volta visto che non c'è alcun metodo per copiare le cartelle.
Se ho capito bene non posso creare l'array della cartella, quindi devo creare un oggetto File col percorso della cartella, poi devo creare un array che prendere l'oggetto File creato prima col parametro listFiles(), giusto?
Poi devo creare i due flussi per trasferire i dati. Siccome bisogna farlo un file alla volta, devo creare un ciclo for nel cui interno viene creato un oggetto FileInputStream etc che prende come parametro un oggetto dell'array dichiarato prima (che grazie al ciclo for viene automatizzato e passato a tutti gli altri file della cartella). E' così?
 
Stato
Discussione chiusa ad ulteriori risposte.
Pubblicità
Pubblicità
Indietro
Top