Mit kXML UTF-8 Dateien lesen

0

15. März 2010

Um UTF-8 Zeichensätze korrekt einlesen zu können, muss man (bei Verwendung der kXML-Bibliothek) den Parser auf UTF-8 einstellen:

FileConnection fc = (FileConnection) Connector.open(file:///root1/test.xml);
InputStream is = fc.openDataInputStream();
InputStreamReader reader = new InputStreamReader(is, "UTF-8");
XmlParser parser = new XmlParser(reader);

Zur Sicherheit sollten die XML-Dateien immer mit der Kodierung “UTF-8 ohne BOM” (einstellbar in Notepad++) abgespeichert werden.

Tags: Java, auslesen, einlesen, JME, kXML, UTF-8, Zeichensatz

Zeilenumbrüche und Tabulatoren in Java entfernen

3

15. März 2010

Hier ein kleiner Beispielcode um einen Zeilenumbruch oder eine Tabulator-Einrückung in Java zu entfernen:

Etwas unsaubere Lösung mit replace:

    public String formatText(String strGivenText)
    {
        // Tabulator entfernen
        String strNewText   = strGivenText.replace('\t', '\0');
        // Zeilenumbruch entfernen (Unix)
        strNewText          = strNewText.replace('\n', '\0');
        // Zeilenumbruch/Wagenrücklauf entfernen (Windows)
        strNewText          = strNewText.replace('\r', '\0');
 
        return strNewText;
    }

Elegante Lösung mit StringBuffer:

    public String formatText(String strGivenText)
    {
        StringBuffer sbFormattedText = new StringBuffer(strGivenText);
 
        for(int i=0; i<sbFormattedText.length(); i++)
        {
           if(sbFormattedText.charAt(i) == '\n')
               sbFormattedText.deleteCharAt(i);
 
           if(sbFormattedText.charAt(i) == '\r')
               sbFormattedText.deleteCharAt(i);
 
           if(sbFormattedText.charAt(i) == '\t')
               sbFormattedText.deleteCharAt(i);
        }
 
        return sbFormattedText.toString();
    }

Tags: Java, entfernen, Tabulator, Zeilenumbruch

IllegalStateException

0

15. März 2010

Die java.lang.IllegalStateException taucht bei Applikationen aus der Java Micro Edition häufig auf, wenn versucht wird bei einem Form-Objekt mit append ein Item hinzuzufügen, das bereits schon auf dem Form existiert.

Beispiel:

        Form neuesForm = new Form("Titelzeile");
        StringItem text = new StringItem("Label","Text");
        neuesForm.append(text);
        neuesForm.append(text);

Das ist verboten. Um dasselbe Objekt erneut dem Form hinzufügen zu können, muss man die ältere Version zuerst mit delete entfernen.

Beispiel:

        Form neuesForm = new Form("Titelzeile");
        StringItem text = new StringItem("Label","Text");
        neuesForm.append(text);
        neuesForm.delete(0);
        neuesForm.append(text);

Die delete-Methode akzeptiert nur Werte vom Typ Integer. Die “0″ steht für das erste Element, welches dem Form hinzugefügt wurde, die “1″ für das zweite Element, usw.. Mit deleteAll() können alle Element vom Form entfernt werden.

Tags: Java, Form, IllegalStateException, JME

Zufallszahlen in Java

3

14. März 2010

Um Zufallszahlen in Java zu erstellen, kann man die Bibliothek java.util.Random verwenden. Die Zufalls-Klasse von Java ist sehr vielseitig und bietet unter anderem die Möglichkeit, Zufallszahlen in einem bestimmten Bereich zu definieren. An dieser Stelle folgt ein kleiner Beispiel-Code, welcher 20 Zufallszahlen im Bereich von 0 bis 72 ausgibt:

    public void erstelleZufallsZahl()
    {
        Random zufallsgenerator = new Random();
 
        for(int i=0; i<20; i++)
        {
            int zahl = zufallsgenerator.nextInt(72);
            System.out.println(zahl);
        }
    }

Etwas ausführlicher:

import java.util.Random;
 
public class JavaApplication1
{
 
  public static void main(String[] args)
  {
    erstelleZufallsZahl();
  }
 
  public static void erstelleZufallsZahl()
  {
    Random zufallsgenerator = new Random();
 
    for (int i = 0; i < 20; i++)
    {
      int zahl = zufallsgenerator.nextInt(72);
      System.out.println(zahl);
    }
  }
}

Tags: Java, Code Snippets, Numbers, Random, Zufallszahlen

JEE und AJAX

0

12. März 2010

Exemplarischer Ablauf für die Verwendung von AJAX in JEE:

Servlet.java definiert die zulässigen Aktionen. Beim Auftreten einer Aktion im Servlet, wird die entsprechende ActionClass.java aufgerufen. Die ActionClass.java leitet dann über einen RequestDispatcher an die ajax.jsp weiter und definiert über Request Attributes (request.setAttribute(…)) die jeweiligen Template-Tags, die daraufhin in der ajax.jsp mit der Expression Language (@{…}) angezeigt werden können. Beim Aktivieren eines Links, der auf einen JavaScript-Befehl verweist, in der ajax.jsp, wird ein Request an das AjaxServlet.java gesendet. Das AjaxServlet.java generiert daraufhin aus den erhaltenen Daten einen neuen Output, der dann aktualisiert in der ajax.jsp dargestellt wird.

An dieser Stelle folgt ein Quelltext-Beispiel für ein AjaxServlet.java und eine ajax.jsp. Die ajax.jsp arbeitet mit MooTools 1.2.1 (mootools-1.2.1-core.js), welches als JavaScript eingebunden werden muss.

Quellcode:

ajax.jsp

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>Title</title>
    <script type="text/javascript" src="mootools-1.2.1-core.js"></script>
    <script type="text/javascript">
    function getSongs(moovar)
    {
        var songRequest = new Request.HTML(
            {
                url: "ajaxservlet",
                update: $('targetBox')
            }).get({'variable': moovar});
    }
    </script>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
    <body>
        <a href="#" onclick="getSongs('BAM!!!')">Shoot!</a>
        <div id="targetBox">Target</div>
    </body>
</html>

AjaxServlet.java

package controller.web;
 
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@WebServlet(name="AjaxServlet", urlPatterns={"/ajaxservlet"})
public class AjaxServlet extends HttpServlet
{
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try
        {
            out.println(request.getParameter("variable"));
        }
        finally
        {
            out.close();
        }
    }
 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException
    {
        processRequest(request, response);
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException
    {
        processRequest(request, response);
    }
 
    @Override
    public String getServletInfo()
    {
        return "Short description";
    }
}

Tags: Java, JavaScript, AJAX, JavaScript, JEE, JSP, MooTools, Servlets, XML

HashMap durchlaufen und auslesen

0

10. März 2010

Allgemein

In einer HashMap werden Daten nach dem Key-Value-Prinzip abgelegt. Die Keys sind eindeutig, d.h. jeder Key (Schlüssel) kommt nur einmal vor. Werden Elemente unter dem selben Key abgespeichert, so wird der bereits vorhandene Value überschrieben. Alle Werte werden unsortiert in der HashMap abgelegt, d.h. was zuerst reingelegt wird muss bei der Ausgabe nicht unbedingt auch zuerst wieder rauskommen. Das folgende Code-Beispiel stellt die Verhaltensweisen anschaulich dar:

Code:

import java.util.HashMap;
 
public class TestMain
{
  public static void main(String[] argv)
  {
    HashMap<string , String> map = new HashMap</string><string , String>();
 
    map.put("Vorname", "Lara");
    map.put("Vorname", "Ralf");
    map.put("Vorname", "Johanna");
    map.put("Vorname", "Benny");
    map.put("Nachname", "Neugebauer");
    map.put("Geburtsort", "Potsdam");
    map.put("Telefon", "123456");
 
    for(String key : map.keySet())
    {
      System.out.print("Key: " + key + " - ");
      System.out.print("Value: " + map.get(key) + "\n");
    }
  }
}
</string>

Ausgabe:

Key: Nachname - Value: Neugebauer
Key: Geburtsort - Value: Potsdam
Key: Telefon - Value: 123456
Key: Vorname - Value: Benny

Tags: Java, auslesen, durchlaufen, foreach, HashMap, iterieren, JEE, Load factor