Java List zufällig sortieren / mischen / shufflen

Posted: Oktober 25th, 2011 | Filed under: Java, Programmieren | Tags: , , , , , , , , , , | 1 Comment »

Schon oft in meinem Programmierer-Dasein habe ich eine List oder eine ArrayList in Java zufällig mischen müssen. Das ganze geht ziemlich einfach. Die Klasse Collections bietet uns die Methode shuffle an. Folgendes Code-Beispiel zeigt wie:

import java.util.ArrayList;
import java.util.Collections;

public class ListZufaelligSortieren {
  
  public static void main(String[] args) {
    
    ArrayList<String> namensListe = new ArrayList<String>();
    
    String name1 = new String("Peter");
    String name2 = new String("Paul");
    String name3 = new String("Maria");
    String name4 = new String("Otto");
    
    namensListe.add(name1);
    namensListe.add(name2);
    namensListe.add(name3);
    namensListe.add(name4);
    
    // List durcheinander mischen
    Collections.shuffle(namensListe);
        
    for(String name : namensListe){
      System.out.print(name);
      System.out.print(" ");
    }
    // Ausgabe: Maria Paul Otto Peter
  }
}

Java: Reguläre Ausdrücke

Posted: August 1st, 2011 | Filed under: Java, Programmieren, Tutorials | Tags: , , , , , , , | No Comments »

Oft will man einen bestimmten Text nach gewissen Kriterien parsen und analysieren. Dafür eignen sich Reguläre Ausdrücke bis zu einem gewissen Grad hervorragend. Ein Regulärer Ausdruck ist eine syntaktische Beschreibung einer Zeichenkette die zum Beispiel in einem Text, einfach oder mehrfach, vorhanden sein kann. In diesem kleinen Code-Beispiel möchte ich kurz erklären wie ihr einen Regulären Ausdruck in Java anwenden könnt.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegularExpression {

  public static void main(String[] args) {
    // Text zum Parsen
    String text = new String("Das derzeit gebräuchlichste Zahlensystem ist"
        + " das Dezimalsystem mit den Ziffern 1, 2, 3, 4, 5, 6, "
        + "7, 8, 9 und 0.");
   
    // Regulärer Ausdruck wird in ein Pattern kompiliert
    // [0-9]+ beschreibt alle Zahlen mit einer oder mehr Stellen
    Pattern pattern = Pattern.compile("[0-9]+");

    // Ein Matcher wird mit dem Pattern erzeugt
    Matcher matcher = pattern.matcher(text);

    // Matcher findet den nächsten Treffer
    // solange bis es keine Treffer mehr gibt, dann
    // wird die Schleife abgebrochen.
    while (matcher.find()) {
      System.out.print(matcher.group() + " ");
    }
   
    // Ausgabe: 1 2 3 4 5 6 7 8 9 0
  }
}

Vor einiger Zeit habe ich ein Programm geschrieben mit dem ihr Regulärer Ausdrücke austesten könnt. Es nennt sich Java Regular Expression Tester.

image


Java Runden und genaues Rechnen

Posted: Juli 29th, 2011 | Filed under: Java, Programmieren, Tutorials | Tags: , , , , | No Comments »

Will man in Java ausgerechnete Werte in einer GUI oder auf der Konsole darstellen hat man oft das Problem, dass man sehr lange Nachkommastellen erhält. Addiert man zum Beispiel zehn mal in einer Schleife den Wert 0.1 auf eine Variable die Initial 0 war so erhält man nicht wie erwartet als Ergebnis 1, sondern "0.9999999999999999".

double x = 0; 
for (int i = 0; i < 10; i++) { 
   x = x + 0.1; 

System.out.println(x); 
// Ausgabe: 0.9999999999999999

imageKein Anwender will solche Zahlen auslesen müssen. Leider kommt es beim Rechnen mit Double-Werten immer wieder zu diesem Problem. Dies liegt einfach daran, dass in Java zum Beispiel ein Double-Wert immer nur 64-Bit hat, also es rein logisch gar nicht möglich ist alle Zahlen "abzudecken". Deswegen wird lediglich eine approximative Darstellung einer reellen Zahl durch Double-Werte ermöglicht. Mehr dazu unter http://de.wikipedia.org/wiki/Gleitkommazahl. Der Einsatz von variabel großen Zahlen ist die Lösung für diese Probleme. Java bietet von Haus aus eine solche Klasse an: BigDecimal. Mit ihr ist es möglich mit beliebig großen oder beliebig kleinen Zahlen mit beliebig viel Nachkommastellen zu rechnen. Gerade für das wissenschaftliche Arbeiten zum Beispiel in der Physik wenn es auf Genauigkeit ankommt wäre es natürlich fatal mit Double-Werten zu Rechnen, die bezogen auf die Masse eines Elektrons katastrophale Ungenauigkeiten aufweisen würde.

BigDecimal bietet zusätzlich die Funktion an Zahlen nach mehreren Kriterien zu runden. Dies nutzen wir aus um unseren "vermurksten" Double-Wert zu korrigieren.

import java.math.BigDecimal;
import java.math.RoundingMode;

public class RundenInJava {
  public static void main(String[] args) {
    double x = 0;
    for (int i = 0; i < 10; i++) {
      x = x + 0.1;
    }
    System.out.println(x);
    // Ausgabe: 0.9999999999999999

    BigDecimal xGerundet = new BigDecimal(x);

    // Runden auf 2 Nachkommastellen zur nähsten
    // Nachbarzahl, falls beide Nachbarn gleichweit
    // entfernt sind wird hochgerundet!
    System.out.println((xGerundet.setScale(2, RoundingMode.HALF_UP)).toString());
    // Ausgabe: 1.00
  }
}

BigDecimal bietet natürlich auch alle nötigen Grundrechenarten, anhand von Methoden an, um damit rechnen zu können.


Java Chat Tutorial

Posted: Juni 21st, 2011 | Filed under: Java, Programmieren | Tags: , , , , , , , , , , | 1 Comment »

imageAls ich meinen Netzwerk-Chat jLanChat programmiert habe, musste ich mich intensiv mit diesem Thema beschäftigen. Herkömmlicherweise verwendet man zum versenden von Nachrichten das sogenannte Client-Server Prinzip. Will zum Beispiel PC1 eine Nachricht an PC2 senden so muss PC2 einen Socket öffnen mit dem sich PC1 dann verbindet und über diesen Socket die Nachricht sendet. Will man nun eine Nachrichtenleitung mit mehren PCs aufbauen so benötigt man schnell einen Server, mit dem sich dann alle Clients verbinden und über diesen dann kommunizieren.

Wenn wir die Kommunikation über Multicast (Punkt zu Gruppe) tätigen brauchen wir keinen Server. Denn fast alle Router/Switches unterstützen Multicast.

Alle Teilnehmer verbinden sich mit dem Switch/Router und treten einer Gruppe, in Form einer IP-Adresse und eines Ports (z.B.: 230.0.0.1:4447), bei. Bekommt der Switch/Router jetzt eine Nachricht eines Clients mit der Gruppen-Adresse als Zieladresse vervielfältigt der Switch/Router diese Nachricht und sendet sie an alle die der Gruppe beigetreten sind, auch an den der die Nachricht abgesendet hat. So kann man zum Beispiel einen serverlosen Chat aufbauen. Wenn man’s genau nimmt übernimmt der Switch/Router jetzt unsere Serverfunktion.

Um das Ganze in JAVA zu realisieren muss man folgende Bibliothek ins Projekt einbinden: http://commons.apache.org/lang/

Hier unser Beispiel, Es gibt eine Sender-Klasse und eine Empfänger-Klasse:

Sender

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;


public class Sender {

  public static void main(String[] args) {
    // Netzwerk-Gruppe
    String NETWORK_GROUP = "230.0.0.1";
    // Netzwerk-Gruppen Port
    int NETWORK_GROUP_PORT = 4447;
    // Client-Port
    int CLIENT_MULTICAST_PORT = 4446;
   
    // Nachrichten-Codierung
    String TEXT_ENCODING = "UTF8";
   
    try {
      MulticastSocket socket =  new MulticastSocket(CLIENT_MULTICAST_PORT);
      byte[] message = "Hallo Welt".getBytes(TEXT_ENCODING);
     
      // Nachricht an Gruppe senden
      socket.send(new DatagramPacket(message, message.length , InetAddress.getByName(NETWORK_GROUP) ,
NETWORK_GROUP_PORT
));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

 

Empfänger

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;


public class Receiver {

  public static void main(String[] args) {
    // Netzwerk-Gruppe
    String NETWORK_GROUP = "230.0.0.1";
    // Netzwerk-Gruppen Port
    int NETWORK_GROUP_PORT = 4447;
   
    // Nachrichten-Codierung
    String TEXT_ENCODING = "UTF8";
   
    InetAddress group;
    MulticastSocket socket;
 
    try {
      // Gruppe anlegen
      group = InetAddress.getByName(NETWORK_GROUP);
      socket = new MulticastSocket(NETWORK_GROUP_PORT);
     
      // Gruppe beitreten
      socket.joinGroup(group);
     
      byte[] bytes = new byte[65536];
      DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
     
      while(true){
        // Warten auf Nachricht
        socket.receive(packet);
        String message = new String(packet.getData(),0,packet.getLength(), TEXT_ENCODING);
        System.out.println(message);
      }   
     
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

 

Ich hoffe ich konnte dem ein oder anderen damit helfen.

Das ganze könnt ihr euch als Eclipse Projekt hier herunterladen (inklusive Bibliotheken): Eclipse Projekt – Tutorial Net Send


Java: Wav-Datei abspielen in einem Applet ohne Sicherheitsabfrage

Posted: April 24th, 2011 | Filed under: Java, Programmieren | Tags: , , , , , | No Comments »

Will man in einem Java Applet eine WAVDatei abspielen ohne auf die lokale Festplatte zugreifen zu müssen, also ohne dass der Benutzer eine Sicherheitsfrage gestellt bekommt, muss man die Applet eigene Methode getAudioClip verwenden. Leider funktioniert diese nicht für MP3s oder OGG.

Beispiel Applet

image

Applet-Quellcode

import java.applet.AudioClip;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.MalformedURLException;
import java.net.URL;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class PlayWav extends javax.swing.JApplet {

   public static JApplet playWav;

   private JButton playButton;
   private JButton stopButton;

   // Audio
   private AudioClip audioClip;

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            JFrame frame = new JFrame();
            PlayWav inst = new PlayWav();
            frame.getContentPane().add(inst);
            ((JComponent) frame.getContentPane()).setPreferredSize(inst
                  .getSize());
            frame.pack();
            frame.setVisible(true);
         }
      });

   }

   public PlayWav() {
      super();
      initGUI();
   }

   private void initGUI() {
      try {
         playWav = this;
         BorderLayout thisLayout = new BorderLayout();
         getContentPane().setLayout(thisLayout);
         {
            playButton = new JButton();
            getContentPane().add(playButton, BorderLayout.CENTER);
            playButton.setText("play");

            // Play
            // Wav Datei online abspielen mittels der Applet-Methode
            // getAudioClip.
            playButton.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent evt) {
                  try {
                     // alarm.wav liegt in
                     // http://blog.mynotiz.de/howTo/PlayWav/alarm.wav
                     URL url = new URL(getDocumentBase().toString());
                     audioClip = playWav.getAudioClip(url, "alarm.wav");
                  } catch (MalformedURLException e) {
                     e.printStackTrace();
                  }

                  // Play normal
                  audioClip.play();

                  // Play in loop
                  // audioClip.loop();
               }
            });
         }
         {
            stopButton = new JButton();
            getContentPane().add(stopButton, BorderLayout.SOUTH);
            stopButton.setText("stop");

            // Stop
            stopButton.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent evt) {
                  audioClip.stop();
               }
            });
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

HTML-Quellcode

<applet style="border: 1px solid black;" code="PlayWav.class" archive="playWav.jar"> Ihr Browser unterstütz keine Java Applets! </applet>

 

Wie ihr aus eurem Code ein Applet erzeugt erfahrt ihr hier.

FTP-Ordner

Im FTP-Verzeichnis sieht das ganze dann wie folgt aus.

image