radauer.com

Es gibt einige Themen, bei denen Google nicht immer die beste Lösung unter den ersten Treffern liefert. Will man zb mit Java einfach eine Datei kopieren, findet man mit Google unter den Suchbegriffen „copy file java“ in den ersten Treffern immer wieder Lösungen wie diese:

public static void copyFile(File srcFile, File destFile) throws IOException {
		FileReader in = new FileReader(srcFile);
		FileWriter out = new FileWriter(destFile);
		try {
			int c;
			while ((c = in.read()) != -1)
				out.write(c);
		} catch (IOException e) {
			throw e;
		}finally{
			if(in!= null) in.close();
			if(out!=null) out.close();
		}

	}

Seit Java 1.4 nicht mehr die optimalste Lösung, es wurden nämlich die Native IO Packages eingeführt. Diese bieten sehr schnelle Klassen um File Operationen durchzuführen:

Unser Copy Beispiel mit NIO:

public static void copyFileNio(File srcFile, File destFile) throws IOException {
		FileChannel inChannel = new	FileInputStream(srcFile).getChannel();
		FileChannel outChannel = new FileOutputStream(destFile).getChannel();
		try {
			inChannel.transferTo(0, inChannel.size(),outChannel);
		}
		catch (IOException e) {
			throw e;
		}
		finally {
			if (inChannel != null) inChannel.close();
			if (outChannel != null) outChannel.close();
		}
	}

Nach einigen Test mit einer ca 10 MB großen binären Datei, komm ich auf eine Geschwindigkeit von ca 3300 ms vs 200 ms, das kann sich wirklich sehen lassen.

Alleine diese Beispiel zeigt, dass es auf jeden Fall sich macht, sich mit NIO zu beschäftigen.

Eclipse bietet ja die einfache Möglichkeit, mittels F3 oder Strg+Klick direkt in die Implementierung einer Methode zu springen. Das Problem ist jedoch leider, das eigentlich nicht in die Implementierung sondern zur Deklaration gesprungen wird.

Nun kennen wir ja alle das Entwurfsprinzip, das man auf Schnittstellen programmieren soll und nicht auf Implementierungen… Nun kommt man mit F3 jedoch immer zum Interface, was während des Debuggens oder Entwickelns eigentlich selten das Ziel ist… ach ein PlugIn wäre toll: http://eclipse-tools.sourceforge.net/implementors mit Alt+F3 wird nun bei einer Implementierung sofort dort hin gesprungen.. gibt es mehrere Implementierungen, würde eine Strg+T auch reichen

sehr praktisch…

Das Exmatrikulations-Beispiel heißt so, weil wenn jemand dieses Beispiel im Rahmen eines IT Studiums nicht schafft oder sich die Lösung von jemanden kopieren muss, kann er sich gleich schon wieder vom Studium abmelden. Hier geht es um sehr grundlegende Operationen, die für weiterführende Themen in der Softwareentwicklung unbedingt verstanden werden müssen. Werte eingeben, Werte ausgeben, if, for, Arrays, usw… Dinge die in diesem Beispiel vorkommen, werden oft in den ersten zwei Wochen einer Grundlagen der Softwareentwicklung Vorlesung als Übung geben.

• Zahlen in ein Array einlesen
• Array ausgeben
• Minimum und Maximum suchen
• Summe bilden
• Palindrom Prüfung
• Sortieren
• Rückwärts ausgeben
• usw…

Also Vorsicht, mein Beispiel sollte nur als Hilfestellung im absoluten Notfall verwendet werden. Wer diese Themen nicht versteht, braucht sich mit der Materie gar nicht weiter beschäftigen…

(Jetzt hoff ich mal, dass ich keine Fehler drinnen hab ;-))

package beginner;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Beginner {
  
   private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

   public static void main(String[] args) {
      System.out.println(”Wie viele Zahlen wollen sie eingeben? “);
      int numbervalues = enterNumer();
     
      int[] values = new int[numbervalues];  
     
      for(int i = 0; i < values.length; i++){
         System.out.print((i+1)+”. Zahl eingeben: “);
         values[i] = enterNumer();
      }     
     
      System.out.println(”Werte Ausgeben:”);
      printArray(values);     
      System.out.println(”Summe: “+getSum(values));
      System.out.println(”Min: “+getMin(values));
      System.out.println(”Max: “+getMax(values));
     
      System.out.println(”\nUmgekehrt:”);
      printArray(reverse(values));
     
      System.out.println(”\nSortiert:”);
      printArray(sort(values));
     
      System.out.println(”\nIst Palindrom:”);
      System.out.println(isPalindrom(values));    
     
      System.out.println(”\nDiagramm:”);
      printDiagramm(values);
     
      int[] counts = countNumbers(values);
      System.out.println(”Counts:”);
      printArray(counts);
      printDiagramm(counts);

   }
  
   public static int getSum(int[] values){
      int sum =0;
      for(int i = 0; i<values.length;i++){
         sum +=values[i];
      }
      return sum;
   }
  
   public static int getMin(int[] values){
      int min = Integer.MAX_VALUE;
      for(int i = 0; i<values.length;i++){
        if(min>values[i])
           min = values[i];
      }
      return min;
   }
  
   public static int getMax(int[] values){
      int max = Integer.MIN_VALUE;
      for(int i = 0; i<values.length;i++){
        if(max<values[i])
           max = values[i];
      }
      return max;
   }
  
   public static int[] reverse(int[] values){
      int len = values.length;
     
      int[] newValues = new int[len];     
     
      for(int i = 0; i<len;i++){
         newValues[i] = values[len-1-i];
      }
      return newValues;
     
   }
  
   public static void printArray(int[] values){
      System.out.println(values.length +” Werte:”);
      for(int i = 0; i<values.length;i++){
         System.out.println(”\t”+(i)+”. “+values[i]);
      }
   }
  
   public static void printDiagramm(int[] values){
      for(int i = 0; i<values.length;i++){
         System.out.print(i+”\t”);
         for(int j=0; j<values[i];j++)
            System.out.print(”X”);
         System.out.println();
      }
   }
  
   public static int[] countNumbers(int[] values){
      int[] counts = new int[getMax(values)+1];
      for(int i=0; i<values.length;i++){
         counts[values[i]]++;        
      }
      return counts;     
   }
  
  
   public static int[] sort(int[] values){ //bubbble sort
      int[] newArray = values.clone();
     
      boolean ready=false;

      while(ready==false){
         //ist ist noch nicht sortiert! also false
         ready=true;
         for(int i=0;i<newArray.length-1;i++){

            if(newArray[i]>newArray[i+1]){
               int temp=newArray[i+1];
               newArray[i+1]=newArray[i];
               newArray[i]=temp;
               ready=false;
            }
         }
      }
      return newArray;
   }
  
   public static boolean isPalindrom(int[] values){
      for(int i = 0; i < values.length/2; i++){
         if(values[i]!=values[values.length-i-1])
            return false;
      }
     
      return true;
   }  
  
  
   public static int enterNumer(){
      while(true){
         try {
            return Integer.parseInt(in.readLine());
         } catch (Exception e) {
            System.out.println(”Das war keine Zahl”);
         }
      }     
   }

}

Vor kurzer Zeit, hatte ich das Problem, dass ich mit Java unter Windows die Positionen aller offenen Fenster ermitteln wollte. Ohne eine kleine native Spielerei hat es leider nicht funktioniert. Hier ist meine Lösung mit JNA. Neben der jna.jar hab ich auch noch die Samples eingebunden, da hier schon einige Dinge vorbereitet sind. Leider sind in den Klassen der Samples nicht alle Methoden die in der MSDN zu finden sind, vorhanden. Aus diesem Grund habe ich die User32 gepatched….
Ich muss sagen, dass JNA eine gewisse Herausforderung darstellt, aber sich der Aufwand doch lohnt.

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;

import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.examples.win32.GDI32;
import com.sun.jna.examples.win32.User32;
import com.sun.jna.examples.win32.GDI32.RECT;
import com.sun.jna.examples.win32.User32.WNDENUMPROC;
import com.sun.jna.examples.win32.W32API.HWND;

public class WindowObserver {

	private static ArrayList fenster;

	public static void main(String[] args) {
		ArrayList fenster = WindowObserver.getOpenWindows();
		for(Fenster f: fenster)
			System.out.println(f.getName()+” “+f.getRectangle());
	}

	public static ArrayList getOpenWindows() {
		fenster = new ArrayList();
		User32B user32 = User32B.INSTANCE;
		user32.EnumWindows(new WNDENUMPROC() {

			public boolean callback(HWND hwnd, Pointer arg1) {
				User32B user32 = User32B.INSTANCE;
				if (user32.IsWindowVisible(hwnd)) {
					byte[] name = new byte[512];
					user32.GetWindowText(hwnd, name, name.length);
					Fenster f = new Fenster();
					f.setName(byte2String(name));
					RECT r = new GDI32.RECT();
					user32.GetWindowRect(hwnd, r);
					f.setRectangle(r.toRectangle());
					fenster.add(f);
				}
				return true;
			}
		}, null);
		return fenster;

	}

	public static String byte2String(byte[] array) {
		try {
			return new String(array, “UTF-16LE”).trim();
		} catch (UnsupportedEncodingException e) {
			return null;
		}
	}

	public interface User32B extends User32 {

		User32B INSTANCE = (User32B) Native.loadLibrary(”user32″,
				User32B.class, DEFAULT_OPTIONS);

		boolean IsWindowVisible(HWND hWnd);

	}
}

import java.awt.Rectangle;

public class Fenster {
	String name;
	Rectangle rectangle;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Rectangle getRectangle() {
		return rectangle;
	}

	public void setRectangle(Rectangle rectangle) {
		this.rectangle = rectangle;
	}
}

Oft sind es Kleinigkeiten die eine edle saubere Homepage von einer billigen 0815 Seite unterscheiden. Feine Linien um einen unaufdringlichen 3d Effekt zu erzeugen oder sanfte Verläufe die Flächen einfach natürlicher aussehen lassen.
Zu diesem Thema gibt es einen ausgezeichneten Artikel auf  psdtuts.com

Oft kommt die Frage, wie man aus einer bestehenden ArrayList doppelte einträge entfernt. Mit Java Baordmitteln ist das eine einfache Angelegenheit.

ArrayList<String> values = new ArrayList<String>();
    values.add("AAA");
    values.add("BBB");
    values.add("CCC");
    values.add("AAA");
   
    values = new ArrayList<String>(new HashSet<String>(values));
   
    for(String s: values)
       System.out.println(s);

eigentlich ein Einzeiler… aufgrund der Werte ein Set erstellen und aufgrund dieses Sets wieder zurück zur List.. fertig!

Viele Lehrer geben gerne einen Taschenrechner als Anfänger Beispiel… ich halte eigentlich gar nichts da davon.

Ein sinnvoller Taschenrechner ist eine ziemliche Herausforderung… parsen, Formeln, Polymorphie, Command Pattern, Strategy Pattern… einen Taschenrechner sollte man einem Anfänger nicht aufgeben… die Arbeit sollte man lieber javascript erledigen lassen:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class Rechner {
 
 public static void main(String[] args) throws IOException {
  BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
  
  System.out.print(”Formel eingeben: “);
  String formel = r.readLine();
         ScriptEngineManager factory = new ScriptEngineManager();
         ScriptEngine engine = factory.getEngineByName(”JavaScript”);
          
        
         try {
    engine.eval(”var v = eval(’”+formel+”‘)”);
    double b =(Double) engine.get(”v”);

          System.out.println(”Ergebnis: “+b);
   } catch (ScriptException e) {
    System.out.println(”Das war wohl nix”);
    e.printStackTrace();
   }       
        
     }
 }

In diversen Java Foren tauchen immer Wieder Fragen zum Thema Polymorphie und Interfaces auf. Ein sehr einfaches kurzes Beispiel, soll das Prinzip verdeutlichen.

import java.util.ArrayList;
public class Polymorphie  {
  
   public static void main(String[] args) {
     ArrayList<Tier> tiere = new ArrayList<Tier>();
     tiere.add(new Katze());
     tiere.add(new Hund());
     tiere.add(new Hund());
     tiere.add(new Katze());    
     for(Tier t: tiere)
        t.gibLaut();     
   } 
}

interface Tier{
   public void gibLaut();
}

class Hund implements Tier{
   public void gibLaut() {
      System.out.println(”wau wau”);        
   }     
}

class Katze implements Tier{
   public void gibLaut() {
      System.out.println(”mia mia”);        
   }     
}

Webdesign benötigt oft sehr viel kreative Energie. Schöne frische Entwürfe zu liefern, kostet viel Anstrengung und ist auch nicht immer möglich Wenn ich programmiere, kann ich noch so müde sein, es kommt eigentlich immer was Sinnvolles raus. Beim Entwerfen ist das schwieriger. Die Motivation und Stimmung muss einfach passen. Was mich motiviert und mir vor allem Ideen bringt sind Template Seiten. Wenn ich auf guten Template Seiten herum surfe, bekomm ich sofort Lust selber einen neuen Entwürfe zu machen. Man erhält Ideen, sieht neue Effekte die man gerne verwenden möchte und kann sich Farbschemen abkupfern.

Seiten auf denen ich mir zur Zeit gerne Ideen hole sind:

• www.freelayouts.com
• www.freecsstemplates.org
• www.oswd.org

Was ich besonders auf http://www.freelayouts.com interessant finde ist, wie sich die Entwürfe im Laufe der Zeit verändert haben. Auf den ersten Seiten findet man wirklich grauenhafte Dinge, die aber meinen Ersten Arbeiten um dem was zu dieser Zeit üblich war, ziemlich nahe kommt.

Im Netzt gibt es Hunderte Seiten mit Tutorials für alle möglichen Themen. Besonders im Bereich Photoshop ist die Auswahl fast erdrückend. Darunter sind oftmals sehr gute enthalten, jedoch findet man aber auch viel zu oft Tutorials die es einfach übertreiben. Dies liegt wahrscheinlich daran, dass die gezeigten Effekte übertrieben werden, damit man sie auch wirklich sieht. Im Bereich Webdesign ist aber weniger oftmals mehr. Schlichte einfache Verläufe oder kaum wahrzunehmende Schatten und Rahmen sehen oftmals besser aus als fette bunte Effekt.

Zwei Tuttrial Seiten die das beherzigen und wirklich gute Tutorials bieten sind:

• www.psdtuts.com
• www.nettuts.com

Ich schau dort gerne vorbei und hohl mir Ideen.