One "truely object oriented" answer would be to define an interface for "Rule" (with condition() and action() methods), create 3 implementations, stuff them into a collection, and then just iterate through them generically as in:

List<Rule> rules = .... ; // your 3 rules initialized here somehow
for(Rule r : rules) {
  if(r.condition()) {
    r.action();
  }
}

This makes a lot more sense if you have 300 rules/conditions rather than just 3.

In Java8, you may want to do this instead, if the rules are CPU-intensive:

rules.parallelStream().filter(Rule::condition).forEach(Rule::action);

If you can use JavaScript, you can use a object with functions:

function doSomething(i) {
  var obj = {};

  obj[12] = function () {
    // order should be same
    up();
    left();
    stop();
  };
  obj[304] = function () {
    // order should be same
    right();
    up();
    stop();
  };
  obj[962] = function () {
    // order should be same
    down();
    left();
    up();
    stop();
  };

  // apparently we can't use any conditional statements
  try {
    obji;
  } catch (e) {}
}

If only if and switch statements aren't allowed, replace all the if statements with the logical AND operator (&&):

function doSomething(i) {
  (i == 12) && (
    // order should be same
    up(),
    left(),
    stop()
  );

  (i == 304) && (
    // order should be same
    right(),
    up(),
    stop()
  );

  (i == 962) && (
    // order should be same
    down(),
    left(),
    up(),
    stop()
  );
}

Use a switch statement or a HashMap.

Switch statement: Readable, but compiles similarly (if not identically) to an if-else chain.

switch([USER_INPUT]) {
    case 1:
        System.out.println("TEST");
        break;
    case 2:
        System.out.println("HELLO");
        break;
    // And so on.
}

Hash Map: Much more readable and simpler. This is preferred.

// Initialization.
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"TEST");
map.put(2,"HELLO");

// Printing.
String s = map.get(USER_INPUT);
if (s == null)
    System.out.println("Key doesn't exist.");
System.out.println(s);

Based on the previous answer, Java allows enums to have properties so you could define a strategy pattern, something like

public enum Action {
    A ( () -> { //Lambda Sintax
        // Do A
       } ), 
    B ( () -> executeB() ), // Lambda with static method
    C (new ExecutorC()) //External Class 

    public Action(Executor e)
        this.executor = e;
    }

    //OPTIONAL DELEGATED METHOD
    public foo execute() {
        return executor.execute();
    }

    // Action Static Method
    private static foo executeB(){
    // Do B
    }
}

Then your Executor (Strategy) would be

public interface Executor {
    foo execute();
}

public class ExecutorC implements Executor {
    public foo execute(){
        // Do C
    }
}

And all your if/else in your doPost method become something like

public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    String action = req.getParameter("action");
    Action.valueOf(action).execute();
}

This way you could even use lambdas for the executors in the enums.

To shorten multiple if-else statements you can use inline if:

((condition == value)?'expr1':'expr2')

expr1 executes when condition is true, else expr2 executes.

String parentFolder = "";
parentFolder = (((name.matches("birds"))?"birdPFUuid":
                 (name.matches("dogs"))?"dogsFUuid":  // if "dogs" then set parent folder to "dogsFUid" else check code in line below
                 (name.matches("cats"))?"catsFUuid":
                 (name.matches("vehicles"))?"vehiclesFUuid":""
));
        

The Strategy pattern seems to suit this down to the ground. Here is the link to the wikipedia article, which should be more than enough to get you started, and because you've provided 0 code, I think I won't either.

But because I'm feeling nice

Firstly, I would have them implementing a common interface or superclass. This is so you don't need to test what type of class they are. Simply have them call the same method. I know you've said polymorphism is out of the question, but I'm not sure why. And if you don't have access to the super class.. make a common interface.

For example:

// Undesirable syntax.
if(obj instanceof Dog)
{
    ((Dog)obj).woof();
}
else if(obj instanceof Cat)
{
    ((Cat)obj).meow();
}
else if(obj instanceof Lion)
{
    ((Lion)obj).roar();
}

Now let's define some common interface, Animal:

public interface Animal
{
    public void speak();
}

And now your instanceof tree looks like this:

public void makeTalk(Animal obj)
{
    obj.speak();
}

Try with contains as devid explained. contains is a function of list to checkout object contains or not. so you have to modify code like below:

 if(!representatives.contains(word)){  
        representatives.add(word);    

    }
    else if(!repeatWords.contains(word)){  
        repeatWords.add(word); }

It check if list don't contain object then add it. otherwise; everything seems ok!!.

As it almost but not really matches Optional, maybe you might reconsider the logic:

Java 8 has a limited expressiveness:

Optional<Elem> element = ...
element.ifPresent(el -> System.out.println("Present " + el);
System.out.println(element.orElse(DEFAULT_ELEM));

Here the map might restrict the view on the element:

element.map(el -> el.mySpecialView()).ifPresent(System.out::println);

Java 9:

element.ifPresentOrElse(el -> System.out.println("Present " + el,
                        () -> System.out.println("Not present"));

In general the two branches are asymmetric.