How is an instance initializer different from a constructor?

In terms of object lifecycle, there is no difference. Both are invoked at construction time, and logically the initializer block can be considered part of construction.

Semantically, an initializer is a nice tool to have for several reasons:

the initializer can improve code readability by keeping the initialization logic next to the variable being initialized:

   public class Universe {
       public int theAnswer;
       {
         int SIX = 6;
         int NINE = 7;
         theAnswer = SIX * NINE;
       }

       // a bunch of other vars
   }

vs

   public class Universe {
       public int theAnswer;

       // a bunch of other vars

       public Universe() {
         int SIX = 6;
         int NINE = 7;
         theAnswer = SIX * NINE;

         // other constructor logic
       }
   }

Initializers are invoked regardless of which constructor is used.

Initializers can be used in anonymous inner classes, where constructors can't.

This seems to explain it well:

Instance initializers are a useful alternative to instance variable initializers whenever:

• initializer code must catch exceptions, or

• perform fancy calculations that can't be expressed with an instance variable initializer. You could, of course, always write such code in constructors.

But in a class that had multiple constructors, you would have to repeat the code in each constructor. With an instance initializer, you can just write the code once, and it will be executed no matter what constructor is used to create the object. Instance initializers are also useful in anonymous inner classes, which can't declare any constructors at all.

From: JavaWorld Object initialization in Java.