Startseite Java Snippets Archive nach Kategorien "Files"

Kategorie: Files

Datentyp in Byte, abhängig der Bytereihenfolge (byte order), wandeln 

// z.B. 4 Bytes float
float a = 1000.0f;

// 4 Bytes langen Puffer anlegen
ByteBuffer buffer = ByteBuffer.allocate(4);

// Bytereihenfolge für x86
buffer.order(ByteOrder.LITTLE_ENDIAN);

// z.B. float übergeben   
buffer.putFloat(a);

// Ergebnis: byte-Array mit 4 Bytes float in der ByteOrder LITTLE_ENDIAN
byte[] bytes = buffer.array();

[Java] CSV-Daten einlesen 

public boolean LoadCSV(String csvfile, String separator) throws FileNotFoundException, IOException
{
    boolean ret = false;
    
    File f = new File(csvfile);
    
    // prüfen, ob Datei existiert
    if (f.exists() && f.isFile())
    {
        BufferedReader br = null;
        FileReader fr = null;

        try
        {
            fr = new FileReader(f);
            br = new BufferedReader(fr);
            
            String l;
            
            // solange Zeilen in der Datei vorhanden
            while ((l = br.readLine()) != null)
            {
                // Zeilen anhand des Separators,
                // z.B. ";", aufsplitten
                String[] col = l.split(separator);
                
                // testweise einzelne Spalten ausgeben
                for (String s : col)
                {
                    System.out.println(s);
                }
            }
            
            ret = true;
        }
        finally
        {
            if (br != null)
            {
                br.close();
            }

            if (fr != null)
            {
                fr.close();
            }
        }
    }
    
    return ret;
}

[Java] SaveFileDialog anzeigen 

import java.io.File;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
 * shows a SaveFileDialog
 */
public class SaveFileDialog
{
    private ArrayList<String> _extensiontext = new ArrayList<>();
    private ArrayList<String> _extension = new ArrayList<>();

    /**
     * shows SaveFileDialog
     * @param path initial path, may be null
     * @return selected file or null if not overwritten
     */
    public File showDialog(String path)
    {
        File f = null;
        
        if (_extensiontext.size() > 0)
        {
            if ((path == null) || (path.length() == 0))
            {
                path = System.getProperty("user.home");
            } 

            final JFileChooser c = new JFileChooser(path);

            c.setDialogTitle("Save file");
            c.setDialogType(JFileChooser.SAVE_DIALOG); 
            c.setFileSelectionMode(JFileChooser.FILES_ONLY);

            // add filters
            for (int i = 0; i < _extensiontext.size(); i++)
            {
                FileNameExtensionFilter ff = new FileNameExtensionFilter(_extensiontext.get(i), _extension.get(i));
                c.setFileFilter(ff);
            }

            c.setVisible(true);

            // if "ok" or "yes" pressed
            if (c.showSaveDialog(null) == JFileChooser.APPROVE_OPTION)
            {
                f = c.getSelectedFile();

                String nameLower = f.getName().toLowerCase();
                String[] exts = ((FileNameExtensionFilter)c.getFileFilter()).getExtensions();
                boolean hascorrectext = false;

                // check if filename ends with filterextension
                for (String ext : exts)
                {
                    if (nameLower.endsWith('.' + ext.toLowerCase()))
                    {
                        hascorrectext = true;
                        break;
                    }
                }

                if (!hascorrectext)
                {
                    // if not, make new filename
                    f = new File(f.toString() + '.' + exts[0].toLowerCase());
                }

                boolean overwrite = true;

                // if file exists ask for overwriting
                if (f.exists())
                {
                    overwrite = (JOptionPane.showConfirmDialog(null, "File exists, overwrite?", "Question", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION);
                }

                if (!overwrite)
                {
                    f = null;
                }
            }
            
            c.setVisible(false);
        }
        
        return f;
    }

    /**
     * adds FileNameExtensionFilter
     * @param text Filtertext, e.g. "Textfiles (*.txt)"
     * @param ext Filterextension, e.g. "txt"
     */
    public void addExtension(String text, String ext)
    {
        _extensiontext.add(text);
        _extension.add(ext);
    } 
}

Aufruf:

SaveFileDialog fd = new SaveFileDialog();
// add an extension
fd.addExtension("Textfiles (*.txt)", "txt");
// open dialog and get selected file
File f = fd.showDialog(null);

[Java] OpenFileDialog anzeigen 

import java.io.File;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
 * shows a OpenFileDialog
 */
public class OpenFileDialog
{
    private ArrayList<String> _extensiontext = new ArrayList<>();
    private ArrayList<String> _extension = new ArrayList<>();

    /**
     * shows OpenFileDialog
     * @param path initial path, may be null
     * @return selected file
     */
    public File showDialog(String initialpath)
    {
        if ((initialpath == null) || (initialpath.length() == 0))
        {
            initialpath = System.getProperty("user.home");
        }

        final JFileChooser c = new JFileChooser(initialpath);
        
        c.setDialogTitle("Select file");
        c.setDialogType(JFileChooser.OPEN_DIALOG); 
        c.setFileSelectionMode(JFileChooser.FILES_ONLY);
        
        // add filters
        for (int i = 0; i < _extensiontext.size(); i++)
        {
            FileNameExtensionFilter ff = new FileNameExtensionFilter(_extensiontext.get(i), _extension.get(i));
            c.setFileFilter(ff);
        }

        // show dialog
        c.setVisible(true);
        
        File f = null;
        
        // if "ok" or "yes" pressed    
        if (c.showOpenDialog(null) == JFileChooser.APPROVE_OPTION)
        {
            // get selected file
            f = c.getSelectedFile();
        }
        
        // close dialog
        c.setVisible(false);

        return f;
    }

    /**
     * adds FileNameExtensionFilter
     * @param text Filtertext, e.g. "Textfiles (*.txt)"
     * @param ext Filterextension, e.g. "txt"
     */
    public void addExtension(String text, String ext)
    {
        _extensiontext.add(text);
        _extension.add(extension);
    }
}

Aufruf:

OpenFileDialog fd = new OpenFileDialog();
// add an extension
fd.addExtension("Textfiles (*.txt)", "txt");
// open dialog and get selected file
File f = fd.showDialog(null);

[Java] Bytedaten einlesen und konvertieren (Little Endian / Big Endian) 

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public boolean LoadBinaryData(String filename) throws IOException
{
    boolean bRetVal = false;

    FileInputStream fis = null;
    DataInputStream dis = null;
    
    try
    {
        File f = new File(filename);
              
        if (f.isFile() && f.canRead())
        {
            fis = new FileInputStream(filename);
            dis = new DataInputStream(fis);
            
            // Bsp.: 8 Bytes als Double lesen
            byte[] Test1 = new byte[8];
            dis.read(Test1);
            
            double a = ByteBuffer.wrap(Test1).order(ByteOrder.LITTLE_ENDIAN).getDouble();

            System.out.println(a);

            // Bsp.: 4 Bytes als Float lesen
            byte[] Test2 = new byte[4];
            dis.read(Test2);
            
            float b = ByteBuffer.wrap(Test2).order(ByteOrder.LITTLE_ENDIAN).getFloat();

            System.out.println(b);

            // Bsp.: 2 Bytes als Short lesen
            byte[] Test3 = new byte[2];
            dis.read(Test3);
            
            short c = ByteBuffer.wrap(Test3).order(ByteOrder.LITTLE_ENDIAN).getShort();

            System.out.println(c);
            
            bRetVal = true;
        }
    }
    catch (Exception e)
    {
         e.printStackTrace();
    }
    finally
    {
         if (fis != null) fis.close();
         if (dis != null) fos.close();
    }
    
    return bRetVal;
}

[Java] Konfigurations-Einstellungen mit Hilfe von Properties laden/speichern

Häufig ist es notwendig, dass Programmeinstellungen in eine Konfigurationsdatei gespeichert und wieder geladen werden können. Mit Hilfe des Properties Objektes können solche Dateien im Format:

#Kommentarzeile
#Mon Jan 12 12:00:00 MYT 2013
database=localhost
user=Horst
password=geheim

oder

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Kommentarzeile</comment>
<entry key="database">localhost</entry>
<entry key="user">Horst</entry>
<entry key="password">geheim</entry>
</properties>

erzeugt werden.

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * Speichert Konfiguration
 * @param filename Dateiname der Konfigurationsdatei
 */
public void SaveConfig(String filename)
{
    Properties prop = new Properties();
    FileOutputStream fos = null;

    try
    {
        // Properties setzen
        prop.setProperty("database", "localhost");
        prop.setProperty("user", "Horst");
        prop.setProperty("password", "geheim");

        // 1. Einstellungen speichern als einfache Datei
        fos = new FileOutputStream(filename);
        prop.store(fos, "Kommentarzeile");

        // 2. Einstellungen speichern als XML-Datei im Format UTF-8
        prop.storeToXML(new FileOutputStream(filename), "Kommentarzeile", "UTF-8");
    }
    catch (IOException ex)
    {
        ex.printStackTrace();
    }
    finally
    {
        if (fos != null) fos.close();
    }
}

/**
 * Läd Konfiguration
 * @param filename Dateiname der Konfigurationsdatei
 */
public void LoadConfig(String filename)
{
    Properties prop = new Properties();
    FileInputStream fis = null;

    try
    {
        // 1. Einstellungen aus einfacher Datei laden
        fis = new FileInputStream(filename);
        prop.load(fis);
        
        // 2. oder Einstellungen aus XML-Datei laden
        //prop.loadFromXML(fis);

        System.out.println(prop.getProperty("database"));
        System.out.println(prop.getProperty("user"));
    	System.out.println(prop.getProperty("password"));
    }
    catch (IOException ex)
    {
        ex.printStackTrace();
    }
    finally
    {
        if (fis != null) fis.close();
    }
}

Weiterführende Links

[Java] Binärdaten aus einer Datei lesen

Bitte beachten: bei Binärformaten kann es vorkommen, dass die Bytereihenfolge der Datentypen vertauscht ist. Siehe auch: Bytedaten einlesen und konvertieren (Little Endian / Big Endian).

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public boolean LoadBinaryData(String filename) throws IOException
{
    boolean bRetVal = false;

    FileInputStream fis = null;
    DataInputStream dis = null;
    
    try
    {
        File f = new File(filename);
              
        if (f.isFile() && f.canRead())
        {
            fis = new FileInputStream(filename);
            dis = new DataInputStream(fis);
            
            // Bsp.: 8 Bytes lesen
            byte[] Test1 = new byte[8];
            dis.read(Test1);
            
            // Bsp.: 1 Byte lesen
            byte Test2 = dis.readByte();
            
            // Bsp.: n float lesen
            while (dis.available() > 0)
            {
                float Test3 = dis.readFloat();

                System.out.println(Test3);
            }
            
            bRetVal = true;
        }
    }
    catch (Exception e)
    {
         e.printStackTrace();
    }
    finally
    {
         if (fis != null) fis.close();
         if (dis != null) fos.close();
    }
    
    return bRetVal;
}