Try this:

private static final int findMaxRecursively(List<Integer> numbers, int index, int max) {
    return index >= numbers.size()
        ? max
        : findMaxRecursively(numbers, index + 1, Math.max(numbers.get(index), max));
}

public static final int findMaxRecursively(List<Integer> numbers) {
    return findMaxRecursively(numbers, 0, Integer.MIN_VALUE);
}

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, -1, 2, -2, 3, -3);
    System.out.printf("Max is %d in %s%n", findMaxRecursively(numbers), numbers);
}

Recursive programming is not a bad practice. It is a tool in your toolbox and like any tool, when it's the only tool used that's when bad things happen. Or when it's used out of a proper context.

When do you use recursion? It's good when you have a tree dataset that you need to perform the same logic upon. For example: You have a tree list of string elements and you wish to calculate total length of all strings, down one branch. You'd define a method to calculate the length of a list element and then see if the element has a sibling and if it does call the method, passing the sibling - and the process starts over.

The most common pitfall would be of a stack overflow. When the list is so large, it can't be handled all at once. So you would implement checks to ensure this never happens. Such as breaking the linked list down into manageable pieces and in your function, utilize a static variable to track the number of levels you traverse - bailing once that number is exceeded.

You should avoid using when your dataset is not a tree type dataset. The only time I can think of that you actually can't avoid using recursion is in programming languages that do not support looping (Haskell).