Most code-efficient way of assigning textures based on varios conditions?

I am currently programming a game using a own engine. However, there is a problem and I am not sure how solve it in the most code-efficient way:
For a lot objects in the game I need to assign different textures based on various conditions / states (I am using enums for that). An example:

The player needs to change its texture based on the direction he is looking at, whether he is walking or waiting, his health state, etc.

One solution would be nested switch-statements like this:

switch (getState ()) {
        case IDLE:
            switch (getDirection()) {
                case UP:
                    setTexture(Textures.PLAYER_IDLE_UP);
                    break;
                case RIGHT:
                    setTexture(Textures.PLAYER_IDLE_RIGHT);
                    break;
                case DOWN:
                    setTexture(Textures.PLAYER_IDLE_DOWN));
                    break;
                case LEFT:
                    setTexture(Textures.PLAYER_IDLE_LEFT);
                    break;
            }
            break;
        case WALKING:
            switch (getDirection()) {
                case UP:
                    setTexture(Textures.PLAYER_WALKING_UP);
                    break;
                case RIGHT:
                    setTexture(Textures.PLAYER_WALKING_RIGHT);
                    break;
                case DOWN:
                    setTexture(Textures.PLAYER_WALKING_DOWN);
                    break;
                case LEFT:
                    setTexture(Textures.PLAYER_WALKING_LEFT);
                    break;
            }
            break;
        case RUNNING:
            ...
    }

But this would get more and more complicated with every condition and I would have to rewrite it if there was a slightly other set of states (e.g. I would implement a Zombie and he could not run or would have additional properties etc.).

I also thought of giving all my textures tags and writing an algorithm which tries to find a matching texture but with more and more textures / conditions and all of this being executed very often I think this approach would be extremly slow.

I do not really know what to do or if I am missing any data structures which are adressing these kinds of problems and are both code-efficient and performant.

I'm not sure if it would make it more efficient, but it would definitely make it more robust for future changes:
I was thinking of something like a lookup-table. This could be a multidimensional array, or even your own data structure.

You could code your states and directions as Integers, e.g.

public static final int IDLE = 0;
public static final int WALKING = 1;
...
public static final int UP = 0;
public static final int LEFT = 1;
...

And then let's say you have an 2-dimensional array containing all the textures. You could use getState() and getDirection() methods as indices for the array. So your code could become something similar to:

setTexture(texture_array[getState()][getDirection()]);

Of course you would have to hardcode all your textures into the array at some point, and some cells you might have to set to null or similar (like when you don't want a texture to be set at a certain state-direction-combination), but I think it would look better and make it more robust for future changes.