Default constructor vs. inline field initialization

What's the difference between a default constructor and just initializing an object's fields directly?

What reasons are there to prefer one of the following examples over the other?

Example 1

public class Foo
{
    private int x = 5;
    private String[] y = new String[10];
}

Example 2

public class Foo
{
    private int x;
    private String[] y;

    public Foo()
    {
        x = 5;
        y = new String[10];
    }
}

Initialisers are executed before constructor bodies. (Which has implications if you have both initialisers and constructors, the constructor code executes second and overrides an initialised value)

Initialisers are good when you always need the same initial value (like in your example, an array of given size, or integer of specific value), but it can work in your favour or against you:

If you have many constructors that initialise variables differently (i.e. with different values), then initialisers are useless because the changes will be overridden, and wasteful.

On the other hand, if you have many constructors that initialise with the same value then you can save lines of code (and make your code slightly more maintainable) by keeping initialisation in one place.

Like Michael said, there's a matter of taste involved as well - you might like to keep code in one place. Although if you have many constructors your code isn't in one place in any case, so I would favour initialisers.

The reason to prefer Example one is that it's the same functionality for less code (which is always good).

Apart from that, no difference.

However, if you do have explicit constructors, I'd prefer to put all initialization code into those (and chain them) rather than splitting it up between constructors and field initializers.