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

public class Kino {

 ArrayList<Integer> platz = new ArrayList<Integer>();
 static int platzReihe = 50;
 int startplatz, endplatz;

 public Kino(int Kategorie) {
 platz.add(0); //Fixt den Bug, da sonst -1 ausgabe bei BinarySearch
 switch (Kategorie) {
 case 1:    startplatz = 1;  break; // Reihe A
 case 2: startplatz = 100; break; // Reihe B
 case 3:    startplatz = 200; break; // Reihe C
 case 4:    startplatz = 300; break; // Reihe D
 }
 endplatz = startplatz + platzReihe;
 }

 public boolean checkPlatz(int anzahlPlaetze) {
 int tempInt = 0;
 for (int i = startplatz; i < endplatz; i++) {
 if (istFrei(i)) {
 tempInt++;
 } else {
 tempInt = 0;
 }

 if (tempInt == anzahlPlaetze) {
 return true;
 }

 }
 return false;
 }

 /**
 *
 * @param platznummer
 * @return true, wenn der Platz frei ist.
 */

 public boolean istFrei(int platznummer) {
 if (! (platznummer < startplatz) || (platznummer > endplatz) ) { // prüfe ob platznumer in Range
 Collections.sort(platz);
 return (Integer.valueOf(Collections.binarySearch(platz, platznummer)) <= 0) ? true : false;
 }
 return false;
 }

 public boolean addPlatz(int Platznummer, int Kategorie) {
 if (istFrei(Platznummer)) {
 platz.add(Platznummer);
 return true;
 } else {
 return false;
 }
 }

 public boolean deletePlatz(int platznummer) {
 Collections.sort(platz);
 platz.remove( Collections.binarySearch(platz, platznummer) );
 return true;
 }

 public int hoechstePlatznummer(int Kategorie) {
 int z = 0;
 for (int i = endplatz; i > startplatz; i--) {
 if (Collections.binarySearch(platz, i) > 0);
 z = platz.get( Collections.binarySearch(platz, i) );
 System.out.println("Z!" + z);

 }

 return z;
 }

 public static void main(String args[]) {
 Kino test = new Kino(2); // A = 1, B = 2, C = 3, D = 4

 test.addPlatz(104, 2);
 test.addPlatz(108, 2);
 test.addPlatz(144, 2);

 if (test.checkPlatz(44) == true) {
 System.out.println("Jep, frei.");
 } else {
 System.out.println("keiner frei");
 }

 test.hoechstePlatznummer(2);

 }
}

Nun, generische Klassen klingt auf Anhieb kompliziert, sind jedoch, mit ein bisschen Übung eine leichte und sehr sinnvolle Methode um Schablonen, bzw. Templates in Java zu erstellen. Sinn hierbei ist es, dass kein Code dupliziert werden muss, sofern es mehrere Datentypen gibt. Unten genanntes Beispiel zeigt, wie Simpel es gehen kann ein Template zu erstellen.

public class Ausgabe <T> { // <T> deklariert eine Templatevariable mit dem Namen T ohne Datentyp.
 public Ausgabe() {}

 private T out;

 public void setOut(T val) // Weiterhin wird mit dem "Leeren Datentyp" gearbeitet.
 {
 out = val;
 }
 public T giveOut() { // Hier wird der Datentyp ausgegeben, der vorher in dem instanziernden Objekt erstellt wurde
 return out;
 }

public static void main(String[] args) {

 Ausgabe<String> f = new Ausgabe<String>(); // Legt ein Objekt mit Dem Datentyp String an
 f.setOut("test");
 System.out.println( f.giveOut() );

 Ausgabe<Integer> a = new Ausgabe<Integer>(); // Legt ein Objekt mit dem Datentyp Integer an
 a.setOut(5);
 System.out.println( a.giveOut() );
 }

}

Wie ihr seht ist das ganze kein Teufelswerk und kann super einfach umgesetzt werden. Natürlich kann man generische Klassen auf beschränken auf verschiedene Datentypen. Das jedoch zeige ich im nächsten Tutorial.

Wie lese ich die MAC-Adresse in Java aus? Dies ist ganz einfach und funktioniert sowohl unter Linux als auch unter Windows und MAC OS X.

Zuerst müssen wir durch die NIC Adapter durchloopen um festzustellen welcher kein LOOPBACK ist. Der LOOPBACK Adapter ist der eigene PC und besitzt keine MAC-Adresse.
(weiterlesen…)

Wie ihr bestimmt wisst, besitzt Java leider nicht die möglichkeit Headerfiles wie beispielsweiße in C, C++ pder C# zu inkludieren.

Für gewöhnlich werden in Headerfiles Konfigurationsdaten angelegt.

Um sowas dennoch in Java zu realisieren, können sie intern auf Ressourcen im eigenen .JAR Paket zugreifen.
Ebenso ist es jedoch auch möglich eine Klasse hierfür zu schreiben, welches sinnvoll mit einem SingleTon Pattern einmal instanziert wird. In dieser Klasse können sie entweder “final static” Variablen deklarieren, oder sie arbeiten mit Settern und Gettern wie folgendes Beispiel zeigt.
(weiterlesen…)

Dateien verschieben

Dateien über Java zu verschieben ist relativ einfach, nämlich zum Beispiel so:

try {
File quellDatei = new File("/meine/quelledatei.txt");
File zielDatei = new File("/meine/zieldatei.txt");
quellDatei.renameTo(zielDatei);
} catch (Exception e) {
e.printStackTrace();
}

_______________________________

Dateien kopieren

Anders schaut es mit Kopieren von Dateien in andere Ordner aus. Hier hat man zwar mehrere Möglichkeiten der Umsetzung, es ist aber auch mit mehr Schreibaufwand verbunden.

Byteweise Einlesen macht in den wenigsten fällen Sinn, es kommt meistens ein Buffer zum Einsatz.
Ein Beispiel findet man hier: http://www.tutorials.de/forum/java/153779-dateien-kopieren.html

Eine performantere Lösung wäre natürlich über System.exec(…) Batch-Befehle per Java abzusetzen, man verspielt dabei aber den Vorteil der Plattformunabhängigkeit.

Eine echte Alternative zu Batch bieten die java.nio Klassen. Kopierprozesse per NIO über

transfer(inputChannel, outputChannel,...)

kann vom Betriebssystem (falls es das unterstützt) noch intern optimiert werden und kommen damit sehr nah an die Geschwindigkeit von Batchverarbeitung ran.

Hier ein Beispiel einer universellen FileCopy Klasse:

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.ByteChannel;
import java.nio.channels.FileChannel;
public class FileCopy {
long chunckSizeInBytes;
boolean verbose;
public FileCopy(){
this.chunckSizeInBytes = 1024 * 1024; //Standard: Buffer 1MB
this.verbose = false; //Statistics about Copy Process
}
public FileCopy(boolean verbose){
this.chunckSizeInBytes = 1024 * 1024; //Standard: Buffer 1MB
this.verbose = verbose; //Statistics about Copy Process
}
public FileCopy(long chunckSizeInBytes){
this.chunckSizeInBytes = chunckSizeInBytes; //Custom Buffer (Bytes)
this.verbose = false; //Statistics about Copy Process
}
public FileCopy(long chunckSizeInBytes, boolean verbose){
this.chunckSizeInBytes = chunckSizeInBytes; //Custom Buffer (Bytes)
this.verbose = verbose; //Statistics about Copy Process
}
public void copy(File source, File destination) {
try {
FileInputStream fileInputStream = new FileInputStream(source);
FileOutputStream fileOutputStream = new FileOutputStream(destination);
FileChannel inputChannel = fileInputStream.getChannel();
FileChannel outputChannel = fileOutputStream.getChannel();
transfer(inputChannel, outputChannel, source.length(), false);
fileInputStream.close();
fileOutputStream.close();
destination.setLastModified(source.lastModified());
} catch (Exception e) {
e.printStackTrace();
}
}
public void transfer(FileChannel fileChannel, ByteChannel byteChannel, long lengthInBytes, boolean verbose)
throws IOException {
long overallBytesTransfered = 0L;
long time = -System.currentTimeMillis();
while (overallBytesTransfered < lengthInBytes) {
long bytesTransfered = 0L;
bytesTransfered = fileChannel.transferTo(overallBytesTransfered, Math.min(chunckSizeInBytes, lengthInBytes - overallBytesTransfered), byteChannel);
overallBytesTransfered += bytesTransfered;
if (verbose) {
System.out.println("overall bytes transfered: " + overallBytesTransfered + " progress " + (Math.round(overallBytesTransfered / ((double) lengthInBytes) * 100.0)) + "%");
}
}
time += System.currentTimeMillis();
if (verbose) {
System.out.println("Transfered: " + overallBytesTransfered + " bytes in: " + (time / 1000) + " s -> " + (overallBytesTransfered / 1024.0) / (time / 1000.0) + " kbytes/s");
}
}
}

Zu beachten ist dabei, dass der Zielordner schon zur Laufzeit bestehen muss beziehungsweise vorher erstellt wird.

Das NIO Beispiel stammt von folgender Seite:
http://www.tutorials.de/forum/java/328830-schnell-grosse-dateien-kopieren-mit-java-nio.html
Es wurde allerdings noch etwas umgeschrieben, dass es als universelle Klasse dient. Außerdem wurde ein Fehler in der Bufferbearbeitung behoben, daher ist von der Verwendung des Originals abzuraten.

Um ein Objekt nur einmal zu instanzieren und von jeder Klasse auf das gleiche Objekt zuzugreifen, wird SingleTon genutzt.

Die Problemlösung ist einfach und sauber. Um ein Objekt nur einmal zu instanzieren, wird geprüft ob das Objekt bereits instanziert wurde und falls es bereits instanziert wurde, wird das Objekt zurück gegeben. Falls das Projekt noch nicht instanziert wurde, wird ein neues Objekt angelegt.

Folgendes Codebeispiel liefert in verschiedenen Klassen immer das gleiche Objekt zurück:

(weiterlesen…)

Java wird prinzipiel in einer Sandbox im Web ausgeliefert, um Schadcode zu unterdrücken. Leider ist diese Sandbox manchmal sehr unpraktisch, wenn es zum Beispiel darum geht Files über ein Applet zu laden und auszuführen. Ebenso ist es sehr wichtig die Sandbox zu umgehen, falls man Netzwerkanwendungen erstellen will, welche über den aufgerufenen Webhost hinaus gehen. (weiterlesen…)

Mithilfe der Klasse java.net.NetworkInterface ist es möglich plattformunabhängig Informationen der Netzwerkkarte auszulesen. Im folgenden Beispiel wird der Netzwerkadapter Name, so wie die dazu gehörige IP-Adresse ausgelesen. Die Ausgabe könnte zum beispiel diese sein:
(weiterlesen…)

Mithilfe des JDBC ist es möglich MySQL Verbindungen aufzubauen und Informationen zu übermitteln und abzufragen. Wie das Beispiel zeigt, senden wir ein einfaches Query an die Datenbank und fragen dieses dann ab. Selbstverständlich ist MySQL weitaus komplexer, worauf sich die Sektion “SQL” spezialisiert.

Um ein einfaches Query abzusenden kann folgende Klasse verwendet werden:

(weiterlesen…)

In Java gibt es für die Datenbankverbindung die Klasse jdbc, welche für Java Database Connectivity steht. Mithilfe dieser Klasse ist es möglich zu einer vielzahl unterschiedlichen Datenbanken zu verbinden und zu verwalten. In folgenden Beispielen wird gezeigt, wie man eine Verbindung zu Oracle und zu MySQL herstellt.

(weiterlesen…)