[Java] Float to String, String to Float

// Float -> String
String s1 = Float.toString(25.0f);
String s2 = String.valueOf(25.0f);

// formatierte Stringausgabe
// Variante 1:
// Dezimalseparator einstellen
DecimalFormatSymbols s = new DecimalFormatSymbols();
s.setDecimalSeparator('.');
// Anzahl Nachkommastellen                
DecimalFormat df = new DecimalFormat("0.00");
df.setDecimalFormatSymbols(s);
String s3 = df.format(25.453f);

// Variante 2:
DecimalFormat df = (DecimalFormat)DecimalFormat.getInstance(Locale.GERMAN);
df.applyPattern("0.00");
String s4 = df.format(25.453f);

// Variante 3:
String.format(Locale.GERMAN, "0.00", 25.453f);

// String -> Float
float f1 = Float.parseFloat("100.0");

// String -> Float ohne Locale
float f2 = NumberFormat.getInstance().parse("100.0").floatValue();
// String -> Float mit Locale
float f3 = NumberFormat.getInstance(Locale.GERMANY).parse("100.0").floatValue();

Weiterführende Links:

[Java] Einen modalen Dialog anzeigen

Voraussetzung für die Nutzung eines modalen Dialoges ist die Nutzung eines JDialog. Folgende Eigenschaften sollten gesetzt sein:

  • defaultCloseOperation = DISPOSE
  • modal = true
  • modalityType = APPLICATION_MODAL
  • Form Size Policy = Generate Resize Code
  • Generate Size = true
  • Generate Center = true

Innerhalb des Dialog-Codes sollte folgende Funktion definiert werden:

/**
 * globale Variable, die den Status des Modaldialoges zurückgibt
 */
private int iDialogResult;

/**
 * Dialog anzeigen, auf Abarbeitung warten und iDialogResult zurückgeben
 * @return int-Status
 */
public int showDialog()
{
    // Code-Abarbeitung hält hier an,
    // bis Button "Ok" geklickt wurde
    this.setVisible(true);
    // nach Klick auf Button "Ok" springt die
    // Methode hier mit dem iDialogResult raus
    return iDialogResult;
}

/**
 * Methode des Ok-Buttons
 */
private void btnOkActionPerformed(java.awt.event.ActionEvent evt) {
    // iDialogResult setzen
    if ( ... )
    {
        iDialogResult = 0;
    }
    else
    {
        iDialogResult = 1;
    }

    // Dialog ausblenden
    this.setVisible(false);
    // Dialog zerstören und automatisch zurück
    // zur Abarbeitung von showDialog() springen
    this.dispose();
}

Der Aufruf des Dialoges muss wie folgt aussehen:

// Dialogobjekt erzeugen
DialogClassName dlg = new DialogClassName(this, true);
// auf DialogResult blockierend warten, bis Dialog geschlossen wird
int result = dlg.showDialog();

[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] XML-Datei speichern

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Datei im XML-Format (*.xml) speichern
 * @param filename Dateiname
 * @return true, wenn Speichern erfolgreich
 */
public boolean SaveXML(String filename)
{
    boolean bRetVal = false;

    try
    {
        File f = new File(filename);
        
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
            
        // root
        Document doc = builder.newDocument();
        Element root = doc.createElement("root");
        doc.appendChild(root);

            // <value>1.0</value>
            Element v = doc.createElement("value");
            v.appendChild(doc.createTextNode("1.0"));
            root.appendChild(v);
        
            for (int i = 0; i < 10; i++)
            {
                // <type value="0"/>
                Element t = doc.createElement("type");
                t.setAttribute("value", Integer.toString(i));
                root.appendChild(t);
                
                for (int j = 0; j < 10; j++)
                {
                    // <type_value v1="0" v2="0"/>
                    Element tv = doc.createElement("type_value");
                    tv.setAttribute("v1", Integer.toString(i+j));
                    tv.setAttribute("v2", Integer.toString(i*j));
                    raster.appendChild(tv);
                }
                //</type>
            }
                        
        // write xml
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        //transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        //transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        transformer.transform(new DOMSource(doc), new StreamResult(f));

        bRetVal = true;
    }
    catch (Exception e)
    {
        bRetVal = false;
    }
    finally
    {
    }
    
    return bRetVal;
}

[Java] XML-Datei laden

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Datei im XML-Format (*.xml) laden
 * @param filename Dateiname
 * @return true, wenn Laden erfolgreich
 * @throws IOException 
 */
public boolean LoadXML(String filename) throws IOException
{
    boolean bRetVal = false;

    try
    {
        File f = new File(filename);
        
        if (f.isFile() && f.canRead())
        {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
            DocumentBuilder builder = factory.newDocumentBuilder(); 
            Document doc = builder.parse(f);
            Node root = doc.getDocumentElement();
            root.normalize();
            
            if (root != null)
            {
                if (root.hasChildNodes())
                {
                    // Liste mit allen Elementen mit dem Bezeichner "item"
                    NodeList items = doc.getElementsByTagName("item");
                    
                    for (int i = 0; i < items.getLength(); i++)
                    {
                        Node item = items.item(i);
                        
                        // nodevalue, e.g. "0.5" or "Paul"
                        String nv = item.getNodeValue();
                        // nodename, e.g. <item>
                        String nn = item.getNodeName();
                        
                        // childs
                        NodeList childs = item.getChildNodes();
                        // attributes
                        NamedNodeMap attr = item.getAttributes();
                        
                        ...
                    }
                }
            }
            
            bRetVal = true;
        }
    }
    catch (Exception e)
    {
        bRetVal = false;
    }
    finally
    {
    }
    
    return bRetVal;
}

[Java] JAR-Datei mit Netbeans + Maven erzeugen

Standardmäßig wird bei der Verwendung von Netbeans + Maven keine JAR-Datei erzeugt. Dies muss erst in den Projekteinstellungen in der Datei “Project Files/pom.xml” festgelegt werden. Dazu sind folgende Eintragungen notwendig:

<build>
  <plugins>
    <plugin>
      <!-- Build an executable JAR -->
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-assembly-plugin</artifactId>
      <version>2.4</version>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
          <manifest>
            <!-- mainpackage: your main package name -->
            <!-- mainclassname: your main class -->
            <mainClass>mainpackage.mainclassname</mainClass>
          </manifest>
        </archive>
      </configuration>
      <executions>
        <execution>
          <id->make-assembly</id>
          <phase->package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Durch diese Eintragung wird eine JAR-Datei erzeugt, welche alle abhängigen Libraries integriert hat.

Weiterführende Links:

[Java] log4j verwenden

log4j dient dem Loggen von Anwendungsmeldungen in Java. Das Framework wird im Code importiert und wie im folgenden Beispiel verwendet:

import org.apache.log4j.*;

public class myClass {

    private final static Logger log = Logger.getLogger( myClass.class );
    
    public void Test() {
      log.trace("Trace");
      log.debug("Debug");
      log.info("Info");
      log.warn("Warn");
      log.error("Error");
      log.fatal("Fatal");
    }
}

Wichtig ist außerdem die Definition einer Konfigurationsdatei “log4j.properties” im Verzeichnis “Projektname\src\main\resources\”, im Projektbaum unter “Other Sources”.

# Root logger option
log4j.rootLogger=DEBUG, file, stdout

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
# Create a logfile below project main directory
log4j.appender.file.File=logfile.log
log4j.appender.file.MaxFileSize=1MB
log4j.appender.file.MaxBackupIndex=1
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

Weiterführende Links: