Blinded by the lights

Usually to print some ouptut you’d use System.out.printl() or System.out.println() method. It’s easy to use but you can face some difficulties in providing output formatted in a specific way.

To format output you can use either of the following methods (they work the same)

• System.out.format(String format, Object... args)
• System.out.format(Locale l, String format, Object... args)
• System.out.printf(String format, Object... args)
• System.out.printf(Locale l, String format, Object... args)

This is the way how those methods should be used:

%[argIndex$][flags][width][.precision] conversion

where:

• argIndex - index of the argument passed within the args array
• flags:
  • - - left justify
  • + - print sign (e.g. +25, -45.7)
  • 0 - pad this argument with zeroes
  • , - use local specific separators (e.g. 124,567,678.877)
  • ( -enclose a negative number in parenthesis
• width - minimum number of characters to print (nice to keep clean columns)
• precision - number of digits that will be printed after decimal delimiter (for floating points)
• conversion:
  • b - boolean
  • c - basic types that represent Unicode characters (char, Character, byte, Byte, short, Short)
  • d - integral types (byte, Byte, short, Short, int, Integer, long, Long, BigInteger)
  • f - floating point (float, Float, double, Double, BigDecimal)
  • s - string (for any argument type)

Mixing generics with legacy code

List<String> words = new ArrayList<String>();
words.add("house");
words.add("book");
addSth(words);

private void addSth(List list) {
   list.add(new Integer(6));
}

• the above code compiles (but with warnings) and can work fine, at least to the place of addition (if the object was later retrieved from the List it could break down, e.g. words would be treated as List<String> but Integer objects was retrieved) - this code is unsafe
• generic code is only for the compiler purposes; JVM knows nothing about what really the List holds
• at runtime both legacy and Java 5 code (with generics) look the same, like pre-generic version

List<String> words = new ArrayList<String>();
System.out.println(words instanceof List<String>);   // WON'T COMPILE

The above code won’t compile since all instances of a generic class have the same runtime class, regardless of their actual type parameters.

Instead, you should do as below:

List<String> words = new ArrayList<String>();
System.out.println(words instanceof List);   // OK

This is also worth a look:

Collection<String> words = new ArrayList<String>();
List<Integer> numbers = new ArrayList<Integer>();
System.out.println(words.getClass() == numbers.getClass()); // produces "true"

Continue reading ‘Generics’

assert Expression1 : Expression2;

• Expression1 is asserted to be true; otherwise AssertionError (that shouldn’t be handled) is thrown
• Expression2 allows to produce some additional information
• Expression2 MUST result in a value - it generates a String message
• allow testing during the development and debugging
• are disabled at runtime by default
• can be enabled using -ea or -enableassertions flags and selectively disabled using -da or -disableassertions flags, e.g:
  • java -ea -da:MyClass NotMyClass - enable in general but disable for MyClass
  • java -ea -da:net.dobrzanski.util... MyClass - enable in general but disable for all classes from net.dobrzanski.util package and any of its subpackages
  • java -ea -dsa MyClass, which is shorter version of java -enableassertions -disablesystemassertions MyClass - enable in general but disable in system classes
• DO NOT USE to validate arguments to public methods
• DO NOT USE to validate command line arguments
• USE to validate arguments to private methods
• USE to validate that particular code block will never be reached (use assert false; in that case)
• assert can be used as a key word (as of Java 1.4) or as an identifier, but never both at the same time

Examples:

Shorter version:

private void doSth() {
   ...
   assert (a < b);
   // in there, a is lower than b
   ...
}

Longer version:

private void doSth() {
   ...
   assert (a < b) : "a=" + a + ", b=" + b;
   // in there, a is lower than b
   ...
}