Practice: a log line parser

String levelOf(String line) {
    return line.split("\\|")[0];
}

void main() {
    IO.println(levelOf("WARN|14:03|Disk usage at 91 percent"));
}

Split on the separator the format actually uses, and the level is the first piece, index 0. | is special in a pattern, so it is written "\\|". Counting characters would work for WARN and INFO and break on ERROR.

String timeOf(String line) {
    return line.split("\\|")[1];
}

void main() {
    IO.println(timeOf("WARN|14:03|Disk usage at 91 percent"));
}

The time is the second field, so it is at index 1. Counting from 0 is the whole of this step.

String messageOf(String line) {
    return line.split("\\|")[2];
}

void main() {
    IO.println(messageOf("WARN|14:03|Disk usage at 91 percent"));
}

The message is the third and last field, at index 2.

boolean isWarning(String line) {
    String level = line.split("\\|")[0];
    return level.toUpperCase().equals("WARN");
}

void main() {
    IO.println(isWarning("WARN|14:03|Disk usage at 91 percent"));
    IO.println(isWarning("warn|08:00|  Fan speed low  "));
    IO.println(isWarning("INFO|09:15|Backup finished"));
}

Put the level in one case before comparing, and compare text with .equals. Without toUpperCase(), half the services are never warned about.

String tidy(String line) {
    String[] fields = line.split("\\|");
    fields[0] = fields[0].toUpperCase();
    fields[2] = fields[2].strip();
    return String.join("|", fields);
}

void main() {
    IO.println(tidy("warn|08:00|  Fan speed low  "));
}

An array's items can be replaced, so the level and the message are swapped for their tidied versions, and String.join puts the separator back between the pieces. String.join takes plain text, not a pattern, so its | needs no backslash. A line that was already tidy comes back unchanged.

ArrayList<String> wordsIn(String message) {
    ArrayList<String> words = new ArrayList<>();
    for (String word : message.strip().split("\\s+")) {
        boolean allLetters = true;
        for (int i = 0; i < word.length(); i++) {
            if (!Character.isLetter(word.charAt(i))) {
                allLetters = false;
            }
        }
        if (allLetters) {
            words.add(word);
        }
    }
    return words;
}

void main() {
    IO.println(wordsIn("Disk usage at 91 percent"));
}

strip().split("\\s+") gives the words however the spaces fall. A word is kept only if every one of its characters is a letter: the flag starts true for each word, and any character that is not a letter turns it false, which is how 91 and sda1 drop out.

String redact(String line, String word) {
    return line.replace(word, "****");
}

void main() {
    IO.println(redact("WARN|14:03|Disk usage at 91 percent", "91"));
}

replace changes every appearance, not just the first, and gives back the line unchanged when the word is not there.

ArrayList<String> warningMessages(ArrayList<String> lines) {
    ArrayList<String> messages = new ArrayList<>();
    for (String line : lines) {
        String[] fields = line.split("\\|");
        if (fields[0].toUpperCase().equals("WARN")) {
            messages.add(fields[2].strip());
        }
    }
    return messages;
}

void main() {
    ArrayList<String> lines = new ArrayList<>();
    lines.add("WARN|14:03|Disk usage at 91 percent");
    lines.add("INFO|09:15|Backup finished");
    lines.add("warn|08:00|  Fan speed low  ");
    IO.println(warningMessages(lines));
}

The messages, not the lines: each warning's third field, stripped. The lowercase line has to be caught and its message tidied, which is why the level is uppercased before the comparison.