What are some things in the class library you wish more people knew about or used?

Link for the curious

A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" bytes, by storing pushed-back bytes in an internal buffer. This is useful in situations where it is convenient for a fragment of code to read an indefinite number of data bytes that are delimited by a particular byte value; after reading the terminating byte, the code fragment can "unread" it, so that the next read operation on the input stream will reread the byte that was pushed back. For example, bytes representing the characters constituting an identifier might be terminated by a byte representing an operator character; a method whose job is to read just an identifier can read until it sees the operator and then push the operator back to be re-read.

This does sound useful. I have to admit I don't know much about InputStream and OutputStream and every time I need to do something with them (which is rare) I just search it up.

Ooh, I've never seen that before. And it's been there since 1.0

Finally a more sane API for HTTP requests in java. Still using a library tho, can be very convenient (like okhttp)

Those sound useful. I haven't had to do much cross-thread synchronization thankfully, but I have had to use a BlockingDeque to check that some events came and in the right order. The CountDownLatch and Phaser may have been better.

I had never heard of Phaser, but it looks pretty cool. I just read Baeldung's Guide to Phaser and correct me if I'm wrong, but doesn't it kind of seem like a race condition (it could just be how they use it in the examples)?

class LongRunningAction implements Runnable {
    private String threadName;
    private Phaser ph;

    LongRunningAction(String threadName, Phaser ph) {
        this.threadName = threadName;
        this.ph = ph;
        ph.register();
    }

    @Override
    public void run() {
        ph.arriveAndAwaitAdvance();
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        ph.arriveAndDeregister();
    }
}

then

executorService.submit(new LongRunningAction("thread-1", ph));
executorService.submit(new LongRunningAction("thread-2", ph));
executorService.submit(new LongRunningAction("thread-3", ph));

if ph.arriveAndAwaitAdvance(); is called before all of the LongRunningActions are initialized, won't it proceed before it is supposed to?

Don't forget its subtypes. OptionalInt, OptionalDouble etc. This avoids auto(un)boxing.

I didn't have a specific goal, but yeah I do wish more people used Optional.

My one "gripe" with Optional (and I use it lightly) is that they mean for it to only be used as a return type instead of anywhere something can be optional. It can still be used as that though, they just don't recommend it.

Optional.ofNullable(thingThatMightBeNull).map(e -> e.someMethod()).orElse(null);

Optional.ofNullable(myObj)
  .map(MyClass::getProperty)
  .map(MyOtherClass::getAnotherProperty)
  .filter(obj -> somePredicate(obj))
  .orElse(null)