Arrays.sort on an array of primitive types (int, long, double, etc.) can degrade to $$$O(N^2)$$$ on adversarial test cases. Note that this does not apply to Collections.sort or non-primitive types.

Apparently, this bug was fixed in Java 14. So on Codeforces, just use Java 17 rather than Java 11 or Java 8. If the online judge you use doesn't offer Java 14+, see the other two options.

Replace int with Integer, long with Long, etc. Changing the primitives to objects forces Arrays.sort to use mergesort, which is guaranteed $$$O(N\log N)$$$.

Shuffle the array before sorting it. For example, you can use the Fisher-Yates shuffle:

static void shuffle(int[] a) {
    Random r = new Random();
    for (int i = a.length-1; i >= 1; i--) {
        int swp = r.nextInt(i+1);
        int tmp = a[swp]; a[swp] = a[i]; a[i] = tmp;
    }
}

String concatenation is linear time in the length of the new string. For example, this code is $$$O(N^2)$$$:

String s = "";
for (int i = 0; i < n; i++) s += "a";

This is because strings in Java are immutable.

Replace String with StringBuilder and use .append:

StringBuilder s = new StringBuilder();
for (int i = 0; i < n; i++) s.append("a");

Input and output using Scanner and System.out.print are slow. I've seen multiple instances of people TLEing on problems because they used one or the other (or both).

For input, learn to use BufferedReader and StringTokenizer:

// Suppose the input is the following:
// 5
// 1 2 3 4 5
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine()); // br.readLine() returns "5", and Integer.parseInt turns the string into an integer
int[] a = new int[n];
StringTokenizer st = new StringTokenizer(br.readLine()); // StringTokenizer splits the string by whitespace
for (int i = 0; i < n; i++) a[i] = Integer.parseInt(st.nextToken());

For output, use PrintWriter:

PrintWriter pw = new PrintWriter(System.out);
pw.println("Hello world!");

To make I/O operations easier, there are a few templates you can use. See here for more information. I recommend the last one for Codeforces since it's the fastest, but for competitions where you can't use prewritten code the third one is fine.

Consider the following code:

Integer a = 1, b = 1, c = 12345, d = 12345;
System.out.println(a == b); // true
System.out.println(c == d); // false

This happens because for objects, == compares the references to the objects, not the objects themselves. This makes sense (consider that you also can't compare Strings with ==) but it's easy to forget, especially when you're using data structures like ArrayList<Integer>.

Use .equals instead:

Integer a = 1, b = 1, c = 12345, d = 12345;
System.out.println(a.equals(b)); // true
System.out.println(c.equals(d)); // true

The Stack data structure is slow. For example, this submission has the correct time complexity but gets TLE.

Use LinkedList instead. The operations (push, pop, peek) all work as intended. (However, note that it adds and removes from the front.) Here is an AC submission using LinkedList instead of Stack.

UPDATE 06/18/2024: After using Java for a bit, I now realize it's better to use ArrayDeque rather than LinkedList. Just write something like

Deque<Integer> stk = new ArrayDeque<>();