How to reverse the contents of an enum element in java

So here is my enum structure.

public enum DictionaryEnum {
        ARROW(
                "Arrow",
                new String[] {
                        "noun"
                },
                new String[] {
                        "Here is one arrow: <IMG> -=>> </IMG>"
                }
        ),
        BOOK(
                "Book",
                new String[]{
                        "noun",
                        "noun",
                        "verb",
                        "verb"
                },
                new String[]{
                        "A set of pages.",
                        "A written work published in printed or electronic form.",
                        "To arrange for someone to have a seat on a plane.",
                        "To arrange something on a particular date."
                }
        );

Basically if the user types in book reverse. The output should be the definitions of the word book in reverse.

Here is what I have so far:

String[] keywords = input.split(" ");
            String key = keywords[0];
            String[][] result = dictionary.get(key);

    if (keywords[1].toLowerCase().equals("reverse") && !keywords[1].toLowerCase().equals("distinct")) {
                        for (int i = DictionaryEnum.values().length - 1; i >= 0; --i) {
                            DictionaryEnum e = DictionaryEnum.values()[i];
                            System.out.println(e);
                        }
                    }

But as you can guess, it outputs the reverse of the whole enum structure as opposed to the reverse of the individual term inside of the structure.

For Example: if the user types in "book" then the output should be:

Book [noun] : A set of pages.
Book [noun] : A written work published in printed or electronic form.
Book [verb] : To arrange for someone to have a seat on a plane.
Book [verb] : To arrange something on a particular date.

if the type in "book reverse", the output should be

Book [verb] : To arrange something on a particular date.
Book [verb] : To arrange for someone to have a seat on a plane.
Book [noun] : A written work published in printed or electronic form.
Book [noun] : A set of pages.

You first need to find the DictionaryEnum selected:

  DictionaryEnum de = DictionaryEnum.valueOf(keywords[0].toUpperCase());

Afterwards you can use the data structure of the given Enum to print out what you want.

As a note: I would not use a unmodifiable data structure for something like a dictionary as it is most likely that in future you want to add entries from other sources.

Since you posted an incomplete enum I had to complete the missing parts myself. So keep in mind that the enum field names and methods might have a different name than in your code:

public enum DictionaryEnum {
ARROW(
"Arrow",
new String[] {
"noun"
},
new String[] {
"Here is one arrow: <IMG> -=>> </IMG>"
}
),
BOOK(
"Book",
new String[]{
"noun",
"noun",
"verb",
"verb"
},
new String[]{
"A set of pages.",
"A written work published in printed or electronic form.",
"To arrange for someone to have a seat on a plane.",
"To arrange something on a particular date."
}
);
private final String name;
private final String[] keys;
private final String[] values;
private DictionaryEnum(String name, String[] keys, String[] values) {
this.name = name;
this.keys = keys;
this.values = values;
}
public String getName() {
return name;
}
public String[] getKeys() {
return keys;
}
public String[] getValues() {
return values;
}
/**
* Will return the fitting DictionaryEnum for the passed name, or null if not found
* @param name
* @return
*/
public static DictionaryEnum getByName(String name) {
for (DictionaryEnum dictionaryEnum : values()) {
if(dictionaryEnum.getName().equalsIgnoreCase(name)) {
return dictionaryEnum;
}
}
return null;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter command:");
String input = scanner.nextLine();
String[] keywords = input.split(" ");
String name = keywords[0];
String command = keywords[1];
// 1. Use our static method to get the fitting enum:
DictionaryEnum dictionaryEnum = DictionaryEnum.getByName(name);
if (dictionaryEnum == null) {
// if the returned object was null no fitting match was found
System.out.println("NO ENUM FOUND!");
} else {
// 2. We found a fitting enum object! Lets use that object to iterate over its contents
if ("reverse".equals(command)) {
for (int i = dictionaryEnum.getKeys().length - 1; i >= 0; i--) {
String key = dictionaryEnum.getKeys()[i];
String value = dictionaryEnum.getValues()[i];
System.out.println(dictionaryEnum.getName() + " [" + key + "] : " + value);
}
} else {
for (int i = 0; i < dictionaryEnum.getKeys().length; i++) {
String key = dictionaryEnum.getKeys()[i];
String value = dictionaryEnum.getValues()[i];
System.out.println(dictionaryEnum.getName() + " [" + key + "] : " + value);
}
}
}
scanner.close();
}
}

Now most of what i added are simple getters/setters and a constructor that should be more or less identical to what you have. What is probably interesting for you is the static method public static DictionaryEnum getByName(String name) that I added. This method takes an String argument and then iterates over all the enum object that exists. It compares the passed argument with the name field and if it is equal (ignoring case) it will return that enum object. If the loop finished runnig without ever finding a match it will return null instead.

So calling that method like DictionaryEnum.getByName("arrow"); will return you the object DictionaryEnum.ARROW.

There are many different ways to find the enum you want by an input (See the answer of Fabian Tschachtli for another example), but you need to get the correct enum object first before you can do anything else.

All you then have to do is use that found enum object to iterate over the Array fields either normally or in reverse. You can see all that in the main method I added and run the code itself.