fil

hvad mener du med gemt igen, vil du bare kopiere den eller loade den ind i hukommelsen ?

Her er koden til et program der flytter et directory med alt derunder, der kan du se hvordan man læser og skriver til filer, og scanner directories osv.

/*
* dirMove.java
*
* Created on 23. november 2000, 11:13
*/


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 "";
    }
}

Her er en simpel klasse der læser
indholdet af en fil som så er
tilgængeligt i getText() metoden
der returnerer en String. Klassen
baserer sig på referencer (svage og bløde)
så teksten kan blive garbage collected
hvis den er stor og hukommelsen er ved
at løbe ud.
TextFileContent tfc = TextFileContent.getSoftTextFileContent("filnavn");
.... // her sker der et eller andet
.... // nu vil I have teksten
String text = tfc.getText();
import java.io.*;
import java.lang.ref.*;

/**
* @author Carsten Knudsen
* @version 1.0
**/
public class TextFileContent implements Serializable {

    private Reference ref;
    private boolean isWeak;
    private String name;
    private static final String CR = System.getProperty( "line.separator" );

    private TextFileContent( Reference ref, String name ) throws IOException {
    this.ref = ref;
    this.isWeak = ref instanceof WeakReference;
    this.name = name;
    } // constructor

    public static TextFileContent getWeakTextFileContent( String name )  throws IOException {
    return new TextFileContent( new WeakReference( load( name ) ), name );
    } // getWeakTextFileContent
   
    public static TextFileContent getSoftTextFileContent( String name )  throws IOException {
    return new TextFileContent( new SoftReference( load( name ) ), name );
    } // getSoftTextFileContent
   
    public String getText() throws IOException {
    String s = (String)ref.get();
    if ( s == null ) {
        s = load( name );
        if ( isWeak )
        ref = new WeakReference( s );
        else
        ref = new SoftReference( s );
    } // if
    return s;
    } // getTextFileContent

    private static String load( String name ) throws IOException {
    File file = new File( name );
    FileReader fileReader = new FileReader( file );
    BufferedReader reader = new BufferedReader( fileReader );
    StringBuffer buffer = new StringBuffer( 8192 );
    String line;
    while ( ( line = reader.readLine() ) != null ) {
        buffer.append( line + CR );
    } // while
    return buffer.toString();
    } // load

} // TextFileContent

Med disse 2 simple klasser, kan du skrive til en fil, og læse fra en fil:

import java.io.*;

class File {
    // Constructors.
    public File() {
      try {
          out = new PrintWriter(new BufferedWriter(new FileWriter("c:\\MyTest.txt")));
        in = new BufferedReader(new FileReader("MyTest.txt"));
      } catch(Exception e) { }
    }

    // Methods.
    public void writeFile(String text) {
      try {
        out.println(text);
        out.close();
      } catch(Exception e) { }
    }

    public void readFile() {
            try {
            String data = (String)in.readLine();
            System.out.println(data);
            in.close();
            } catch(Exception e) { }
    }

    // Variables.
    private BufferedReader in;
    private PrintWriter out;
}





Og test klassen:

public class MyTestFile {
  public static void main(String[] args) {
    File f = new File();
        f.writeFile("This is a test \n");
        f.readFile();
    }   
}