Byte-Welt Wiki - Benutzerbeiträge [de]

Voodoo-Kiste

2013-08-07T15:57:42Z

Fastjack: Die Seite wurde neu angelegt: „Kategorie:Java == String-Magic Level 1 == Der erste Eintrag der lustigen Java-Voodookiste widmet sich ganz einfach mal der wunderbaren Kunst der Stringkonkat…“

[[Kategorie:Java]]
== String-Magic Level 1 ==

Der erste Eintrag der lustigen Java-Voodookiste widmet sich ganz einfach mal der wunderbaren Kunst der Stringkonkatenation. Ein wenig Mystery ist auch dabei, ganz bestimmt

<code=java>
System.out.println("funny concat : " + 1 + 1); // it's okay if you first think it's 2
System.out.println("stupid funny concat : " + + + + + + 1 + + + + 1); // <- yeah! wth?
System.out.println("stupid funny concat : " +- + + +- + + -+-1 + + + + -+-1); // <- omg! wtf?!?!?!
System.out.println("so nice :) : " + - - - - - - + 1 +- - - -1); // <- omfg!!! wtfh?!???!!!
//System.out.println("never ever 1st :( : " ++ 1); // never ever, you cannot do so, never, believe it :)
//System.out.println("never ever 2nd :( : " + -- 1); // absolutely no!
</code=java>

== Integer-Magic Level 1 ==

Es folgt ein mächtiger Kniff aus der Java-Voodookiste mit anschließendem Brain**** am Ende:

<code=java>
Integer i0 = 5000;
Integer i1 = 5000;
System.out.println(i0 == i1); // ok, we should know this is false, or not? Look at the end ;)
System.out.println(i0.intValue() == i1.intValue()); // yeah, it's right mister
// let's try smaller values
i0 = 127;
i1 = 127;
System.out.println(i0.intValue() == i1.intValue()); // yeees sir!
System.out.println(i0 == i1); // wth?
i0 = -128;
i1 = -128;
System.out.println(i0 == i1); // wtfh?!?!?!
// try this: give the VM the following VM-Argument -Djava.lang.Integer.IntegerCache.high=5001
// and things becomes very scary ;)
</code=java>

== Byte-Magic Level 1 ==

Zur Abwechslung der Grundkurs Byte-Magic für Level 1 Wizards

<code=java>
byte b = 1; // ok, it's nice too see
//byte b = 128; // we know that's not compiling ;)
//b = b + 127; // hey, we know this too :) it's absolutely safe, ever!
b += 127; // but wth?
b ++; // omg!!!
b ++; // wtf?!?!?
for(int i = 0; i < 169; i ++) {
b ++; // yeah!
}
b --;
System.out.println(b); // the solution of the biggest question ever!

short s = 1;
s = Short.MAX_VALUE;
//s = s + 1; // yeah! it's not compiling mister ;)
s += 1; // ok, we like bytes, we like you too!
// and so on ... you already know the solution :)

int i = 1;
i = Integer.MAX_VALUE;
i = i + 1; // don't be panic OO
i = i + 10; // we like byte and short more than other numeric types ;)
System.out.println(i); // it's something crazy...

char c = 1;
c = 65535; // yeah, you know the c64?
//c = c + 1; // ok char, we like you too ;) don't compile this :)
c ++;
c ++;
System.out.println((char) (c - Short.MAX_VALUE)); // because you're funny as bytes and shorts :)
</code=java>

== Write-through-Magic Level 1 ==

Es folgt ein kleiner Ausflug in die Kunst des Durchschreibenden-Voodoozaubers von Ank-Pheng.

<code=java>
// lets create a simple list
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
String[] array = list.toArray(new String[0]); // create an array from it
System.out.println("1st list : " + list); // ok, i know i know!
System.out.println("1st array-size: " + array.length); // yeah, i expected this ;)
System.out.println("set 'a' to 'z' in list ..."); // ok chummer!
list.set(0, "z");
System.out.println("1st list : " + list); // where's the trick here?
System.out.println("1st array[0] : " + array[0]); // no trick! what you think? We don't summon demons or cast spells here, ever! ever ever!
// let's create a simple array
array = new String[]{"a", "b", "c"};
list = Arrays.asList(array); // create a list from it
System.out.println("2nd list : " + list); // ok, i already know it!
System.out.println("2nd array size: " + array.length); // yessss! what you expect here?
System.out.println("set first element to 'z' in array ..."); // try it baby! try!
array[0] = "z";
System.out.println("2nd array[0] : " + array[0]); // yeah! i know!!!
System.out.println("2nd list : " + list); // omg!!! wtfh?!?!?! i can't believe...
// believe the power of write-through magic ;)
</code=java>

Weihnachtsbaum

2013-08-07T15:52:42Z

Fastjack:

[[Kategorie:Java]]

Da viele immer mal wieder einen Weihnachtsbaum erstellen möchten, stelle ich mal meinen vor Wem es hilft, der kann sich gerne bedienen.

Viel Spaß!

<code=java>
/*
* ChristmasTreeTest.java
*
* 05.01.2012
*
* Copyright 2012 fastjack
*/
package blog.tree;

import org.junit.*;

import static org.junit.Assert.*;

public class ChristmasTreeTest {
private static final String LINE_END = System.getProperty("line.separator");

@Test(expected=IllegalArgumentException.class)
public void failCreateWithNegativeHigh() {
new ChristmasTree(-1);
}

@Test(expected=IllegalArgumentException.class)
public void failCreateWithZeroHigh() {
new ChristmasTree(0);
}

@Test
public void shouldCreateWithHighOfOne() {
StringBuilder expected = new StringBuilder();
expected.append("*").append(LINE_END);
expected.append("|").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(1).toString());
}

@Test
public void shouldCreateWithHighOfTwo() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append("***").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(2).toString());
}

@Test
public void shouldCreateWithHighOfThree() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append("*****").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(3).toString());
}

@Test
public void shouldCreateWithHighOfFour() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append(" ***** ").append(LINE_END);
expected.append("*******").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(4).toString());
}

@Test
public void shouldCreateWithHighOfFive() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append(" ***** ").append(LINE_END);
expected.append(" ******* ").append(LINE_END);
expected.append("*********").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(5).toString());
}

}
</code=java>

<code=java>
/*
* ChristmasTree.java
*
* 05.01.2012
*
* Copyright 2012 fastjack
*/
package blog.tree;

import org.apache.commons.lang.*;

/**
* This class defines a christmas tree. After construction the tree can represented as String
* via the toString() method.
*
* <pre>
* System.out.println(new ChristmasTree(3).toString());
* </pre>
*
* prints out a christmas tree with a height of three in form:
*
* <pre>
* *
* ***
* *****
* |
* </pre>
*
* the idea for defined height n is
*
* <pre>
* // 2n-1 lines for body
* * // for actual row (beginning at zero) r print out 2(r+1)-1 stars
* *** //
* |.| // if actual column is in star printing area |.| including the | then print a star
* |.| // otherwise a space
* ***** //
* | // and a separate line for the centered trunk
* </pre>
*
* @author fastjack
*/
public class ChristmasTree {
private static final String TRUNK = "|";
private static final String SPACE = " ";
private static final String STAR = "*";
private static final String LINE_END = System.getProperty("line.separator");
private int height;
private int maxTreeWidth;
private int halfOfTreeWidth;

/**
* Creates a christmas tree for the defined height.
*
* @param height the height of the tree must be greater than zero
*/
public ChristmasTree(int height) {
Validate.isTrue(height > 0, "height must be greater than zero!");
this.height = height;
maxTreeWidth = 2 * height - 1;
halfOfTreeWidth = maxTreeWidth / 2;
}

@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append(makeBody());
s.append(makeBottomLineWithTrunk());
return s.toString();
}

private String makeBody() {
StringBuilder lines = new StringBuilder();
for(int row = 0; row < height; row ++) {
int numberOfStarsInRow = getNumberOfStarsInRow(row);
int startOfStarPrinting = getStartColumnToPrintStars(numberOfStarsInRow);
int endOfStarPrinting = startOfStarPrinting + numberOfStarsInRow;
lines.append(makeLine(startOfStarPrinting, endOfStarPrinting));
}
return lines.toString();
}

private int getNumberOfStarsInRow(int row) {
return 2 * (row + 1) - 1;
}

private int getStartColumnToPrintStars(int numberOfStarsInRow) {
return halfOfTreeWidth - (numberOfStarsInRow / 2);
}

private StringBuilder makeLine(int startOfStarPrinting, int endOfStarPrinting) {
StringBuilder line = new StringBuilder();
for(int column = 0; column < maxTreeWidth; column ++) {
if (isStarToPrint(startOfStarPrinting, endOfStarPrinting, column)) {
line.append(STAR);
} else {
line.append(SPACE);
}
}
line.append(LINE_END);
return line;
}

private boolean isStarToPrint(int startOfStarPrinting, int endOfStarPrinting, int column) {
return column >= startOfStarPrinting && column < endOfStarPrinting;
}

private String makeBottomLineWithTrunk() {
StringBuilder bottom = new StringBuilder();
for(int column = 0; column < maxTreeWidth; column ++) {
if (column == maxTreeWidth / 2) {
bottom.append(TRUNK);
} else {
bottom.append(SPACE);
}
}
bottom.append(LINE_END);
return bottom.toString();
}

}
</code=java>

Formatierte Tabellen auf der Console ausgeben

2013-08-07T15:51:46Z

Fastjack:

[[Kategorie:Java]]
Die folgende Klasse kann auf einfache Art und Weise eine formatierte Texttabelle als String erzeugen. Dabei können zusätzlich die Formatierungseigenschaften der Klasse java.util.Formatter verwendet werden. Die Formatierung ähnelt den Konsolenausgaben von MySQL-Anfragen. Viel Spaß!

<code=java>
/*
* Table.java
*
* 14.10.2010
*
* (c) fastjack
*/

package blog.text;

import java.util.*;

/**
* This class defines a simple formatted text table. It can be used to create simple formatted
* text tables (like MySQL console outputs) with the formatting stuff from class
* "java.util.Formatter" defined in the enumerations.
*
* @author fastjack
*/
public class Table {
private List<Col> cols = new ArrayList<Col>();
private List<Row> rows = new ArrayList<Row>();

/**
* Adds a col.
*
* @param name the name
* @return the table
*/
public Table addCol(String name) {
this.cols.add(new Col(name));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Flags... flags) {
this.cols.add(new Col(name, null, flags));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param conversion the conversion
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Conversions conversion, Flags... flags) {
this.cols.add(new Col(name, conversion, flags));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param conversion the conversion
* @param dtconversion the date/timeconversion
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Conversions conversion, DateTimeConversions dtconversion,
Flags... flags) {
this.cols.add(new Col(name, conversion, dtconversion, flags));
return this;
}

/**
* Gets the col size.
*
* @return the col size
*/
public int getColSize() {
return this.cols.size();
}

/**
* Gets the col.
*
* @param index the index
* @return the col
*/
public Col getCol(int index) {
return this.cols.get(index);
}

/**
* Gets the row size.
*
* @return the row size
*/
public int getRowSize() {
return this.rows.size();
}

/**
* Gets the row.
*
* @param index the index
* @return the row
*/
public Row getRow(int index) {
return this.rows.get(index);
}

/**
* Adds the row.
*
* @param values the values
*/
public void addRow(Object... values) {
this.rows.add(new Row(values));
}

@Override
public String toString() {
StringBuilder s1 = new StringBuilder();
StringBuilder s2 = new StringBuilder();
// data
for (int i = 0, n = this.rows.size(); i < n; i++) {
Row r = this.rows.get(i);
for (int ii = 0, nn = this.cols.size(); ii < nn; ii++) {
Col c = this.cols.get(ii);
Object o = r.getValue(ii);
if (c.getConversion() == null) {
c.setConversion(this.getConversionForType(o));
}
int nl = Math.max(c.getName().length(), String.valueOf(o).length());
if (nl > c.getWidth()) {
c.width = nl;
}
int ol = String.format(this.getToken(o, c.getWidth(), c.getConversion(),
c.getDateTimeConversion(), c.getFlags()), o).length();
if (ol > c.getWidth()) {
c.width = ol;
}
}
}
for (int i = 0, n = this.rows.size(); i < n; i++) {
Row r = this.rows.get(i);
StringBuilder data = new StringBuilder();
for (int ii = 0, nn = this.cols.size(); ii < nn; ii++) {
Col c = this.cols.get(ii);
Object o = r.getValue(ii);
data.append("| ");
data.append(this.getToken(o, c.getWidth(), c.getConversion(),
c.getDateTimeConversion(), c.getFlags()));
if (ii < nn - 1) {
data.append(" ");
}
}
data.append(" |\n");
s2.append(String.format(data.toString(), r.getValues()));
}
// head
StringBuilder sep = new StringBuilder();
StringBuilder begin = new StringBuilder();
StringBuilder end = new StringBuilder();
StringBuilder head = new StringBuilder();
Object[] oa = new Object[this.cols.size()];
for (int i = 0, n = this.cols.size(); i < n; i++) {
Col c = this.cols.get(i);
oa[i] = c.getName();
if (i == 0) {
begin.append("+");
end.append("+");
sep.append("+");
} else {
begin.append("+");
end.append("+");
sep.append("+");
}
head.append("| %");
head.append(String.valueOf(c.getWidth()));
head.append("s");
for (int ii = 0; ii < c.getWidth() + 2; ii++) {
begin.append("-");
sep.append("-");
end.append("-");
}
if (i < n - 1) {
head.append(" ");
}
}
begin.append("+\n");
sep.append("+\n");
end.append("+\n");
head.append(" |\n");
s1.append(begin);
s1.append(String.format(head.toString(), oa));
s1.append(sep);
s1.append(s2);
s1.append(end);
return s1.toString();
}

private String getToken(Object object, int width, Conversions conversion,
DateTimeConversions dtconversion, Flags... flags) {
StringBuilder s = new StringBuilder();
s.append("%");
if (flags != null && flags.length > 0) {
for (int i = 0; i < flags.length; i++) {
Flags f = flags[i];
s.append(f.getToken());
}
}
if (width > 0) {
s.append(width);
}
if (conversion != null) {
s.append(conversion.getToken());
} else {
s.append(this.getConversionForType(object).getToken());
}
if (dtconversion != null) {
s.append(dtconversion.getToken());
}
return s.toString();
}

private Conversions getConversionForType(Object object) {
if (object instanceof Byte) {
return Conversions.DECIMAL;
} else if (object instanceof Short) {
return Conversions.DECIMAL;
} else if (object instanceof Integer) {
return Conversions.DECIMAL;
} else if (object instanceof Character) {
return Conversions.CHARACTER;
} else if (object instanceof Long) {
return Conversions.DECIMAL;
} else if (object instanceof Float) {
return Conversions.FLOAT;
} else if (object instanceof Double) {
return Conversions.FLOAT;
} else if (object instanceof Boolean) {
return Conversions.BOOLEAN;
} else if (object instanceof String) {
return Conversions.STRING;
} else {
return Conversions.STRING;
}
}
</code=java>

Die Klasse für die Zeilen:

<code=java>
/**
* This class defines a row, containing an object arry with values.
*/
public class Row {
private Object[] values = null;

/**
* Instantiates a new row.
*
* @param values the values
*/
public Row(Object[] values) {
super();
this.values = values;
}

/**
* Gets the value.
*
* @param index the index
* @return the value
*/
public Object getValue(int index) {
return this.values[index];
}

/**
* Gets the values.
*
* @return the values
*/
public Object[] getValues() {
return this.values;
}
}
</code=java>

Die Klasse für die Spalten:

<code=java>
/**
* This class defines a column.
*/
public class Col {
private Flags[] flags = null;
private Conversions conversion = null;
private DateTimeConversions dateTimeConversion = null;
private String name = "";
private int width = 0;

/**
* Instantiates a new col.
*
* @param name the name
*/
public Col(String name) {
this(name, null);
}

/**
* Instantiates a new col.
*
* @param name the name
* @param conversion the conversion
* @param flags the flags
*/
public Col(String name, Conversions conversion, Flags... flags) {
this(name, conversion, null, flags);
}

/**
* Instantiates a new col.
*
* @param name the name
* @param conversion the conversion
* @param dateTimeConversion the date time conversion
* @param flags the flags
*/
public Col(String name, Conversions conversion, DateTimeConversions dateTimeConversion,
Flags... flags) {
super();
this.dateTimeConversion = dateTimeConversion;
this.conversion = conversion;
this.flags = flags;
this.name = name;
this.width = this.name.length();
}

/**
* Gets the name.
*
* @return the name
*/
public String getName() {
return this.name;
}

/**
* Gets the conversion.
*
* @return the conversion
*/
public Conversions getConversion() {
return this.conversion;
}

/**
* Sets the conversion.
*
* @param conversion the new conversion
*/
public void setConversion(Conversions conversion) {
this.conversion = conversion;
}

/**
* Gets the width.
*
* @return the width
*/
public int getWidth() {
return this.width;
}

/**
* Gets the flags.
*
* @return the flags
*/
public Flags[] getFlags() {
return this.flags;
}

/**
* Gets the date time conversion.
*
* @return the date time conversion
*/
public DateTimeConversions getDateTimeConversion() {
return this.dateTimeConversion;
}

}
</code=java>

Die Flaggen:

<code=java>
/**
* This enumeration defines the flags.
*/
public enum Flags {
LEFT("-"),
CONVERSION_DEPENDENT("#"),
SIGN("+"),
POSITIVE_LEADING_SPACE(" "),
ZERO_PADDING("0"),
LOCALE_GROUPING_SEPARATORS(","),
PARENTHESES_FOR_NEGATIVES("(");

String token = "";

/**
* Instantiates a new flag.
*
* @param token the token
*/
Flags(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}
}
</code=java>

Die Konversionen:

<code=java>
/**
* This enumeration defines conversions.
*/
public enum Conversions {
BOOLEAN("b"),
CHARACTER("c"),
DATE_TIME("t"),
DECIMAL("d"),
FLOAT("f"),
FLOAT_HEX("a"),
FLOAT_SCIENCE("e"),
FLOAT_SCIENCE_PREC("g"),
HEX("h"),
HEX_INT("h"),
LINE_SEPARATOR("n"),
OCTAL("o"),
PERCENT("%"),
STRING("s");

String token = "";

/**
* Instantiates a new conversion.
*
* @param token the token
*/
Conversions(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}

}
</code=java>

Zeit/Datums- Konversionen:

<code=java>
/**
* This enumeration defines date/time conversions.
*/
public enum DateTimeConversions {
FULL_MONTH_NAME("B"),
ABBREVATED_MONTH_NAME("b"),
ABBREVATED_MONTH_NAME_H("h"),
FULL_DAY_OF_THE_WEEK_NAME("A"),
SHORT_DAY_OF_THE_WEEK_NAME("a"),
FOUR_DIGIT_YEAR("C"),
LEADING_ZEROS_YEAR("Y"),
LAST_TWO_DIGITS_YEAR("y"),
THREE_DIGIT_DAY_OF_THE_YEAR("j"),
TWO_DIGIT_MONTH("m"),
TWO_DIGIT_DAY_OF_MONTH("d"),
DAY_OF_MONTH("e"),
HOUR_OF_DAY_LEADING_24("H"),
HOUR_OF_DAY_LEADING_12("I"),
HOUR_OF_DAY_24("k"),
HOUR_OF_DAY_12("l"),
TWO_DIGIT_MINUTE("M"),
TWO_DIGIT_SECOND("S"),
THREE_DIGIT_MILLISECOND("L"),
TWO_DIGIT_NANOSECOND("N"),
MORING_AFTERNOON_MARKER("p"),
RFC822_TIME_ZONE_OFFSET("z"),
TIME_ZONE_ABBREVATION("Z"),
BEGINNING_SECONDS("s"),
BEGINNING_MILLISECONDS("Q"),
TIME_HOUR_CLOCK_24("R"),
LONG_TIME_HOUR_CLOCK_24("T"),
TIME_HOUR_CLOCK_12("r"),
LONG_DATE("D"),
ISO8601_DATE("F"),
FULL_DATE("c");

String token = "";

/**
* Instantiates a new date time conversion.
*
* @param token the token
*/
DateTimeConversions(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}
}

}
</code=java>

Der folgende Anwendungsfall:

<code=java>
public static void main(String[] args) {
Table t = new Table();
t = t.addCol("char", Flags.LEFT)
.addCol("byte", Flags.ZERO_PADDING)
.addCol("short", Flags.PARENTHESES_FOR_NEGATIVES, Flags.LEFT)
.addCol("int", Flags.LOCALE_GROUPING_SEPARATORS)
.addCol("long", Flags.LOCALE_GROUPING_SEPARATORS, Flags.SIGN)
.addCol("float", Conversions.FLOAT_HEX)
.addCol("double", Conversions.FLOAT_SCIENCE)
.addCol("boolean")
.addCol("string")
.addCol("object")
.addCol("null")
.addCol("Date", Conversions.DATE_TIME, DateTimeConversions.FULL_DATE);
t.addRow('a', (byte) 1, (short) 1, 100, 100L, 1.0F, 1.0, true, "ab", new Object(), null,
new Date());
t.addRow('a', (byte) 1, (short) -1, 1000, 1000L, 1.0F, 1.0, false, "abbas", new Object(), null,
new Date());
t.addRow('a', (byte) 1, (short) 1, 10000, -10000L, 1.0F, 1.0, true, "sdhjsdhjdsghsdghds",
new Object(), null, new Date());
Col c = t.getCol(0);
System.out.println(t);
}
</code=java>

Erzeugt die Ausgabe:

<nowiki>
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
| char | byte | short | int | long | float | double | boolean | string | object | null | Date |
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
| a | 0001 | 1 | 100 | +100 | 0x1.0p0 | 1,000000e+00 | true | ab | java.lang.Object@1e97676 | null | So Apr 03 17:46:15 MESZ 2011 |
| a | 0001 | (1) | 1.000 | +1.000 | 0x1.0p0 | 1,000000e+00 | false | abbas | java.lang.Object@7bd9f2 | null | So Apr 03 17:46:15 MESZ 2011 |
| a | 0001 | 1 | 10.000 | -10.000 | 0x1.0p0 | 1,000000e+00 | true | sdhjsdhjdsghsdghds | java.lang.Object@121cc40 | null | So Apr 03 17:46:15 MESZ 2011 |
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
</nowiki>

Benchmarks

2013-08-07T15:50:06Z

Fastjack:

[[Kategorie:Java]]

Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach kommentieren.

Das Interface Bench:

<code=java>
/*
* Bench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Schnittstelle beschreibt einen Benchmark.
*
* @author fastjack
* @version 1.0
*/
public interface Bench {

/**
* @return der Name.
*/
String getName();

/**
* setzt den Benchmark und alle Resourcen, die er benutzt in den Urzustand zurück.
*/
void reset();

/**
* Bereitet den Benchmark zur Ausführung vor.
*
* @param lm Parameter anhand dessen der Benchmark vorbereitet wird.
*/
void prepare(long lm);

/**
* Führt den Benchmark aus.
*
* @param lm Parameter anhand dessen der Benchmark ausgeführt wird.
*/
void execute(long lm);
}

</code=java>

Die abstrakte Klasse Bench:

<code=java>
/*
* AbstractBench.java
*
* 06.01.2011
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Klasse stellt einen abstrakten Benchmark dar.
*
* @author fastjack
* @version 1.0
*/
public abstract class AbstractBench implements Bench {

@Override
public String getName() {
return this.getClass().getSimpleName();
}

@Override
public void prepare(long lm) {
}

@Override
public void reset() {
}

}

</code=java>

Das Benchmarksystem QuickBench:

<code=java>
/*
* QuickBench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

import java.util.*;

/**
* Diese kleine Klasse soll ein einfaches Benchmarksystem darstellen.
*
* @author fastjack
* @version 1.0
*/
public class QuickBench {

private final static String headerNxMSep = "+---------------------------+----------+-------"
+ "-----+----------+----------+-----------------+-----------------+";
private final static String headerNxM = "| %-25s | %8s | %10s | %8s | %8s | %15s | %15s "
+ "|\n";
private final static String headerNxIntervallSep = "+---------------------------+----------"
+ "+------------+------------+----------+----------+-----------------+-------------"
+ "----+";
private final static String headerNxIntervall = "| %-25s | %8s | %10s | %10s | %8s | %8s | "
+ "%15s | %15s |\n";
private final static String patternNxM = "| %-25s | %,8d | %,10d | %,8d | %,8d | %,15d | "
+ "%,15d |\n";
private final static String patternNxMWNT = "| %-25s | %,8d | %,10d | %,8d | %,8d | %15s | "
+ "%15s |\n";
private final static String patternNxIntervall = "| %-25s | %,8d | %,10d | %,10d | %,8d | "
+ "%,8d | %,15d | %,15d |\n";
private final static String patternNxIntervallWNT = "| %-25s | %,8d | %,10d | %,10d | %,8d "
+ "| %,8d | %15s | %15s |\n";

private QuickBench() {
}

/**
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet. Bevor das Benchmarking
* gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch den
* Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Alle Benchmarks werden zu jedem Eintrag e in n i-mal (i <= e) wiederholt,
* jeweils mit einem Wert aus dem dem angegebenen Intervall.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
* @param ba Benchmarks.
*/
public static void benchNxIntervall(long minMs, long wm, long[] n, long mmin, long mmax,
Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxIntervallSep);
System.out.printf(headerNxIntervall, "Bench", "Rounds", "min", "max", "ms",
"ms (avg)", "nt", "nt (avg)");
System.out.println(headerNxIntervallSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
qb.executeIntervall(b, n, minMs, mmin, mmax);
}
System.out.println(headerNxIntervallSep);
qb.showInfo();
}

/**
* Führt Benchmarks, die z.B. einer Anzahl von Objekten basieren, aus. Der Benchmark
* wird zurerst zurückgesetzt und jeweils zu einem Wert aus m vorbereitet. Bevor das
* Benchmarking gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch
* den Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Die Anzahl der Objekte im Feld m. Alle Benchmarks werden zu jedem Eintrag m0
* in m i-mal (i <= m0) durchlaufen und zu jedem Eintrag n0 in n j-mal (j <= n0)
* zu dem Wert m0 ausgeführt.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param m Anzahl an z.B. Objekten.
* @param ba Benchmarks.
*/
public static void benchNxM(long minMs, long wm, long[] n, long[] m, Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxMSep);
System.out.printf(headerNxM, "Bench", "Rounds", "Objects", "ms", "ms (avg)",
"nt", "nt (avg)");
System.out.println(headerNxMSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
for (int ii = 0; ii < m.length; ii++) {
qb.execute(b, n, minMs, m[ii]);
}
}
System.out.println(headerNxMSep);
qb.showInfo();
}

/*
* Zeigt Informationen zum System an.
*/
private void showInfo() {
System.out.println("java version " + System.getProperty("java.version"));
System.out.println(System.getProperty("java.runtime.name") + "(build " +
System.getProperty("java.runtime.version") + ")");
System.out.println(System.getProperty("java.vm.name") + "(build "
+ System.getProperty("java.vm.version") + ", "
+ System.getProperty("java.vm.info") + ")");
System.out.println(System.getProperty("os.name") + "("
+ System.getProperty("os.version") + ") " + System.getProperty("os.arch"));
System.out.println("Max memory: " + Runtime.getRuntime().maxMemory() / (1024 * 1024)
+ "MB");
}

/*
* Führt ein warmup zu allen Benchmarks durch. Dabei werden die Benches jeweils mit den
* Werten 1 vorbereitet und ausgeführt.
*
* @param ba Benchmarks.
* @param n Anzahl an Durchläufen zum WarmUp.
*/
private void warmup(Bench[] ba, long n) {
for (int i = 0; i < n; i++) {
for (int ii = 0; ii < ba.length; ii++) {
Bench b = ba[ii];
b.reset();
b.prepare(1);
b.execute(1);
}
}
}

/*
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
*/
private void executeIntervall(Bench b, long[] n, long minMs, long mmin, long mmax) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
for (long l = mmin; l < mmax; l++) {
b.reset();
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(l);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
}
if (ms < minMs) {
System.out.printf(patternNxIntervall, b.getName(), ln, mmin, mmax, ms, ms / ln,
nt, (nt / ln));
} else {
System.out.printf(patternNxIntervallWNT, b.getName(), ln, mmin, mmax, ms,
ms / ln, "...", "...");
}
}
}

/*
* Führt Benchmarks zu einem gegebenen Wert aus. Der Benchmark wird zurerst
* zurückgesetzt und zu dem Wert val vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param val Wert.
*/
private void execute(Bench b, long[] n, long minMs, long val) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
b.reset();
b.prepare(val);
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(val);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
if (ms < minMs) {
System.out.printf(patternNxM, b.getName(), ln, val, ms, ms / ln, nt, (nt / ln));
} else {
System.out.printf(patternNxMWNT, b.getName(), ln, val, ms, ms / ln, "...",
"...");
}
}
}
}
</code=java>

Ein kleines Beispiel zum Traversieren einer Liste (NxM):

<code=java>
Bench b0 = new Bench() {
List<String> l = null;

@Override
public String getName() {
return "Traverse";
}

@Override
public void reset() {
l = new ArrayList<String>();
}

@Override
public void prepare(long lm) {
for (int i = 0; i < lm; i++) {
l.add(String.valueOf(i));
}
}

@Override
public void execute(long lm) {
for (int i = 0, n = l.size(); i < n; i++) {
String s = l.get(i);
}
}
};
</code=java>

Benutzung:

<code=java>
...
QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
new Bench[] { b0 });
...
</code=java>

Als Ergebnis erhält man folgendes:

<nowiki>
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | Objects | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Traverse ArrayList For | 10 | 10.000 | 0 | 0 | 1.945.638 | 194.563 |
| Traverse ArrayList For | 100 | 10.000 | 16 | 0 | ... | ... |
| Traverse ArrayList For | 1.000 | 10.000 | 171 | 0 | ... | ... |
| Traverse ArrayList For | 10 | 100.000 | 16 | 1 | ... | ... |
| Traverse ArrayList For | 100 | 100.000 | 109 | 1 | ... | ... |
| Traverse ArrayList For | 1.000 | 100.000 | 1.170 | 1 | ... | ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Legende:

<nowiki>
Bench: Name des Benchmarks.
Rounds: Anzahl an Durchläufen.
Objects: Anzahl an verwendeteten Objekten.
ms: Gesamtzeitbedarf in Millisekunden.
ms (avg): Durchschnittlicher Zeitbedarf in Millisekunden.
nt: Gesamtzeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
nt (avg): Durchschnittlicher Zeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
</nowiki>

Weitere Beispiele folgen...

Und zwar jetzt:

Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

<code=java>
/* fibonacci -> recursive */
static class FibBench_Recursive extends AbstractBench {

private int fib(int a) {
if (a == 1 || a == 2) {
return 1;
} else {
return fib(a - 1) + fib(a - 2);
}
}

@Override
public String getName() {
return "Fibonacci: recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};

/* fibonacci -> non-recursive */
static class FibBench_NonRecursive extends AbstractBench {

private long fib(int a) {
long fib = 1;
for (long fib1 = 1, fib2 = 1, i = 3; i <= a; i++) {
fib = fib1 + fib2;
fib1 = fib2;
fib2 = fib;
}
return fib;
}

@Override
public String getName() {
return "Fibonacci: non-recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};
</code=java>

Aufruf wie folgt:

<code=java>
public static void main(String[] args) {
QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
}
</code=java>

Als Ergebnis erhält man ungefähr folgende Ausgabe:

<nowiki>
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | min | max | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Fibonacci: recursive | 10 | 1 | 25 | 0 | 0 | 8.312.579 | 831.257 |
| Fibonacci: recursive | 100 | 1 | 25 | 93 | 0 | ... | ... |
| Fibonacci: recursive | 1.000 | 1 | 25 | 812 | 0 | ... | ... |
| Fibonacci: non-recursive | 10 | 1 | 25 | 0 | 0 | 25.911 | 2.591 |
| Fibonacci: non-recursive | 100 | 1 | 25 | 0 | 0 | 241.581 | 2.415 |
| Fibonacci: non-recursive | 1.000 | 1 | 25 | 0 | 0 | 1.974.832 | 1.974 |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Formatierte Tabellen auf der Console ausgeben

2013-08-07T15:01:38Z

Fastjack: Die Seite wurde neu angelegt: „Kategorie:Java Die folgende Klasse kann auf einfache Art und Weise eine formatierte Texttabelle als String erzeugen. Dabei können zusätzlich die Formatierun…“

[[Kategorie:Java]]
Die folgende Klasse kann auf einfache Art und Weise eine formatierte Texttabelle als String erzeugen. Dabei können zusätzlich die Formatierungseigenschaften der Klasse java.util.Formatter verwendet werden. Die Formatierung ähnelt den Konsolenausgaben von MySQL-Anfragen. Viel Spaß!

<nowiki>
/*
* Table.java
*
* 14.10.2010
*
* (c) fastjack
*/

package blog.text;

import java.util.*;

/**
* This class defines a simple formatted text table. It can be used to create simple formatted
* text tables (like MySQL console outputs) with the formatting stuff from class
* "java.util.Formatter" defined in the enumerations.
*
* @author fastjack
*/
public class Table {
private List<Col> cols = new ArrayList<Col>();
private List<Row> rows = new ArrayList<Row>();

/**
* Adds a col.
*
* @param name the name
* @return the table
*/
public Table addCol(String name) {
this.cols.add(new Col(name));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Flags... flags) {
this.cols.add(new Col(name, null, flags));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param conversion the conversion
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Conversions conversion, Flags... flags) {
this.cols.add(new Col(name, conversion, flags));
return this;
}

/**
* Adds a col.
*
* @param name the name
* @param conversion the conversion
* @param dtconversion the date/timeconversion
* @param flags the flags
* @return the table
*/
public Table addCol(String name, Conversions conversion, DateTimeConversions dtconversion,
Flags... flags) {
this.cols.add(new Col(name, conversion, dtconversion, flags));
return this;
}

/**
* Gets the col size.
*
* @return the col size
*/
public int getColSize() {
return this.cols.size();
}

/**
* Gets the col.
*
* @param index the index
* @return the col
*/
public Col getCol(int index) {
return this.cols.get(index);
}

/**
* Gets the row size.
*
* @return the row size
*/
public int getRowSize() {
return this.rows.size();
}

/**
* Gets the row.
*
* @param index the index
* @return the row
*/
public Row getRow(int index) {
return this.rows.get(index);
}

/**
* Adds the row.
*
* @param values the values
*/
public void addRow(Object... values) {
this.rows.add(new Row(values));
}

@Override
public String toString() {
StringBuilder s1 = new StringBuilder();
StringBuilder s2 = new StringBuilder();
// data
for (int i = 0, n = this.rows.size(); i < n; i++) {
Row r = this.rows.get(i);
for (int ii = 0, nn = this.cols.size(); ii < nn; ii++) {
Col c = this.cols.get(ii);
Object o = r.getValue(ii);
if (c.getConversion() == null) {
c.setConversion(this.getConversionForType(o));
}
int nl = Math.max(c.getName().length(), String.valueOf(o).length());
if (nl > c.getWidth()) {
c.width = nl;
}
int ol = String.format(this.getToken(o, c.getWidth(), c.getConversion(),
c.getDateTimeConversion(), c.getFlags()), o).length();
if (ol > c.getWidth()) {
c.width = ol;
}
}
}
for (int i = 0, n = this.rows.size(); i < n; i++) {
Row r = this.rows.get(i);
StringBuilder data = new StringBuilder();
for (int ii = 0, nn = this.cols.size(); ii < nn; ii++) {
Col c = this.cols.get(ii);
Object o = r.getValue(ii);
data.append("| ");
data.append(this.getToken(o, c.getWidth(), c.getConversion(),
c.getDateTimeConversion(), c.getFlags()));
if (ii < nn - 1) {
data.append(" ");
}
}
data.append(" |\n");
s2.append(String.format(data.toString(), r.getValues()));
}
// head
StringBuilder sep = new StringBuilder();
StringBuilder begin = new StringBuilder();
StringBuilder end = new StringBuilder();
StringBuilder head = new StringBuilder();
Object[] oa = new Object[this.cols.size()];
for (int i = 0, n = this.cols.size(); i < n; i++) {
Col c = this.cols.get(i);
oa[i] = c.getName();
if (i == 0) {
begin.append("+");
end.append("+");
sep.append("+");
} else {
begin.append("+");
end.append("+");
sep.append("+");
}
head.append("| %");
head.append(String.valueOf(c.getWidth()));
head.append("s");
for (int ii = 0; ii < c.getWidth() + 2; ii++) {
begin.append("-");
sep.append("-");
end.append("-");
}
if (i < n - 1) {
head.append(" ");
}
}
begin.append("+\n");
sep.append("+\n");
end.append("+\n");
head.append(" |\n");
s1.append(begin);
s1.append(String.format(head.toString(), oa));
s1.append(sep);
s1.append(s2);
s1.append(end);
return s1.toString();
}

private String getToken(Object object, int width, Conversions conversion,
DateTimeConversions dtconversion, Flags... flags) {
StringBuilder s = new StringBuilder();
s.append("%");
if (flags != null && flags.length > 0) {
for (int i = 0; i < flags.length; i++) {
Flags f = flags[i];
s.append(f.getToken());
}
}
if (width > 0) {
s.append(width);
}
if (conversion != null) {
s.append(conversion.getToken());
} else {
s.append(this.getConversionForType(object).getToken());
}
if (dtconversion != null) {
s.append(dtconversion.getToken());
}
return s.toString();
}

private Conversions getConversionForType(Object object) {
if (object instanceof Byte) {
return Conversions.DECIMAL;
} else if (object instanceof Short) {
return Conversions.DECIMAL;
} else if (object instanceof Integer) {
return Conversions.DECIMAL;
} else if (object instanceof Character) {
return Conversions.CHARACTER;
} else if (object instanceof Long) {
return Conversions.DECIMAL;
} else if (object instanceof Float) {
return Conversions.FLOAT;
} else if (object instanceof Double) {
return Conversions.FLOAT;
} else if (object instanceof Boolean) {
return Conversions.BOOLEAN;
} else if (object instanceof String) {
return Conversions.STRING;
} else {
return Conversions.STRING;
}
}
</nowiki>

Die Klasse für die Zeilen:

<nowiki>
/**
* This class defines a row, containing an object arry with values.
*/
public class Row {
private Object[] values = null;

/**
* Instantiates a new row.
*
* @param values the values
*/
public Row(Object[] values) {
super();
this.values = values;
}

/**
* Gets the value.
*
* @param index the index
* @return the value
*/
public Object getValue(int index) {
return this.values[index];
}

/**
* Gets the values.
*
* @return the values
*/
public Object[] getValues() {
return this.values;
}
}
</nowiki>

Die Klasse für die Spalten:

<nowiki>
/**
* This class defines a column.
*/
public class Col {
private Flags[] flags = null;
private Conversions conversion = null;
private DateTimeConversions dateTimeConversion = null;
private String name = "";
private int width = 0;

/**
* Instantiates a new col.
*
* @param name the name
*/
public Col(String name) {
this(name, null);
}

/**
* Instantiates a new col.
*
* @param name the name
* @param conversion the conversion
* @param flags the flags
*/
public Col(String name, Conversions conversion, Flags... flags) {
this(name, conversion, null, flags);
}

/**
* Instantiates a new col.
*
* @param name the name
* @param conversion the conversion
* @param dateTimeConversion the date time conversion
* @param flags the flags
*/
public Col(String name, Conversions conversion, DateTimeConversions dateTimeConversion,
Flags... flags) {
super();
this.dateTimeConversion = dateTimeConversion;
this.conversion = conversion;
this.flags = flags;
this.name = name;
this.width = this.name.length();
}

/**
* Gets the name.
*
* @return the name
*/
public String getName() {
return this.name;
}

/**
* Gets the conversion.
*
* @return the conversion
*/
public Conversions getConversion() {
return this.conversion;
}

/**
* Sets the conversion.
*
* @param conversion the new conversion
*/
public void setConversion(Conversions conversion) {
this.conversion = conversion;
}

/**
* Gets the width.
*
* @return the width
*/
public int getWidth() {
return this.width;
}

/**
* Gets the flags.
*
* @return the flags
*/
public Flags[] getFlags() {
return this.flags;
}

/**
* Gets the date time conversion.
*
* @return the date time conversion
*/
public DateTimeConversions getDateTimeConversion() {
return this.dateTimeConversion;
}

}
</nowiki>

Die Flaggen:

<nowiki>
/**
* This enumeration defines the flags.
*/
public enum Flags {
LEFT("-"),
CONVERSION_DEPENDENT("#"),
SIGN("+"),
POSITIVE_LEADING_SPACE(" "),
ZERO_PADDING("0"),
LOCALE_GROUPING_SEPARATORS(","),
PARENTHESES_FOR_NEGATIVES("(");

String token = "";

/**
* Instantiates a new flag.
*
* @param token the token
*/
Flags(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}
}
</nowiki>

Die Konversionen:

<nowiki>
/**
* This enumeration defines conversions.
*/
public enum Conversions {
BOOLEAN("b"),
CHARACTER("c"),
DATE_TIME("t"),
DECIMAL("d"),
FLOAT("f"),
FLOAT_HEX("a"),
FLOAT_SCIENCE("e"),
FLOAT_SCIENCE_PREC("g"),
HEX("h"),
HEX_INT("h"),
LINE_SEPARATOR("n"),
OCTAL("o"),
PERCENT("%"),
STRING("s");

String token = "";

/**
* Instantiates a new conversion.
*
* @param token the token
*/
Conversions(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}

}
</nowiki>

Zeit/Datums- Konversionen:

<nowiki>
/**
* This enumeration defines date/time conversions.
*/
public enum DateTimeConversions {
FULL_MONTH_NAME("B"),
ABBREVATED_MONTH_NAME("b"),
ABBREVATED_MONTH_NAME_H("h"),
FULL_DAY_OF_THE_WEEK_NAME("A"),
SHORT_DAY_OF_THE_WEEK_NAME("a"),
FOUR_DIGIT_YEAR("C"),
LEADING_ZEROS_YEAR("Y"),
LAST_TWO_DIGITS_YEAR("y"),
THREE_DIGIT_DAY_OF_THE_YEAR("j"),
TWO_DIGIT_MONTH("m"),
TWO_DIGIT_DAY_OF_MONTH("d"),
DAY_OF_MONTH("e"),
HOUR_OF_DAY_LEADING_24("H"),
HOUR_OF_DAY_LEADING_12("I"),
HOUR_OF_DAY_24("k"),
HOUR_OF_DAY_12("l"),
TWO_DIGIT_MINUTE("M"),
TWO_DIGIT_SECOND("S"),
THREE_DIGIT_MILLISECOND("L"),
TWO_DIGIT_NANOSECOND("N"),
MORING_AFTERNOON_MARKER("p"),
RFC822_TIME_ZONE_OFFSET("z"),
TIME_ZONE_ABBREVATION("Z"),
BEGINNING_SECONDS("s"),
BEGINNING_MILLISECONDS("Q"),
TIME_HOUR_CLOCK_24("R"),
LONG_TIME_HOUR_CLOCK_24("T"),
TIME_HOUR_CLOCK_12("r"),
LONG_DATE("D"),
ISO8601_DATE("F"),
FULL_DATE("c");

String token = "";

/**
* Instantiates a new date time conversion.
*
* @param token the token
*/
DateTimeConversions(String token) {
this.token = token;
}

/**
* Gets the token.
*
* @return the token
*/
String getToken() {
return token;
}
}

}
</nowiki>

Der folgende Anwendungsfall:

<nowiki>
public static void main(String[] args) {
Table t = new Table();
t = t.addCol("char", Flags.LEFT)
.addCol("byte", Flags.ZERO_PADDING)
.addCol("short", Flags.PARENTHESES_FOR_NEGATIVES, Flags.LEFT)
.addCol("int", Flags.LOCALE_GROUPING_SEPARATORS)
.addCol("long", Flags.LOCALE_GROUPING_SEPARATORS, Flags.SIGN)
.addCol("float", Conversions.FLOAT_HEX)
.addCol("double", Conversions.FLOAT_SCIENCE)
.addCol("boolean")
.addCol("string")
.addCol("object")
.addCol("null")
.addCol("Date", Conversions.DATE_TIME, DateTimeConversions.FULL_DATE);
t.addRow('a', (byte) 1, (short) 1, 100, 100L, 1.0F, 1.0, true, "ab", new Object(), null,
new Date());
t.addRow('a', (byte) 1, (short) -1, 1000, 1000L, 1.0F, 1.0, false, "abbas", new Object(), null,
new Date());
t.addRow('a', (byte) 1, (short) 1, 10000, -10000L, 1.0F, 1.0, true, "sdhjsdhjdsghsdghds",
new Object(), null, new Date());
Col c = t.getCol(0);
System.out.println(t);
}
</nowiki>

Erzeugt die Ausgabe:

<nowiki>
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
| char | byte | short | int | long | float | double | boolean | string | object | null | Date |
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
| a | 0001 | 1 | 100 | +100 | 0x1.0p0 | 1,000000e+00 | true | ab | java.lang.Object@1e97676 | null | So Apr 03 17:46:15 MESZ 2011 |
| a | 0001 | (1) | 1.000 | +1.000 | 0x1.0p0 | 1,000000e+00 | false | abbas | java.lang.Object@7bd9f2 | null | So Apr 03 17:46:15 MESZ 2011 |
| a | 0001 | 1 | 10.000 | -10.000 | 0x1.0p0 | 1,000000e+00 | true | sdhjsdhjdsghsdghds | java.lang.Object@121cc40 | null | So Apr 03 17:46:15 MESZ 2011 |
+------+------+-------+--------+---------+---------+--------------+---------+--------------------+--------------------------+------+-------------------------------+
</nowiki>

Weihnachtsbaum

2013-08-07T14:54:05Z

Fastjack: Die Seite wurde neu angelegt: „Kategorie:Java Da viele immer mal wieder einen Weihnachtsbaum erstellen möchten, stelle ich mal meinen vor Wem es hilft, der kann sich gerne bedienen. Viel…“

[[Kategorie:Java]]

Da viele immer mal wieder einen Weihnachtsbaum erstellen möchten, stelle ich mal meinen vor Wem es hilft, der kann sich gerne bedienen.

Viel Spaß!

<nowiki>
/*
* ChristmasTreeTest.java
*
* 05.01.2012
*
* Copyright 2012 fastjack
*/
package blog.tree;

import org.junit.*;

import static org.junit.Assert.*;

public class ChristmasTreeTest {
private static final String LINE_END = System.getProperty("line.separator");

@Test(expected=IllegalArgumentException.class)
public void failCreateWithNegativeHigh() {
new ChristmasTree(-1);
}

@Test(expected=IllegalArgumentException.class)
public void failCreateWithZeroHigh() {
new ChristmasTree(0);
}

@Test
public void shouldCreateWithHighOfOne() {
StringBuilder expected = new StringBuilder();
expected.append("*").append(LINE_END);
expected.append("|").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(1).toString());
}

@Test
public void shouldCreateWithHighOfTwo() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append("***").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(2).toString());
}

@Test
public void shouldCreateWithHighOfThree() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append("*****").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(3).toString());
}

@Test
public void shouldCreateWithHighOfFour() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append(" ***** ").append(LINE_END);
expected.append("*******").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(4).toString());
}

@Test
public void shouldCreateWithHighOfFive() {
StringBuilder expected = new StringBuilder();
expected.append(" * ").append(LINE_END);
expected.append(" *** ").append(LINE_END);
expected.append(" ***** ").append(LINE_END);
expected.append(" ******* ").append(LINE_END);
expected.append("*********").append(LINE_END);
expected.append(" | ").append(LINE_END);
assertEquals("christmas tree was not correct!", expected.toString(),
new ChristmasTree(5).toString());
}

}
</nowiki>

<nowiki>
/*
* ChristmasTree.java
*
* 05.01.2012
*
* Copyright 2012 fastjack
*/
package blog.tree;

import org.apache.commons.lang.*;

/**
* This class defines a christmas tree. After construction the tree can represented as String
* via the toString() method.
*
* <pre>
* System.out.println(new ChristmasTree(3).toString());
* </pre>
*
* prints out a christmas tree with a height of three in form:
*
* <pre>
* *
* ***
* *****
* |
* </pre>
*
* the idea for defined height n is
*
* <pre>
* // 2n-1 lines for body
* * // for actual row (beginning at zero) r print out 2(r+1)-1 stars
* *** //
* |.| // if actual column is in star printing area |.| including the | then print a star
* |.| // otherwise a space
* ***** //
* | // and a separate line for the centered trunk
* </pre>
*
* @author fastjack
*/
public class ChristmasTree {
private static final String TRUNK = "|";
private static final String SPACE = " ";
private static final String STAR = "*";
private static final String LINE_END = System.getProperty("line.separator");
private int height;
private int maxTreeWidth;
private int halfOfTreeWidth;

/**
* Creates a christmas tree for the defined height.
*
* @param height the height of the tree must be greater than zero
*/
public ChristmasTree(int height) {
Validate.isTrue(height > 0, "height must be greater than zero!");
this.height = height;
maxTreeWidth = 2 * height - 1;
halfOfTreeWidth = maxTreeWidth / 2;
}

@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append(makeBody());
s.append(makeBottomLineWithTrunk());
return s.toString();
}

private String makeBody() {
StringBuilder lines = new StringBuilder();
for(int row = 0; row < height; row ++) {
int numberOfStarsInRow = getNumberOfStarsInRow(row);
int startOfStarPrinting = getStartColumnToPrintStars(numberOfStarsInRow);
int endOfStarPrinting = startOfStarPrinting + numberOfStarsInRow;
lines.append(makeLine(startOfStarPrinting, endOfStarPrinting));
}
return lines.toString();
}

private int getNumberOfStarsInRow(int row) {
return 2 * (row + 1) - 1;
}

private int getStartColumnToPrintStars(int numberOfStarsInRow) {
return halfOfTreeWidth - (numberOfStarsInRow / 2);
}

private StringBuilder makeLine(int startOfStarPrinting, int endOfStarPrinting) {
StringBuilder line = new StringBuilder();
for(int column = 0; column < maxTreeWidth; column ++) {
if (isStarToPrint(startOfStarPrinting, endOfStarPrinting, column)) {
line.append(STAR);
} else {
line.append(SPACE);
}
}
line.append(LINE_END);
return line;
}

private boolean isStarToPrint(int startOfStarPrinting, int endOfStarPrinting, int column) {
return column >= startOfStarPrinting && column < endOfStarPrinting;
}

private String makeBottomLineWithTrunk() {
StringBuilder bottom = new StringBuilder();
for(int column = 0; column < maxTreeWidth; column ++) {
if (column == maxTreeWidth / 2) {
bottom.append(TRUNK);
} else {
bottom.append(SPACE);
}
}
bottom.append(LINE_END);
return bottom.toString();
}

}
</nowiki>

Benchmarks

2013-08-07T14:50:57Z

Fastjack:

[[Kategorie:Java]]

Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach kommentieren.

Das Interface Bench:

<nowiki>
/*
* Bench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Schnittstelle beschreibt einen Benchmark.
*
* @author fastjack
* @version 1.0
*/
public interface Bench {

/**
* @return der Name.
*/
String getName();

/**
* setzt den Benchmark und alle Resourcen, die er benutzt in den Urzustand zurück.
*/
void reset();

/**
* Bereitet den Benchmark zur Ausführung vor.
*
* @param lm Parameter anhand dessen der Benchmark vorbereitet wird.
*/
void prepare(long lm);

/**
* Führt den Benchmark aus.
*
* @param lm Parameter anhand dessen der Benchmark ausgeführt wird.
*/
void execute(long lm);
}

</nowiki>

Die abstrakte Klasse Bench:

<nowiki>
/*
* AbstractBench.java
*
* 06.01.2011
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Klasse stellt einen abstrakten Benchmark dar.
*
* @author fastjack
* @version 1.0
*/
public abstract class AbstractBench implements Bench {

@Override
public String getName() {
return this.getClass().getSimpleName();
}

@Override
public void prepare(long lm) {
}

@Override
public void reset() {
}

}

</nowiki>

Das Benchmarksystem QuickBench:

<nowiki>
/*
* QuickBench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

import java.util.*;

/**
* Diese kleine Klasse soll ein einfaches Benchmarksystem darstellen.
*
* @author fastjack
* @version 1.0
*/
public class QuickBench {

private final static String headerNxMSep = "+---------------------------+----------+-------"
+ "-----+----------+----------+-----------------+-----------------+";
private final static String headerNxM = "| %-25s | %8s | %10s | %8s | %8s | %15s | %15s "
+ "|\n";
private final static String headerNxIntervallSep = "+---------------------------+----------"
+ "+------------+------------+----------+----------+-----------------+-------------"
+ "----+";
private final static String headerNxIntervall = "| %-25s | %8s | %10s | %10s | %8s | %8s | "
+ "%15s | %15s |\n";
private final static String patternNxM = "| %-25s | %,8d | %,10d | %,8d | %,8d | %,15d | "
+ "%,15d |\n";
private final static String patternNxMWNT = "| %-25s | %,8d | %,10d | %,8d | %,8d | %15s | "
+ "%15s |\n";
private final static String patternNxIntervall = "| %-25s | %,8d | %,10d | %,10d | %,8d | "
+ "%,8d | %,15d | %,15d |\n";
private final static String patternNxIntervallWNT = "| %-25s | %,8d | %,10d | %,10d | %,8d "
+ "| %,8d | %15s | %15s |\n";

private QuickBench() {
}

/**
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet. Bevor das Benchmarking
* gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch den
* Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Alle Benchmarks werden zu jedem Eintrag e in n i-mal (i <= e) wiederholt,
* jeweils mit einem Wert aus dem dem angegebenen Intervall.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
* @param ba Benchmarks.
*/
public static void benchNxIntervall(long minMs, long wm, long[] n, long mmin, long mmax,
Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxIntervallSep);
System.out.printf(headerNxIntervall, "Bench", "Rounds", "min", "max", "ms",
"ms (avg)", "nt", "nt (avg)");
System.out.println(headerNxIntervallSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
qb.executeIntervall(b, n, minMs, mmin, mmax);
}
System.out.println(headerNxIntervallSep);
qb.showInfo();
}

/**
* Führt Benchmarks, die z.B. einer Anzahl von Objekten basieren, aus. Der Benchmark
* wird zurerst zurückgesetzt und jeweils zu einem Wert aus m vorbereitet. Bevor das
* Benchmarking gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch
* den Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Die Anzahl der Objekte im Feld m. Alle Benchmarks werden zu jedem Eintrag m0
* in m i-mal (i <= m0) durchlaufen und zu jedem Eintrag n0 in n j-mal (j <= n0)
* zu dem Wert m0 ausgeführt.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param m Anzahl an z.B. Objekten.
* @param ba Benchmarks.
*/
public static void benchNxM(long minMs, long wm, long[] n, long[] m, Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxMSep);
System.out.printf(headerNxM, "Bench", "Rounds", "Objects", "ms", "ms (avg)",
"nt", "nt (avg)");
System.out.println(headerNxMSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
for (int ii = 0; ii < m.length; ii++) {
qb.execute(b, n, minMs, m[ii]);
}
}
System.out.println(headerNxMSep);
qb.showInfo();
}

/*
* Zeigt Informationen zum System an.
*/
private void showInfo() {
System.out.println("java version " + System.getProperty("java.version"));
System.out.println(System.getProperty("java.runtime.name") + "(build " +
System.getProperty("java.runtime.version") + ")");
System.out.println(System.getProperty("java.vm.name") + "(build "
+ System.getProperty("java.vm.version") + ", "
+ System.getProperty("java.vm.info") + ")");
System.out.println(System.getProperty("os.name") + "("
+ System.getProperty("os.version") + ") " + System.getProperty("os.arch"));
System.out.println("Max memory: " + Runtime.getRuntime().maxMemory() / (1024 * 1024)
+ "MB");
}

/*
* Führt ein warmup zu allen Benchmarks durch. Dabei werden die Benches jeweils mit den
* Werten 1 vorbereitet und ausgeführt.
*
* @param ba Benchmarks.
* @param n Anzahl an Durchläufen zum WarmUp.
*/
private void warmup(Bench[] ba, long n) {
for (int i = 0; i < n; i++) {
for (int ii = 0; ii < ba.length; ii++) {
Bench b = ba[ii];
b.reset();
b.prepare(1);
b.execute(1);
}
}
}

/*
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
*/
private void executeIntervall(Bench b, long[] n, long minMs, long mmin, long mmax) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
for (long l = mmin; l < mmax; l++) {
b.reset();
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(l);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
}
if (ms < minMs) {
System.out.printf(patternNxIntervall, b.getName(), ln, mmin, mmax, ms, ms / ln,
nt, (nt / ln));
} else {
System.out.printf(patternNxIntervallWNT, b.getName(), ln, mmin, mmax, ms,
ms / ln, "...", "...");
}
}
}

/*
* Führt Benchmarks zu einem gegebenen Wert aus. Der Benchmark wird zurerst
* zurückgesetzt und zu dem Wert val vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param val Wert.
*/
private void execute(Bench b, long[] n, long minMs, long val) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
b.reset();
b.prepare(val);
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(val);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
if (ms < minMs) {
System.out.printf(patternNxM, b.getName(), ln, val, ms, ms / ln, nt, (nt / ln));
} else {
System.out.printf(patternNxMWNT, b.getName(), ln, val, ms, ms / ln, "...",
"...");
}
}
}
}
</nowiki>

Ein kleines Beispiel zum Traversieren einer Liste (NxM):

<nowiki>
Bench b0 = new Bench() {
List<String> l = null;

@Override
public String getName() {
return "Traverse";
}

@Override
public void reset() {
l = new ArrayList<String>();
}

@Override
public void prepare(long lm) {
for (int i = 0; i < lm; i++) {
l.add(String.valueOf(i));
}
}

@Override
public void execute(long lm) {
for (int i = 0, n = l.size(); i < n; i++) {
String s = l.get(i);
}
}
};
</nowiki>

Benutzung:

<nowiki>
...
QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
new Bench[] { b0 });
...

</nowiki>

Als Ergebnis erhält man folgendes:

<nowiki>
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | Objects | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Traverse ArrayList For | 10 | 10.000 | 0 | 0 | 1.945.638 | 194.563 |
| Traverse ArrayList For | 100 | 10.000 | 16 | 0 | ... | ... |
| Traverse ArrayList For | 1.000 | 10.000 | 171 | 0 | ... | ... |
| Traverse ArrayList For | 10 | 100.000 | 16 | 1 | ... | ... |
| Traverse ArrayList For | 100 | 100.000 | 109 | 1 | ... | ... |
| Traverse ArrayList For | 1.000 | 100.000 | 1.170 | 1 | ... | ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Legende:

<nowiki>
Bench: Name des Benchmarks.
Rounds: Anzahl an Durchläufen.
Objects: Anzahl an verwendeteten Objekten.
ms: Gesamtzeitbedarf in Millisekunden.
ms (avg): Durchschnittlicher Zeitbedarf in Millisekunden.
nt: Gesamtzeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
nt (avg): Durchschnittlicher Zeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
</nowiki>

Weitere Beispiele folgen...

Und zwar jetzt:

Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

<nowiki>
/* fibonacci -> recursive */
static class FibBench_Recursive extends AbstractBench {

private int fib(int a) {
if (a == 1 || a == 2) {
return 1;
} else {
return fib(a - 1) + fib(a - 2);
}
}

@Override
public String getName() {
return "Fibonacci: recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};

/* fibonacci -> non-recursive */
static class FibBench_NonRecursive extends AbstractBench {

private long fib(int a) {
long fib = 1;
for (long fib1 = 1, fib2 = 1, i = 3; i <= a; i++) {
fib = fib1 + fib2;
fib1 = fib2;
fib2 = fib;
}
return fib;
}

@Override
public String getName() {
return "Fibonacci: non-recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};
</nowiki>

Aufruf wie folgt:

<nowiki>
public static void main(String[] args) {
QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
}
</nowiki>

Als Ergebnis erhält man ungefähr folgende Ausgabe:

<nowiki>
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | min | max | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Fibonacci: recursive | 10 | 1 | 25 | 0 | 0 | 8.312.579 | 831.257 |
| Fibonacci: recursive | 100 | 1 | 25 | 93 | 0 | ... | ... |
| Fibonacci: recursive | 1.000 | 1 | 25 | 812 | 0 | ... | ... |
| Fibonacci: non-recursive | 10 | 1 | 25 | 0 | 0 | 25.911 | 2.591 |
| Fibonacci: non-recursive | 100 | 1 | 25 | 0 | 0 | 241.581 | 2.415 |
| Fibonacci: non-recursive | 1.000 | 1 | 25 | 0 | 0 | 1.974.832 | 1.974 |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Benchmarks

2013-08-07T14:42:42Z

Fastjack: Die Seite wurde neu angelegt: „Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System …“

Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach kommentieren.

Das Interface Bench:

<nowiki>
/*
* Bench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Schnittstelle beschreibt einen Benchmark.
*
* @author fastjack
* @version 1.0
*/
public interface Bench {

/**
* @return der Name.
*/
String getName();

/**
* setzt den Benchmark und alle Resourcen, die er benutzt in den Urzustand zurück.
*/
void reset();

/**
* Bereitet den Benchmark zur Ausführung vor.
*
* @param lm Parameter anhand dessen der Benchmark vorbereitet wird.
*/
void prepare(long lm);

/**
* Führt den Benchmark aus.
*
* @param lm Parameter anhand dessen der Benchmark ausgeführt wird.
*/
void execute(long lm);
}

</nowiki>

Die abstrakte Klasse Bench:

<nowiki>
/*
* AbstractBench.java
*
* 06.01.2011
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Klasse stellt einen abstrakten Benchmark dar.
*
* @author fastjack
* @version 1.0
*/
public abstract class AbstractBench implements Bench {

@Override
public String getName() {
return this.getClass().getSimpleName();
}

@Override
public void prepare(long lm) {
}

@Override
public void reset() {
}

}

</nowiki>

Das Benchmarksystem QuickBench:

<nowiki>
/*
* QuickBench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

import java.util.*;

/**
* Diese kleine Klasse soll ein einfaches Benchmarksystem darstellen.
*
* @author fastjack
* @version 1.0
*/
public class QuickBench {

private final static String headerNxMSep = "+---------------------------+----------+-------"
+ "-----+----------+----------+-----------------+-----------------+";
private final static String headerNxM = "| %-25s | %8s | %10s | %8s | %8s | %15s | %15s "
+ "|\n";
private final static String headerNxIntervallSep = "+---------------------------+----------"
+ "+------------+------------+----------+----------+-----------------+-------------"
+ "----+";
private final static String headerNxIntervall = "| %-25s | %8s | %10s | %10s | %8s | %8s | "
+ "%15s | %15s |\n";
private final static String patternNxM = "| %-25s | %,8d | %,10d | %,8d | %,8d | %,15d | "
+ "%,15d |\n";
private final static String patternNxMWNT = "| %-25s | %,8d | %,10d | %,8d | %,8d | %15s | "
+ "%15s |\n";
private final static String patternNxIntervall = "| %-25s | %,8d | %,10d | %,10d | %,8d | "
+ "%,8d | %,15d | %,15d |\n";
private final static String patternNxIntervallWNT = "| %-25s | %,8d | %,10d | %,10d | %,8d "
+ "| %,8d | %15s | %15s |\n";

private QuickBench() {
}

/**
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet. Bevor das Benchmarking
* gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch den
* Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Alle Benchmarks werden zu jedem Eintrag e in n i-mal (i <= e) wiederholt,
* jeweils mit einem Wert aus dem dem angegebenen Intervall.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
* @param ba Benchmarks.
*/
public static void benchNxIntervall(long minMs, long wm, long[] n, long mmin, long mmax,
Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxIntervallSep);
System.out.printf(headerNxIntervall, "Bench", "Rounds", "min", "max", "ms",
"ms (avg)", "nt", "nt (avg)");
System.out.println(headerNxIntervallSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
qb.executeIntervall(b, n, minMs, mmin, mmax);
}
System.out.println(headerNxIntervallSep);
qb.showInfo();
}

/**
* Führt Benchmarks, die z.B. einer Anzahl von Objekten basieren, aus. Der Benchmark
* wird zurerst zurückgesetzt und jeweils zu einem Wert aus m vorbereitet. Bevor das
* Benchmarking gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch
* den Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Die Anzahl der Objekte im Feld m. Alle Benchmarks werden zu jedem Eintrag m0
* in m i-mal (i <= m0) durchlaufen und zu jedem Eintrag n0 in n j-mal (j <= n0)
* zu dem Wert m0 ausgeführt.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param m Anzahl an z.B. Objekten.
* @param ba Benchmarks.
*/
public static void benchNxM(long minMs, long wm, long[] n, long[] m, Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxMSep);
System.out.printf(headerNxM, "Bench", "Rounds", "Objects", "ms", "ms (avg)",
"nt", "nt (avg)");
System.out.println(headerNxMSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
for (int ii = 0; ii < m.length; ii++) {
qb.execute(b, n, minMs, m[ii]);
}
}
System.out.println(headerNxMSep);
qb.showInfo();
}

/*
* Zeigt Informationen zum System an.
*/
private void showInfo() {
System.out.println("java version " + System.getProperty("java.version"));
System.out.println(System.getProperty("java.runtime.name") + "(build " +
System.getProperty("java.runtime.version") + ")");
System.out.println(System.getProperty("java.vm.name") + "(build "
+ System.getProperty("java.vm.version") + ", "
+ System.getProperty("java.vm.info") + ")");
System.out.println(System.getProperty("os.name") + "("
+ System.getProperty("os.version") + ") " + System.getProperty("os.arch"));
System.out.println("Max memory: " + Runtime.getRuntime().maxMemory() / (1024 * 1024)
+ "MB");
}

/*
* Führt ein warmup zu allen Benchmarks durch. Dabei werden die Benches jeweils mit den
* Werten 1 vorbereitet und ausgeführt.
*
* @param ba Benchmarks.
* @param n Anzahl an Durchläufen zum WarmUp.
*/
private void warmup(Bench[] ba, long n) {
for (int i = 0; i < n; i++) {
for (int ii = 0; ii < ba.length; ii++) {
Bench b = ba[ii];
b.reset();
b.prepare(1);
b.execute(1);
}
}
}

/*
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
*/
private void executeIntervall(Bench b, long[] n, long minMs, long mmin, long mmax) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
for (long l = mmin; l < mmax; l++) {
b.reset();
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(l);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
}
if (ms < minMs) {
System.out.printf(patternNxIntervall, b.getName(), ln, mmin, mmax, ms, ms / ln,
nt, (nt / ln));
} else {
System.out.printf(patternNxIntervallWNT, b.getName(), ln, mmin, mmax, ms,
ms / ln, "...", "...");
}
}
}

/*
* Führt Benchmarks zu einem gegebenen Wert aus. Der Benchmark wird zurerst
* zurückgesetzt und zu dem Wert val vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param val Wert.
*/
private void execute(Bench b, long[] n, long minMs, long val) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
b.reset();
b.prepare(val);
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(val);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
if (ms < minMs) {
System.out.printf(patternNxM, b.getName(), ln, val, ms, ms / ln, nt, (nt / ln));
} else {
System.out.printf(patternNxMWNT, b.getName(), ln, val, ms, ms / ln, "...",
"...");
}
}
}
}
</nowiki>

Ein kleines Beispiel zum Traversieren einer Liste (NxM):

<nowiki>
Bench b0 = new Bench() {
List<String> l = null;

@Override
public String getName() {
return "Traverse";
}

@Override
public void reset() {
l = new ArrayList<String>();
}

@Override
public void prepare(long lm) {
for (int i = 0; i < lm; i++) {
l.add(String.valueOf(i));
}
}

@Override
public void execute(long lm) {
for (int i = 0, n = l.size(); i < n; i++) {
String s = l.get(i);
}
}
};
</nowiki>

Benutzung:

<nowiki>
...
QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
new Bench[] { b0 });
...

</nowiki>

Als Ergebnis erhält man folgendes:

<nowiki>
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | Objects | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Traverse ArrayList For | 10 | 10.000 | 0 | 0 | 1.945.638 | 194.563 |
| Traverse ArrayList For | 100 | 10.000 | 16 | 0 | ... | ... |
| Traverse ArrayList For | 1.000 | 10.000 | 171 | 0 | ... | ... |
| Traverse ArrayList For | 10 | 100.000 | 16 | 1 | ... | ... |
| Traverse ArrayList For | 100 | 100.000 | 109 | 1 | ... | ... |
| Traverse ArrayList For | 1.000 | 100.000 | 1.170 | 1 | ... | ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Legende:

<nowiki>
Bench: Name des Benchmarks.
Rounds: Anzahl an Durchläufen.
Objects: Anzahl an verwendeteten Objekten.
ms: Gesamtzeitbedarf in Millisekunden.
ms (avg): Durchschnittlicher Zeitbedarf in Millisekunden.
nt: Gesamtzeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
nt (avg): Durchschnittlicher Zeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
</nowiki>

Weitere Beispiele folgen...

Und zwar jetzt:

Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

<nowiki>
/* fibonacci -> recursive */
static class FibBench_Recursive extends AbstractBench {

private int fib(int a) {
if (a == 1 || a == 2) {
return 1;
} else {
return fib(a - 1) + fib(a - 2);
}
}

@Override
public String getName() {
return "Fibonacci: recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};

/* fibonacci -> non-recursive */
static class FibBench_NonRecursive extends AbstractBench {

private long fib(int a) {
long fib = 1;
for (long fib1 = 1, fib2 = 1, i = 3; i <= a; i++) {
fib = fib1 + fib2;
fib1 = fib2;
fib2 = fib;
}
return fib;
}

@Override
public String getName() {
return "Fibonacci: non-recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};
</nowiki>

Aufruf wie folgt:

<nowiki>
public static void main(String[] args) {
QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
}
</nowiki>

Als Ergebnis erhält man ungefähr folgende Ausgabe:

<nowiki>
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | min | max | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Fibonacci: recursive | 10 | 1 | 25 | 0 | 0 | 8.312.579 | 831.257 |
| Fibonacci: recursive | 100 | 1 | 25 | 93 | 0 | ... | ... |
| Fibonacci: recursive | 1.000 | 1 | 25 | 812 | 0 | ... | ... |
| Fibonacci: non-recursive | 10 | 1 | 25 | 0 | 0 | 25.911 | 2.591 |
| Fibonacci: non-recursive | 100 | 1 | 25 | 0 | 0 | 241.581 | 2.415 |
| Fibonacci: non-recursive | 1.000 | 1 | 25 | 0 | 0 | 1.974.832 | 1.974 |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>