Reguläre Ausdrücke und Gruppen

Um bei einem Pattern wie Pattern pattern = Pattern.compile(“(In)|(present|the)“); herauszufinden, ob das gefundene Wort aus der ersten Gruppe („In“) oder aus der zweiten Gruppe („present|the“) kommt, lässt sich group(int) verwenden.

Pattern pattern = Pattern.compile( "(In)|(present|the)" );
String string = "In the present study the cytotoxic activity of aloin";   Matcher matcher = pattern.matcher( string );   while ( matcher.find() )
{
 System.out.println( "Found: " + matcher.group() );   if ( matcher.group(1) != null )
  System.out.println( "\tGruppe *1*" );
 else if ( matcher.group(2) != null )
  System.out.println( "\tGruppe *2*" );   System.out.println( "\tStart At: " + matcher.start() );
 System.out.println( "\tEnd At: " + matcher.end() );
 System.out.println( "\tGroupID: " + "???" );

}

BIG_ENDIAN oder LITTLE_ENDIAN?

In verschiedenen Programmen wird zwischen BIG_ENDIAN und LITTLE_ENDIAN unterschieden. Unter Java wird alles als in BIG_ENDIAN gespeichert. Sollen die Bytes umgedreht werden, reicht folgendes:

public class Swap
{
  public final static int swapInt( int v )
  {  
    return  (v >>> 24) | (v << 24) | ((v << 8) & 0x00FF0000) | ((v >> 8) & 0x0000FF00);
  }   public static void main( Strings[] args )
  {
    //  before 0x01020304  
    //    after  0x04030201    int v = 0x01020304;  
    System.out.println("before : 0x" + Integer.toString(v,16));  
    System.out.println("after  : 0x" + Ineger.toString(swapInt(v),16));  
  }  
}

Um herauszufinden, ob BIG_ENDIAN oder LITTLE_ENDIAN darunterliegt, würde ich die Architektur aus den Properties auslesen und dann abschätzen.

Wie kann man eine neue JVM aus einem Java-Programm starten?

Man kann eine neue VM aus einem Java-Programm starten, und der dabei natürlich eine Main-Klasse und alle möglichen Parameter mitgeben. Alle anderen Dienstprogramme, wie javac, jar, sind reine Java-Programme, die man auch anders nutzen kann, aber für das Starten einer JVM ist das mit ProcessBuilder oder exec() am Einfachsten.

ProcessBuilder builder = new ProcessBuilder( "java", "Sample" );
Map<String, String> env= builder.environment();
env.put( "V", "sample" );
Process process = builder.start();

Wenn das Programm das folgende ist:

public class Sample {
 public static void main( String[] args ) {
  System.out.println( System.getenv("V") );
 }
}

Für Java 5 war mal eine Isolation API (Beschreibung) geplant, aber daraus wurde nix.

Wie kann man die Bildschirmausgabe in ein Textfeld umleiten

Folgendes genügt, um die Ausgabe in ein Fenster umzuleiten; es referenziert die Variable ta ein TextArea-Objekt:

PrintStream p = new PrintStream( 
  new OutputStream() { 
    public void write( int b ) { 
      ta.append( (char)b ); 
    } 
  } 
);   System.setErr( p ); 
System.setOut( p );

Wie kann man ein proportionales Vergrößern eines Fensters erreichen?

Wenn wir auf die Größenveränderung eines Fensters achten wollen, so müssen wir mit addComponentListener() einen Listener an das Fenster hängen, der auf die Veränderung reagiert. Wir implementieren eine Klasse, die sich von ComponentAdapter ableitet und überschreiben componentResized(). Wenn wir nur das Frame-Objekt als Ereignishorcher mit dem ComponentListener verbinden, ist klar, wer der Auslöser war. Mit getComponent() auf dem Ereignisobjekt bekommen wir genau diesen Frame. Nun ist es Sache des Algorithmus, wie mit der Größenveränderung zu verfahren ist. Eine Möglichkeit ist, die aktuelle Größe mittels getSize() auszulesen und dann das Minimum aus Höhe und Breite wieder mit setSize() zu setzen.

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*;   public class ResizeTheFrame extends JFrame 
{ 
  public ResizeTheFrame() 
  { 
    setSize( 200, 200 ); 
    setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 
    setVisible( true ); 
  }   public static void main( String[] args ) 
  { 
    new ResizeTheFrame().addComponentListener( new ResizeEvent() ); 
  }   static class ResizeEvent extends ComponentAdapter 
  { 
    @Override 
    public void componentResized( ComponentEvent event ) 
    { 
      if ( event.getID() == ComponentEvent.COMPONENT_RESIZED ) 
      { 
        JFrame f = (JFrame) event.getComponent(); 
        Dimension d = f.getSize(); 
        int size = Math.min( d.width, d.height ); 
        f.setSize( size, size ); 
      } 
    } 
  } 
}

Wie kann man für die Hilfe mit F1 soll eine Aktion auslösen?

frame.getRootPane().getInputMap( JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0), "HELP" );
frame.getRootPane().getActionMap().put( "HELP", new AbstractAction()
{
  @Override public void actionPerformed( ActionEvent e )
  {
    // ..
  }
} );

Wie kann man das L & F für alle Fenster setzen?

Das Setzen eines L & Fs mit setLookAndFeel() führt zu keinem Neuzeichnen der Komponenten. Wird das neue L & F gesetzt, bevor Swing die Komponenten darstellen muss, fällt das nicht auf. Mit dargestellten Komponenten müssen wir jedoch das Neuzeichnen anstoßen. Dazu dient die Methode SwingUtilities.updateComponentTreeUI(component), wobei component im Allgemeinen das Window (also JFrame/JWindow) ist. Ein Problem ergibt sich, wenn der Frame noch Window-Objekte erzeugt, da diese immer Kinder eines Fensters sind; Änderungen des Aussehens müssen an diese Kinder weitergegeben werden. Dazu erfragen wir zuerst alle Fenster über die statische Funktion Frame.getFrames(). Anschließend laufen wir vom Fenster alle Windows ab, die wir dann aktualisieren.

for ( Frame f : Frame.getFrames() )
{
 SwingUtilities.updateComponentTreeUI( f );
 for ( Window w : f.getOwnedWindows() )
 SwingUtilities.updateComponentTreeUI( w );
}

Wie kann man Text um 90° drehen?

Um einen Text um 90 Grad zu drehen, gibt mehrere Möglichkeiten: 1. Den Text in eine Offscreen Image legen und 1.1 dann zum Beispiel einen Filter drauf loslassen 1.2 ein Arrays raus machen (PixelGrabber) und das Feld umdrehen und wieder in ein Image konvertieren (MemoryImageSource) (ist im Prinzip ein Filter) (Ein Beispiel für einen Rotate Filter findet sich auch im Sun Tutorial) 2. Swing nehmen, den mit dem AffineTransform-Objekt bekommt einen Winkel über setToRotation() und zeichnet dann.

import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.awt.geom.*;   public class Demo2D extends Frame
{
  public Demo2D()
  {
    setSize( 400, 400 );
    addWindowListener( new WindowAdapter() {
      public void windowClosing ( WindowEvent e ) { System.exit(0); }
    });
  }   public void paint( Graphics g )
  {
    Graphics2D g2d = (Graphics2D) g;
    AffineTransform at = new AffineTransform();
    at.setToTranslation( 200.0, 200.0);
    g2d.transform(at);
    at.setToRotation(Math.PI / 2.0);   for (int i = 0; i < 4; i++) {
        g2d.drawString( "Tutego likes Java", 0.0f, 0.0f );
        g2d.transform(at);
    }
  }   public static void main( String[] args )
  {
    new Demo2D().setVisible( true );
   }
}

Wie kann man in Java einzelne Strings de/komprimieren. So wie man es in einem Zip-File machen kann nur eben ohne Zip.

Nehme ein String und trage es in einen ByteArray[Output|Input]Stream ein. Dann nehme den GZIPOutputStream/..InputStream und komprimiere den String in einen ByteArrayXXXStream. Diesen kannst du dann wieder zu einem Bytefeld konvertieren.

Kennt jemand eine einfache Möglichkeit in Java Dateien zu kürzen?

Du kannst eine Datei kürzen, indem du von RandomAccessFile die setLength() Methode nutzt. Leider kann man vorne keine Blöcke ausschneiden (und das möchte man ja eigentlich).

Ich möchte gerne mit JDOM ein XML-Dokument ohne Attribute ausgeben. Gibt es eine Möglichkeit, das mit dem Outputter einfach zu realisieren?

Baue eine Unterklasse von XMLOutputter. Dann kann man schön das Template-Pattern in Anwendung sehen, in dem man die Methode printAttributes() leer lässt:

protected void printAttributes( Writer out, List attributes,
                                Element parent, NamespaceStack namespaces)
  throws IOException { }

Anstatt dann den XMLOutputter einfach die eigene Klasse nehmen.

Der SAX Parser parst doch sequentiell immer die folgende Reihenfolge 1. startDocument(), 2. startElement(), 3. characters(), 4. endElement(), 5. endDocument(), oder?

Durch Character-Chunking kann characters() auch öfters hintereinander aufgerufen werden. Siehe dazu http://www.tutego.de/blog/javainsel/2007/01/character-%E2%80%9Echunking%E2%80%9C-bei-sax/. So etwas wie processingInstruction() kann natürlich auch noch kommen.

Ich würde gerne aus einer MySQL-Datenbank jeweils eine Zeile auslesen, manche Spalten davon bearbeiten und letztendlich alles wieder in eine andere Datenbank schreiben. Im Moment sieht’s ungefähr so aus: a) Verbindung zur Datenbank, b) ResultSet holen, c) Zeile verarbeiten und was machen. Jetzt hab ich aber beim Einlesen schon ein Problem. Ich bekomme  bei dem ResultSet (mit "SELECT * FROM DB") einen Speicherüberlauf. Die Datenbank besteht aus mehreren 100.000 Zeilen und ich weiß leider nicht, wie ich das sonst lösen sollte. Kann man zum Beispiel das ResultSet begrenzen? Also beispielsweise immer wieder 1000 Zeilen lesen oder so? Oder gibt’s noch eine elegantere Lösung?

MySQL kennt leider kein echtes Cursor-Konzept (früherer jedenfalls), sodass der JDBC-Treiber alle Daten auf die Client-Seite überträgt. Mit dieser Technik muss die Datenbank nicht gelockt werden und muss keine Transaktionen unterstützten. Das löst auf einfache Weise ein Problem wie: Der Abholer braucht 10 Stunden für das Lesen, die Tabelle wird aber beschrieben. Kopiert man alles, muss die Datenbank nur für die Übertragung gelockt werden. Schöne Optimierung-Parameter wie fetch-size oder so sind da völlig wertlos. Hier helfen

Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE );

// SENSITIVE ode INSENSITIVE gut überlegen

ResultSet uprs = stmt.executeQuery( "SELECT Bla FROM Blub" );

// Auf die passende Zeile steuern, dann etwa

uprs.updateFloat( "Groesse", 183f );
uprs.updateRow();

Warum bekomme ich bei Hibernate mit session.load(clazz, x) bei Sammlungen ein PersistentSet und kein normales Set?

Der Grund ist einfach: Hibernate verwaltet eine eigenes Set, um Lazy-Loading zu ermöglichen. Ist Lazy-Loading bei 1:n:-Assoziationen eingestellt (Standard), dann wird die Sammlung erst dann geladen, wenn es einen Zugriff auf die Sammlung gibt (Anfragen, add(), …). Der Punkt ist nun: Wie sollte ein Persistence-Provider mitbekommen, dass jmd. nun Daten aus der Sammlung lesen will? Daher fängt das PersistentSet (http://www.hibernate.org/hib_docs/v3/api/org/hibernate/collection/PersistentSet.html) von Hibernate als Proxy die Anfragen ab (PersistentSet ist ein waschechtes java.util.Set) und kann so vor dem tatsächlichen Zugriff auf die Sammlung die Daten schnell laden.

Übrigens hat man in der JPA auch nur die Basis-Collection-Schnittstellen wie Set, List, … aber keine konkreten Klassen wie HashSet, TreeSet,… Die PersistentSet-Doku schreibt aber: "The underlying collection is a HashSet."

Mit Hilfe des Parameters -exclude kann man bei Javadoc komplette Pakete von der Dokumentation ausschließen. Nun möchte ich allerdings nur einzelne Klassen innerhalb eines Pakets ausschließen. Ist das irgendwie möglich?

Wenn du ant (http://ant.apache.org/manual/CoreTasks/javadoc.html) benutzt, schau dir doch mal das FileSet (http://ant.apache.org/manual/CoreTypes/fileset.html) an.

<fileset dir="${server.src}" casesensitive="yes">
  <include name="**/*.java"/>
  <exclude name="**/*Test*"/>
</fileset>

Damit sollte das gehen, etwa so:

<javadoc
 packagenames="..."
 destdir="..."
 ...
  <fileset dir="...">
    <include name="**/*.java" />
    <exclude...>
  </fileset>
</javadoc>

Java 5 heiß ja lange Tiger. Gibt es auch für die anderen Java-Versionen solche Bezeichner?

Für fast jede Java-Version gibt es Code-Namen, etwa für 1.1.4 Sparkler (Diamant), 1.1.5 Pumpkin (Kürbis, auch Trottel), 1.1.6 Abigail (Zofe), 1.1.7 Brutus und 1.1.8 Chelsea . Java 1.2 hieß Playground, und für die folgenden Versionen nutzte Sun Tiernamen (http://java.sun.com/j2se/codenames.html): Cricket 1.2.2 (Grille), 1.3 Kestrel (Turmfalke), Ladybird 1.3.1 (Marienkäfer), 1.4.0 Merlin (Falke), 1.4.1 Hopper (Heuschrecke), 1.4.2 Mantis (Gottesanbeterin), 5 Tiger, 6 Mustang und 7 Dolphin (Delfin). Vielleicht finden wir demnächst auch Java-Flugfrosch, Java-Nashorn und Javaneraffe (lat. Macaca fascicularis, eine krabbenfressende Affenart) – diese Tiere gibt’s wirklich und einen Java-Tiger auch. (Der ist übrigens vom Aussterben bedroht.)

Ich benötige eine Routine zur Bestimmung aller Subklassen einer Klasse bzw. aller Klassen die ein Interface implementieren zur Laufzeit. Leider scheint mit Java Reflection (Class etc.) hier keine Lösung anzubieten (in SmallTalk-80 wäre das kein Problem gewesen 😉

Das Problem lässt sich allgemein auch in Java nicht lösen. Eine (suboptimale) Lösung ist, sich eine Liste aller Klassen zu besorgen (auch das funktioniert nur im Spezialfall) und dann jede Klasse zu fragen, ob sie Unterklasse ist. Dabei muss jedes Class-Objekt auch geladen werden — die Performance ist natürlich richtig schlecht. Dieser Ansatz wird etwa hier realisiert: http://freerails.cvs.sourceforge.net/freerails/jfreerails/src/jfreerails/util/ClassLocater.java?revision=1.2&view=markup. Die Idee ist, zu schauen, welcher Klassenlader die Klassen lädt, und dann über diesen an das Verzeichnis bzw. Jar-Archiv heranzukommen und das dann vollständig zu durchsuchen.

Eine andere Lösung, die oft vorgeschlagen wird, ist die, dass man jede Klasse in einem static {} Block an einer Zentrale anmeldet, sodass man später nur noch diese Zentrale als "Liste aller Klassen" durchsuchen muss. Wenn die Klassen über ein Framework wie JPA oder Spring verwaltet werden ist das auch wieder einfacher. Bei JPA/Hibernate kann zum Beispiel eine Anfrage auf Entity-Beans wie "select o from java.lang.Object o" helfen.

Aus einem Buch unter dem Kapitel "Sprachdesign und Compiler" habe ich folgenden Satz gefunden und als Zitat in meiner Diplomarbeit verwendet: "Variablen können bei der Initialisierung mit dem Schlüsselwort "final" gekennzeichnet werden, was bedeutet, dass sich der Wert dieser Variablen nicht mehr verändern kann." Der Kommentar meines Prof. war: "So einfach ist das nicht"! Ist es nicht so, dass eine mit final deklarierte Variable nicht mehr verändert werden kann?

Worauf dein Prof anspielt ist, dass man final Variablen nicht zwingend bei der Deklaration einen Wert zuweisen muss. Dies kann man später machen, dann aber nur einmal. Nun muss der Compiler durch Flussanalyse verfolgen, ob schon jemand schreibend zugegriffen hat. Und da hat sich der Javac damals in die Nesseln mit gesetzt und das mach den Jikes heute immer noch so. Das Problem war ein switch(). Wenn man den durchfallen lässt, kann man in beiden Teilen die Variable belegen. Ein Beispiel dafür findest du in der FAQ.

Das mit final Variablen und Zuweisungen führt manches mal zu sehr abgefahrenen Lösungen, etwa in der System Klasse. Dort sind die Konsolenströme (in,out,err) final und über einen Hack werden sie nativ bei einer Systeminitialisierung wieder geändert. Das musste man machen, da final Variablen prinzipiell inline gesetzt werden könnte. Das musste man verhindern.

Kennt jemand eine bessere Methode, in Java Potenzen von (kleinen) ganzen Zahlen zu berechnen, als java.lang.Math.pow() zu benutzen und dann von double auf int zu casten?

Wenn man nur 2^n braucht, dann tut es doch ein Shift. Man muss dann aber aufpassen, dass die Bits nicht rausrutschen.

int twoPow( long n )
{
  return 1 << n;
}

Kann mir jemand eine gute Erklärung geben warum ich eine abstrakte Methode nicht static deklarieren kann?

Eine abstrakte Methode ist ja eine Methode, die nicht implementiert ist, also etwa so etwas

abstract class A
{
 abstract void m();
}

Später wird dann die abstrakte Klasse erweitert und die Implementierung nachgeliefert. Wenn die Methode m() aber in A keine Implementierung hat, dann kann Sie auch keine Klassenmethode sein, da Klassenmethoden (statische Methoden) ja nicht an ein Objekt gebunden ist, sondern an die Klasse. Wenn sie statisch wäre, dann könnte man ja etwa

A.m();

schreiben. Doch was soll hier passieren? Also geht das nicht. Eine ähnliche Begründung gilt für private. Wenn die Methode nicht für andere sichtbar ist, dann kann sich aber auch nicht überschrieben werden, da sie keiner sieht. Auch mit final ist es das gleicht. final heißt ja, keiner darf überschreiben. Aber abstract muss man überschreiben.

Andere FAQs

• jGuru FAQ
• comp.lang.java FAQ (Elliotte Rusty Harold. Letzte Änderung 1997)
• FAQ der Newsgroup de.comp.lang.java (Letzte Änderung 2004)
• Frequently Asked Questions About JDBC (Sun)
• Java Network Programming FAQ (David Reilly. Letzte Änderung 2000)

Ich benötige für ein Applet 16 Zufallszahlen. Das habe ich mit Random gelöst und soweit klappt das auch. Dummerweise soll jede Zahl nur einmal vorkommen, was nicht der Fall ist (liegt wohl in der Natur von Zufallszahlen). Wie kann ich das denn lösen?

Du kannst die Collection API nutzen. Erzeuge ein ArrayList der Größe 16. Dann rufe shuffle() auf, welches dir das Feld durchwürfelt. Nun kannst du einen Iterator darüber laufen lassen. Ist dieser am Ende, dann shuffle() einfach neu.

Wie kann man rausfinden, ob mit der Maus auf eine zuvor gezeichnete Linie geklickt wurde?

Das geht mit der Standard-Java-Bibliothek nicht. Da musst du selbst was programmieren; es gibt aber reichlich vorgefertigtes. Unter anderem das sehr leistungsfähige JGraph (http://jgraph.sourceforge.net/). Allerdings muss man sich schon etwas einarbeiten.

Weiß jemand wie es möglich ist von mehreren Linien den Schnittpunkt zu berechnen. Eigentlich geht es darum festzustellen ob sich Linien schneiden. Diese Linien sind durch Koordinaten x und y bestimmt.

Das sind genau genommen zwei Probleme. a) Schneiden sie sich überhaupt und b) wo schneiden sie sich. Dann kommt noch eine Frage hinzu: Soll getestet werden, ob sich eine bestimmte Linie mit irgend einer anderen Linie schneidet, oder soll getestet werden, ob sich irgendeine Linie mit irgendeiner anderen schneidet.
Ein schnelles Verfahren für die Lösung ist der klassische Sweep-Line-Ansatz. Eine Anfrage mit Google dürfte schnell ein Ergebnis liefern. Bei ein paar wenigen Linien reicht ein ein Doofi-Verfahren jeder-mit-jedem mit intersectsLine(Line2D) aus Line2D.

Ich möchte ein Applet programmieren, in dem ich 2 Rechtecke zeichne. Wenn die beiden Rechtecke sich überschneiden, dann soll die Schnittmenge in einer anderen Farbe dargestellt werden. Nun man kann das natürlich mit einzelnen Punkten machen, 24 If Fälle aber… In Java 2 gibt es aber eine Methode die mir diese Schnittmenge berechnet. Wie fange ich die beiden Koordinaten dann auf? Wie kann ich die weiterverarbeiten?

Wenn die Rechtecke nicht gedreht sind, ist das mit der Klasse Rectangle zu lösen. createIntersection(Rectangle2D r) liefert dir ein Rectangle2D Objekt zurück. Mit getWidth, getX, getY kommst du dann an die Werte ran.

Wie fügt man mehrere Bilder zu einem Bild zusammen?

Für Image Objekte gibt es einen Konstruktur, in dem du auch die Größe angeben kannst. Nimm diesen und erzeugt ein das Objekt. Anschließend kannst du dir mittels getGraphics() einen Grafik-Kontext holen und diesen dann Offline zum Platzieren der Bilder nehmen. Neben Image gibt es auch noch BufferedImage. Mit einem PixelGrabber und MemoryImageSource kann man du auch arbeiten, aber das ist ungünstig, da createImage()  leider relativ viel Rechenzeit kostet.

Ich will zwei JPEG-Bilder (gleicher Größe) lesen, untereinander kleben und als eine JPEG-Datei wieder speichern.

Folgendes sollte klappen  (ungetestet)

Image i1 = ...
Image i2 = ...    // deine beiden Bilder

// Bilder jetzt laden (ImageIcon der MediaTracker)

Image i3 = createImage( i1.width(), i1.height() + i2.height() )
Graphics g = i3.getGraphics();
g.drawImage( i1, koordinaten )
g.drawImage( i2, koordinaten )

Wie kann ich ein *.gif oder *.jpg von ein Klient zum Server kriegen mit RMI?

Entweder ein Icon-Objekt (Swing) draus machen, oder ein Bytefeld (PixelGrabber) und auf der anderen Seite wieder zusammensetzten. Leider bekommt man ja ein Image-Objekt nicht serialisiert.

Wie kann ich den Wordwrap bei einer Textbox ausschalten?

Ohne horizontalen Schieberegler wird Zeitenumbruch automatisch eingeleitet. TextArea.SCROLLBARS_NONE oder TextArea.SCROLLBARS_VERTICAL_ONLY einschalten. Standardmäßig wird die TextArea mit horizontalem und and vertikalem Schieberegler ausgestattet. Setze dies im Konstruktor oder später mit der set() Methode.

Ist es möglich, das Name-Caching der Klasse java.inet.InetAddress für einen bestimmten Lookup abzuschalten? Im konkreten Fall geht es um eine dyndns-Adresse, die nicht gecacht werden soll. Das globalNamenscaching soll nicht abgeschaltet werden.

Unter http://www.dnsjava.org/ gibt es eine pure Java-Implementierung, mit der man den Cache ganz präzise steuern.

https://verein.ing-diba.de/sport/47665/turnfreunde-sonsbeck

http://jdk8.java.net/download.html

http://www.apple.com/stevejobs/

Mitte 2013. Weitere News von der JavaONE bei Heise: http://www.heise.de/newsticker/meldung/Java-8-verspaetet-sich-aber-nur-ein-wenig-1354571.html