You are here: Home ยป Blog

Initializing Java collections and arrays during creation

Posted on Saturday, March 15 2014 at 21:32 | Category: Software Engineering, Java | 0 Comment(s)

Initializing collections with predefined values

Especially when writing unit tests or mock objects, it can be useful to initialize collections like Lists, Maps and Arrays with specific values. The usual way to do this is to instantiate the corresponding class and then add the values, e.g.


List<String> names = new ArrayList<>();
names.add("John");
names.add("Jack");
names.add("Greg");

However, when the collection is only required to be passed to a method as parameter, this adds a temporary reference variable to the current scope.

In another scenario, it could be necessary to create a collection with predefined values as class members, and using the approach above would require the add() calls to be done in the class constructor (or in the instance initializer). For readability and maintainability, it would be better to add the default values at the same place where the member is defined. In any case, initializing collections in this way can be done using the "double brace initialization syntax":


List<String> names = new ArrayList<String>() {{
      add("John");
      add("Jack");
      add("Greg");
   }};

Is this really a specific, probably new, Java syntax? Not really - lets rewrite it slighty:


List<String> names = new ArrayList<String>() {

   {
      add("John");
      add("Jack");
      add("Greg");
   }

};

It might be more obvious now - what we do is that we create an anonymous class as a sub class of ArrayList<String>. In that class, we create an instance initializer which is enclosed with the inner pair of braces. Syntactically this can be written as above, hence the name "double brace initializer". One particular detail to consider is that the diamond operator can not be used with anonymous classes, so we need to explicitly name the type when instantiating a generic class. See stackoverflow.com/questions/13821586/why-cant-diamond-infer-types-on-anonymous-inner-classes for more details. Using this approach also allows to pass a readily initialized collection as a parameter to a method, without the need to create a temporary variable as in our introductionary example:


   public void processMap(Map map) {
      System.err.println(map);
   }

   public static void main() {
       processMap(new HashMap<String, Integer>() {{
             put("one",  1); 
             put("two",  2); 
             put("three",  3); 
          }});
   }

Initializing raw arrays with predefined values

Another common use case is to create a raw array with predefined values. When T is the array type, then the syntax for array initialization is:


T[] array = new T[] {val1, val2, val3, ..., valN};

This creates an array with N elements, initialized with the given values. The nice thing is that this syntax can also be used to initialize an array while passing it as parameter. Consider the following method:


public void processArray(int[] array) {
   System.err.println(Arrays.toString(array));
}

Then, when we want to pass an array with the values 1, 2, 3, we can simply call the method like this:


processArray(new int[] {1, 2, 3} );

The same works also with reference type arrays:


public void processArray(Date[] array) {
   System.err.println(Arrays.toString(array));
}

processArray(new Date[] {new Date(123456789012L), new Date(234567890123L), new Date(345678901234L)} );

Retrieving original hashcode of a Java object

Posted on Sunday, March 09 2014 at 21:33 | Category: Software Engineering, Java | 0 Comment(s)

For debugging Java applications, it is sometimes useful to know if two references point to the same or to different objects - this can be easily checked by evaluating the return value of hashCode() (the default implementation from java.lang.Object returns distinct integers for distinct objects). However, this might not work if hashCode() is overridden - in that case, hashCode() might return the same value for different objects to fulfill the equals() contract. In that case, it is still possible to retrieve the same hashCode() value as it would be returned by java.lang.Object if the hashCode() method was not overridden, by using System.identityHashCode() on this object:

public class Value {
    private int theValue;

    public Value(int val) {
        theValue = val;
    }

    @Override
    public int hashCode() {
        return theValue;
    }
	
    public static void main(String[] args) {
        Value value = new Value(42);
        System.err.println(value.hashCode());
        System.err.println(System.identityHashCode(value));
    }
}
Output:
42
1024180077

Enabling unrestricted security algorithms in Java

Posted on Friday, November 23 2012 at 22:12 | Category: Software Engineering, Java | 0 Comment(s)

While I tried to reproduce this question on StackOverflow, I learned that it is required to install additional policy files in order to use strong encryption algorithms with the Java Cryptography Architecture (JCA). This article shows a sample encryption/decryption application and how to enable AES-256 support by installing the additional policy files: Using strong encryption in Java


Creating java virtual machine stack traces

Posted on Tuesday, August 14 2012 at 12:08 | Category: Software Engineering, Java | 0 Comment(s)

This article shows how to create stack traces from background java processes: Creating Java Stack Traces


Displaying results 17 to 20 out of 23