Path til træ-struktur

lav en rekursiv algoritme som scanner alle dirs ud fra et bestemt punkt.

Du starter f.eks. med en tom arraylist.
Hvis du møder et dir, indsætter du et object som indeholder en ny arraylist, for at scanne denne kalder du den oprindelige rutine men med en ny start pos.
Møder du en fil, indsætter du et object der indeholder filens navn, og evt. andet data.

Bagefter kører du bare denne arrayliste struktur igennem for at generere dit JTree, det skulle ikke tage længere tid, end en

'dir /s' går i dos (okay en lille smule mere, men ikke lang tid

Du kan måske få ideer fra denne her, som kopierer et helt dir og alt derunder over til et nyt sted.

import java.io.*;
import java.lang.*;
import java.util.*;


/**
*
* @author  reinke
* @version
*/
public class dirMove extends Object
{
    /** The error code
    */
    private int error=0;

    File sourceDir,destDir;
   
    public dirMove()
    {
    }
   
    /** Moves directory from source to dest including everything beneath it
    * @param source The filepath to the source directory
    * @param dest The filepath to the destination
    * @return According to result of the moving of the directory
    */
    public boolean move(String source, String dest)
    {
        //check if either source or dest is empty or null
        if ( (source.trim().length()==0) || (source==null) || (dest.trim().length()==0) || (dest==null) )
        {
            error=1;
            return false;
        }
       
        sourceDir=new File(source);
       
        if(!sourceDir.isDirectory())
        {
            error=2;
            return false;
        }

        destDir=new File(dest);
       
        if(destDir.exists())
        {
            error=3;
            return false;
        }

        if(source.endsWith("/"))
        {
            source=source.substring(0,source.length()-1);
        }

        if(dest.endsWith("/"))
        {
            dest=dest.substring(0,dest.length()-1);
        }
   
        //some error has happened
        if(!moveIt(source,dest))
        {
            deleteDirs(dest);
        }
        return true;
    }

    public void deleteDirs(String dest)
    {
        File dFile=new File(dest);

        File files[]=scanDir(dFile);
       
        if(files.length!=0)
        {
            for(int x=0;x<files.length;x++)
            {
                String name=files[x].getName();
               
                if(files[x].isDirectory())
                {
                    deleteDirs(dest+"/"+name);
                    files[x].delete();
                }
                else
                {
                    files[x].delete();
                }
            }
        }
        else
        {
            dFile.delete();
        }
    }
   
    private boolean moveIt(String source, String dest)
    {
        File sFile=new File(source);
        File dFile=new File(dest);
       
        if(!dFile.mkdirs())
        {
            error=4;
            return false;
        }
     
        File files[]=scanDir(sFile);
       
        if(files.length!=0)
        {
            for(int x=0;x<files.length;x++)
            {
                String name=files[x].getName();
               
                if(files[x].isDirectory())
                {
                    moveIt(source+"/"+name,dest+"/"+name);
                }
                else
                {
                    if(!copyFile(source+"/"+name,dest+"/"+name))
                    {
                        error=5;
                        return false;
                    }
                }
            }
        }
        return true;
    }
   
    /**
    * @param dir
    * @return  */
    private File [] scanDir(File dir)
    {
        return dir.listFiles();
    }
   
    private boolean copyFile(String source, String dest)
    {
        try
        {
//            FileInputStream in=new FileInputStream(new File(source));
//            FileOutputStream out=new FileOutputStream(new File(dest));
            BufferedInputStream in=new BufferedInputStream(new FileInputStream(new File(source)));
            BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream(new File(dest)));
           
            int data;
           
            while((data=in.read())!=-1)
            {
                out.write(data);
            }
           
            in.close();
            out.close();
        }
        catch (IOException e)
        {
            return false;
        }
        return true;
    }
   
    /** Returns the error text according to the value of 'error'
    * @return String containing the Error Text according to the value of {@link error}
    */
    public String getError()
    {
        if(error==1) return "source eller dest er tom";
        if(error==2) return "source er ikke en directory";
        if(error==3) return "destination findes allerede!!!";
        if(error==4) return "Could not create Directory";
        if(error==5) return "File copy failed";
        return "";
    }
}

Du skal have tak for din tid, disky, men det hjælper mig ikke. Spørgsmålet gik jo netop på hvordan jeg undgik at lave en kæmpealgoritme, ikke hvordan jeg laver algoritmen.

det er entm at svare på.

Nu er en simpel lille rekursiv algoritme ikke kæmpe :-)

Et kig i JDK1.4 API'en for JTree gav indirekte en link til :

http://java.sun.com/products/jfc/tsc/articles/treetable1/index.html se nederst der har de et eksempel hvordan du skal gøre

De hele kan downloades her:
http://java.sun.com/products/jfc/tsc/articles/treetable1/downloads/sources.zip

Hvad der er en lille rekursiv algoritme for dig, er en kæmpe algoritme for mig.

(det er ikke det jeg leder efter, og jeg havde også selv fundet det tidligere, men det lader ikke til andre har et bud)