Bag (org.apache.commons) → Defines a collection that counts the number of times an object appears in
the collection.

Buffer (org.apache.commons) → Defines a collection that allows objects to be removed in some well-defined order. (FIFO, LRU cache)

Methoden: isDigit(), isWhitespace(), isLetter(), isLowerCase()

Methoden: isEmpty(), length(), contains(), indexOf(), equals(), equalsIgnoreCase(), compareTo(),
startsWith(), endsWith(), toCharArray(), getChars(), trim()

System.out.println( input.equals( “heinzelmann” ) ); → Nullpointer möglich
System.out.println( “heinzelmann”.equals( input ) ); → Hier nicht

String s = “Deutsche Kinder sind zu dick”;
boolean b = s.regionMatches( 9, “Bewegungsarmut bei Kindern”, 19, 6 );

Der von compareTo() vorgenommene Vergleich basiert nur auf der internen numerischen Kodierung der Unicode-Zeichen. Dabei berücksichtigt compareTo() nicht die landestypischen Besonderheiten, etwa die übliche Behandlung der deutschen Umlaute. Dafür müssten wir Collator-Klassen nutzen,

Die concat()-Methode arbeitet relativ zügig und effizienter als der Plus-Operator, der einen temporären String-Puffer anlegt.
Ein Vergleich:

for(int i = 0; i < 1000000; i++) {
  String b = "Hase";
  String c = "nfuss";
  String d = b.concat(c); // String d = b + c;
}

Die +-Variante verwendet durchschnittlich 190 Millisekunden, die concat-Variante hingegen nur 110.

String rudi = "There is no spoon"; 
String rudi = new String( "There is no spoon" );

Variante 1 ist besser als 2, da bei der 2. Variante ein zusätzliches Objekt erzeugt wird, denn das Literal ist ja schon ein vollwertiges String-Objekt.

Methoden zum Konvertieren:
String.valueOf(), Integer.parseInt() …

Sting, StringBuffer, StringBuilder im Vergleich:

   
  public static void main(String[] args) {
    long aa = System.currentTimeMillis();
    aa = System.currentTimeMillis();
    StringBuilder c = new StringBuilder();
    for(int i = 0; i < 100000; i++) {
       c.append("a");
    }

    aa = System.currentTimeMillis();
    System.out.println(System.currentTimeMillis() - aa);
    StringBuffer a = new StringBuffer();
    for(int i = 0; i < 100000; i++) {
        a.append("a");
    }
    System.out.println(System.currentTimeMillis() - aa);

    aa = System.currentTimeMillis();
    System.out.println(System.currentTimeMillis() - aa);
    StringBuffer d = new StringBuffer(100000);
    for(int i = 0; i < 100000; i++) {
        d.append("a");
    }
    System.out.println(System.currentTimeMillis() - aa);

    aa = System.currentTimeMillis();
    String b = "";
    for(int i = 0; i < 100000; i++) {
        b += "a";
    }
    System.out.println(System.currentTimeMillis() - aa);


  }

Antwortzeit: 0, 30, 0, 8, 31125
Bei vielen Konkatenationen unbedingt StringBuffer oder StringBuilder verwenden!

Eine Sonderform ist X(?!Y) – das drückt aus, dass der reguläre Ausdruck X dem regulären Ausdruck Y nicht folgen darf.

System.out.println( Pattern.matches( "0\\*", "01" ) );           // false 
System.out.println( Pattern.matches( "0\\*", "0*" ) );           // true
System.out.println( Pattern.matches( "\\d*.", "112a" ) );        // true 
System.out.println( Pattern.matches( ".\\d*.", "x112a" ) );      // true

Bei mehrmaliger Anwendung des gleichen Patterns sollte es compiliert gecacht werden, denn das immer wieder nötige Übersetzen über die Objektfunktion String#matches() bzw. die statische Funktion Pattern.matches() kostet Speicher und Laufzeit.

E-Mail: static Pattern p = Pattern.compile( ”[\\w|-]+@\\w[\\w|-]*\\.[a-z]{2,3}” );

  String s = "'Demnach, welcher verheiratet, der tut wohl; welcher aber nicht Zeilen-Umbruch 
  verheiratet, der tut besser.'" + " 1. Korinther 7, 38"; 
  Matcher matcher = Pattern.compile( "\\d+" ).matcher( s ); 
  while ( matcher.find() ) 
    System.out.printf( "%s an Postion [%d,%d]%n", Zeilen-Umbruch 
                      matcher.group(), matcher.start(), Zeilen-Umbruch 
                      matcher.end() 

1 an Postion [94,95]
7 an Postion [107,108]
38 an Postion [110,112]

Greedy:

Pattern pattern = Pattern.compile( "<b>.*</b>" ); 
Matcher matcher = pattern.matcher( "Echt <b>fett</b>. <b>Cool</b>!" ); 
while ( matcher.find() ) 
  System.out.println( matcher.group() );

Non-Greedy:

Pattern pattern = Pattern.compile( "<b>.*?</b>" ); 
Matcher matcher = pattern.matcher( "Echt <b>fett</b>. <b>Cool</b>!" ); 
while ( matcher.find() ) 
  System.out.println( matcher.group() );

Matchresult:

static Iterable<MatchResult> findMatches( String pattern, CharSequence s ) 
{ 
  List<MatchResult> results = new ArrayList<MatchResult>(); 
 
  for ( Matcher m = Pattern.compile(pattern).matcher(s); m.find(); ) 
    results.add( m.toMatchResult() ); 
 
  return results; 
}
String pattern = "\\d{9,10}[\\d|x|X]"; 
String s = "Insel: 3898425266, Reguläre Ausdrücke: 3897213494"; 
 
for ( MatchResult r : findMatches( pattern, s ) ) 
  System.out.println( r.group() + " von " + r.start() + " bis " + r.end() );

String[] segs = path.split( Pattern.quote( "." ) ); 

Split ist bei mehrmaliger Anwendung nicht sehr effizient,
besser auf die Methode split() von Pattern zugreifen.

  Scanner scanner = new Scanner( new File("EastOfJava.txt") ); 
    while ( scanner.hasNextLine() ) 
      System.out.println( scanner.nextLine() ); 
  } 

Scanner scanner = new Scanner( "tutego 12 1973 12,03 True 123456789000" ); 
System.out.println( scanner.hasNext() );        // true 
System.out.println( scanner.next() );           // tutego 
System.out.println( scanner.hasNextByte() );    // true 
System.out.println( scanner.nextByte() );       // 12 
System.out.println( scanner.hasNextInt() );     // true 
System.out.println( scanner.nextInt() );        // 1973 
System.out.println( scanner.hasNextDouble() );  // true 
System.out.println( scanner.nextDouble() );     // 12.03 
System.out.println( scanner.hasNextBoolean() ); // true 

String s = "Faulheit ist der Hang zur Ruhe ohne vorhergehende Arbeit"; 
StringTokenizer tokenizer = new StringTokenizer( s ); 
while ( tokenizer.hasMoreTokens() ) 
  System.out.println( tokenizer.nextToken() );

Bietet auch Methode countTokens(), jedoch nicht billig

Zum Trennen von Sätzen, Wörtern …

Beispiel zum runden von Zahlen nach 2 Nachkommastellen:

class Round2Scales 
{ 
  public static double roundScale2( double d ) 
  { 
    return Math.round( d * 100 ) / 100.; 
  } 
 
  public static void main( String[] args ) 
  { 
    System.out.println( roundScale2(+1.341 ) );    //  1.34 
    System.out.println( roundScale2(–1.341 ) );    // –1.34 
    System.out.println( roundScale2(+1.345 ) );    //  1.34 
 
    System.out.println( roundScale2(–1.345 ) );    // –1.34 
    System.out.println( roundScale2(+1.347 ) );    //  1.35 
    System.out.println( roundScale2(–1.347 ) );    // –1.35 
  } 
}

Zufallszahlen mit Random, Kryptografisch bessere Zufallszahlen liefert die Klasse java.security.SecureRandom, die eine Unterklasse von Random ist.

BigDecimal, BigInteger und MathContext für genaue Berechnungen.

Trick wie der try-Block wieder ausgeführt wird.

int number = 0; 
while ( true ) 
{ 
  try 
  { 
    String s = javax.swing.JOptionPane.showInputDialog( 
                 "Bitte Zahl eingeben" ); 
    number = Integer.parseInt( s ); 
    break; 
  } 
  catch ( NumberFormatException ó_ò ) 
  { 
    System.err.println( "Das war keine Zahl!" ); 
  } 
} 
System.out.println( "Danke für die Zahl " + number ); 
System.exit( 0 );           // Beendet die Anwendung

Exceptions nicht abfangen mit:

import java.io.*; 
 
class MirIstAllesEgal 
{ 
  public static void main( String[] args ) throws Exception 
  { 
    RandomAccessFile f = new RandomAccessFile( "Datei.txt", "r" ); 
    System.out.println( f.readLine() ); 
  } 
}

throws bei überschriebenen Methoden:

• dieselben Ausnahmen wie die Oberklasse auslösen,

• Ausnahmen spezialisieren oder

• weglassen.

http://www.tagtraum.com/gcviewer-vmflags.html

-XX:+HeapDumpOnOutOfMemoryError : Creates a heapDump

Null-Abfragen:

String s = rs.getString( column ); 
if ( rs.wasNull() ) 
  System.out.println( "SQL-NULL" );

Mehrere Updated gleichzeitig machen:

int[] updateCounts = null; 
try 
{ 
  con.setAutoCommit( false ); 
  Statement s = con.createStatement(); 
  s.addBatch( "INSERT INTO Lieferanten VALUES (x,y,z)" ); 
  s.addBatch( "INSERT INTO Lieferanten VALUES (a,b,c)" ); 
  s.addBatch( "INSERT INTO Lieferanten VALUES (d,e,f)" ); 
  updateCounts = s.executeBatch(); 
} 
catch ( BatchUpdateException e ) { con.rollback();  } 
catch ( SQLException e ) { /* Behandeln! */ }

Das ResultSet muss immer eine Verbindung mit der Datenbank haben, und ein Aufruf von next() könnte sich die Zei-leninformationen immer von der Datenbank besorgen. Ein ResultSet ist also kein Container, der Daten speichert. Aus diesem Grunde implementiert ResultSet auch nicht die Schnittstelle Serializable.

A CachedRowSet object is a disconnected rowset, which means that it makes use of a connection to its data source only briefly. It connects to its data source while it is reading data to populate itself with rows and again while it is propagating changes back to its underlying data source. The rest of the time, a CachedRowSet object is disconnected, including while its data is being modified. Being disconnected makes a RowSet object much leaner and therefore much easier to pass to another component. For example, a disconnected RowSet object can be serialized and passed over the wire to a thin client such as a personal digital assistant (PDA).

Bietet Möglichkeit für Paging, Updating, Registering Listeners