Tag Archive for 'java'

Page 2 of 3

Formatting output

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


  • 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)

Exeptions and Errors in Java

In the diagram below I present the hierarchy of most common Exceptions and Errors:

 |_ Throwable
    |_ Error
    |   |
    |   |_ AssertionError
    |   |
    |   |_ LinkageError
    |   |   |
    |   |   |_ ExceptionInInitializerError
    |   |   |
    |   |   |_ NoClassDefFoundError
    |   |   |
    |   |_ VirtualMachineError
    |       |
    |       |_ StackOverflowError
    |_ Exception
        |_ RuntimeException
            |_ NullPointerException
            |_ IllegalArgumentException
            |   |
            |   |_ NumberFormatException
            |_ IndexOutOfBoundException
            |   |
            |   |_ ArrayIndexOutOfBoundException
            |_ ClassCastException
            |_ IllegalStateException

Continue reading ‘Exeptions and Errors in Java’

Java: == might work the same as equals()

It’s a rule that == is used to compare references, not values. To compare values for equality equals() method should be used.
However, as of Java 5, you can also use == to check if two objects’ values are the same… But it works only for the following wrapper objects, if their primitive counterparts’ values are the same:

  • Boolean
  • Byte
  • Character for values: \u0000 (0) ÷ \u007f (127)
  • Byte and Integer for values: -128 ÷ 127


Mixing generics with legacy code

List<String> words = new ArrayList<String>();

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’

Collections – sorting and searching


In order to sort a Collection, one should use java.util.Collections class as follows (assuming ArrayList will be used):

List<String≫ words = new ArrayList<String>();
... //populate list of words 

It’s similar with arrays of objects.

In the above mentioned example the List contained obects of String type. Shall an own object type be used, special rules of sorting must be defined with Comparable or Comparator interfaces.

Continue reading ‘Collections – sorting and searching’

Assertions in Java

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 

Collection classes in Java

Collections are very important on SCJP exam. It’s useful to remember the following…

collections thumb Collection classes in Java

Continue reading ‘Collection classes in Java’

Java: main method declaration

It’s good to remember that there are a few ways of defining the main() method in Java 5:

public static void main(String[] args) {}


public static void main(String args[]) {}


public static void main(String... args) {}

Sometimes, we don’t care and remeber of basic stuff, which can result in worse score on the exam icon smile Java: main method declaration

Useful links on SCJP

I’ve found a couple of links that may be useful while preparing to SCJP. Take a look at them, if you wish:

Should you have some other useful links, don’t hesitate to show me them (by replying to this post).

Java: overriding and overloading

Overriding and overloading are common concepts of Java and occur often on SCJP exam. Although I know the rules that apply for them, I happen to think twice (or more) on questions dealing with them. Thus, it’s a good idea to keep the following rules in mind…


  • applies ONLY to inherited methods
  • is related to polymorphism
  • object type (NOT reference variable type) determines which overriden method will be used at runtime
  • overriding method MUST have the same argument list (if not, it might be a case of overloading)
  • overriding method MUST have the same return type; the exception is covariant return (used as of Java 5) which returns a type that is a subclass of what is returned by the overriden method
  • overriding method MUST NOT have more restrictive access modifier, but MAY have less restrictive one
  • overriding method MUST NOT throw new or broader checked exceptions, but MAY throw fewer or narrower checked exceptions or any unchecked exceptions
  • abstract methods MUST be overridden
  • final methods CANNOT be overridden
  • static methods CANNOT be overridden
  • constructors CANNOT be overridden


  • overloading can take place in the same class or in the subclass
  • overloaded methods MUST have a different argument list
  • overloaded methods MAY change the return type (in case argument list is different)
  • overloaded methods MAY change the access modifier
  • overloaded methods MAY throw new or broader checked excpetions
  • reference type determines which overloaded method will be used at compile time
  • constructors MAY be overloaded
  • methods adjustment in connection with overloaded method’s arguments:
    • you cannot widen and then box (int -> Long)
    • you can box and then widen (int -> Object, via Integer)
    • you can combine var args with either widening (byte -> int) or boxing (int -> Integer):
      • widening is over boxing
      • widening is over var args
      • boxing is over var args

Finally, a few notes on polymorphism:

  • a refenrence variable is of an unchangeable type, but can refer to a subtype object
  • a single object can be referred to by reference variable of many differnet types (however, they MUST be the of same type or supertype of the object)
  • reference type determines which method will be called

Also, keep that in mind:
Reference type determines which overloaded method is used at compile time.
Object type determines which overriden method is used at runtime.