---
title: 'Ein paar (F)AQs, Teil 3'
url: 'https://www.tutego.de/blog/javainsel/2011/10/ein-paar-faqs-teil-3'
markdown: 'https://www.tutego.de/blog/javainsel/2011/10/ein-paar-faqs-teil-3.md'
date: '2011-10-24'
description: '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( …'
taxonomy:
  category:
    - Allgemein
---

# Ein paar (F)AQs, Teil 3

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://www.tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://www.tutego.de/blog/javainsel/)

## Ein paar (F)AQs, Teil 3

24.10.2011 · [Christian Ullenboom](https://www.tutego.de/blog/javainsel/author/admin/)

##### 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.

```java
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: " + "???" );
```

```java
}
```

**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:

```java
public class Swap
{
  public final static int swapInt( int v )
  {  
    return  (v >>> 24) | (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.

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

Wenn das Programm das folgende ist:

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

Für Java 5 war mal eine [Isolation API](http://www.jcp.org/en/jsr/detail) ([Beschreibung](http://userfriendly.free.fr/christopher/en/index.php?2006%2F06%2F24%2F18-jsr-121-isolation=1)) 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:

```java
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.

```java
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?**

```java
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.

```java
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.

```java
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 );
   }
}
```

Kategorien: [Allgemein](https://www.tutego.de/blog/javainsel/category/allgemein/)

## 1 Kommentare

**DONTTRUST** · [24.10.2011 18:12](#comment-3932)

\>> Wie kann man eine neue JVM aus einem Java-Programm starten? So einfach wie es hier dargestellt wird ist es leider nicht. Dies wird in dieser Form nur funktionieren wenn "java" bekannt ist, z.B. JRE/JDK in der Umgebungsvariable PATH ist. Ist dies nicht der Fall dann wird es deutlich komplexer - auch wenn das Verzeichnis vom JRE/JDK bekannt ist - eine plattformunabhängige Lösung zu implementieren. Es ist empfehlenswert zumindest mal einen Blick im ANT-API in den Java-Task zu werfen..

Die bisherigen Kommentare wurden aus WordPress übernommen. Neue Kommentare sind derzeit geschlossen.

[← Alle Beiträge](https://www.tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Ein paar (F)AQs, Teil 2](https://www.tutego.de/blog/javainsel/2011/10/ein-paar-faqs-teil-2.md)
- Next: [10. Auflage der Insel (Band 1) online](https://www.tutego.de/blog/javainsel/2011/10/10-auflage-der-insel-band-1-online.md)