Java enums and arrays

You could use an EnumSet instead of the integer array. Enums in Java do have an integer associated with each instance (obtained from the ordinal() method, which you could use to keep the above code as it is), and EnumSet is implemented using a long as a bitfield (well, that's RegularEnumSet, and there's an alternative implementation for enums with more than 64 members- choosing is encapsulated).

So sth like:

EnumSet<Direction> links = EnumSet.noneOf(Direction.class);
// populate links (links.add(Direction.UP) etc)
if (desired_direction == LEFT || links.contains(Direction.LEFT)) return true;
// etc...

You could iterate over a direction[]:

direction[] enumVals = direction.values();
for(direction dir: enumVals) {
    if ((dir == direction.LEFT  ) || (LINK[dir.ordinal()]  > 0))
        return true;
}

enumName.values() returns an enumName[] that holds all the elements of the enum.

Note that you cannot use an enum-element directly as a number. You need to call (for example) direction.LEFT.ordinal() to get the 0-based ordinal of the element in the enum.

Your enum could like this:

public enum Direction {
    UP(0), DOWN(1), LEFT(2), RIGHT(3), NEUTRAL(4);
    private Integer index;

    Direction(Integer index){
        this.index = index;
    };

    public Integer getIndex(){
        return this.index;
    }
}

and then your if statements :

Direction desired_direction = Direction.LEFT;
int[] LINK = {2,0,0,0,0};
if (desired_direction == Direction.LEFT  || LINK[Direction.LEFT.getIndex()]  > 0){
 return true;
}

Or you could reference the ordinal() method rather than explicity creating an index Integer. Like so LINK[Direction.LEFT.ordinal()] > 0

However maybe using a hashmap could be appropriate (althoguh the logic is not quite the same as your question :

Map<Direction, Integer> myLink = new HashMap<Direction, Integer>(5);
        myLink.put(Direction.LEFT, 2);
        myLink.put(Direction.RIGHT, 0);
        myLink.put(Direction.UP, 0);
        myLink.put(Direction.DOWN, 0);

        if(myLink.get(desired_direction) > 0) 
        {
            return true;
        }

But my favourite is putting all the logic on the enum itself and then passing the int array as a parameter :

public Boolean getAnalysis(int[] link){
  return link[this.getIndex()]  > 0 ? Boolean.TRUE:Boolean.FALSE; 
}

I also like explicit setting an index property rather than rely on the ordinal, just in case someone alters the enum in the future and your call would like this

Direction desired_direction = Direction.LEFT;
return desired_direction.getAnalysis(LINK);