Get histogram of bytes in any set of files in Java - take III

        if (args.length == 0) {
            try {
                loadByteHistogramFromStdin(byteHistogram);

I fail to see why handling stdin is a special case compared to files. Technically all you need is to read from a stream, what that stream is does not matter. Simplified it could be:

if (args.length == 0) {
    loadIntoByteHistogram(System.in, byteHistogram);
} else {
    for (String argument : args) {
        loadIntoByteHistogram(new FileInputStream(argument), byteHistogram);
    }
}

With loadIntoByteHistogram closing the stream after it is done in this example.

On a sidenote, traditionally many UNIX-like tools allow to pass - as parameter to designate to read from stdin at that point:

yourtool file1 file2 - file3

Which might or might not be a functionality you want to support.

System.out.println(byteHistogram);

I'm not a fan of having UI logic inside toString(), as it is also often used for debugging purposes (for example by IDEs). Also the object itself (ByteHistogram) would contain logic for the UI this way, which might or might not be desirable. Having another method in your main CLI class which does the formatting seems like a good solution instead.

showHistogram(byteHistogram);

    private static void loadImpl(final InputStream is, 
                                 final ByteHistogram byteHistogram) 

Every time you need to use the Impl postfix something is wrong. Either the method structuring is off, or the name could be better. loadFromInputStreamInto seems like a good candidate in this case.

loadFromStdInInto(ByteHistogram)
loadFromFileInto(Path, ByteHistogram)
loadFromInputStreamInto(InputStream, ByteHistogram)

        final InputStream is =
                new BufferedInputStream(
                        new FileInputStream(fileName));
        
        loadImpl(is, byteHistogram);

That stream is never closed, which isn't really an issue in this application, but you should always consider closing the stream you're opening to avoid leaking anything. Either have loadImpl close the streams it is passed (which might or might not be desirable) or use a try-with-resources block:

    try (final InputStream is =
                new BufferedInputStream(
                        new FileInputStream(fileName))) {
        loadImpl(is, byteHistogram);
    }

That will close the stream automatically when leaving the block.

That said, why do you need a BufferedInputStream here? You're never using the additional functionality down the line.

        int ch;
        
        while ((ch = is.read()) != -1) {
            byteHistogram.insert(ch);
        }

Reading a stream byte by byte can be slow. Consider reading from it in blocks instead, 16k, 32k or 64k depending on the usecase.

byte[] buffer = new byte[16 * 1024];
int read = 0;

while ((read = (stream.read(buffer)) >= 0) {
    byteHistogram.add(buffer, 0, read);
}

Also ch and is aren't really good names, especially as the ch seems to imply char but it's really an int.

    /**
     * Loads the byte histogram data only from standard input.
     * 
     * @param byteHistogram the byte histogram for holding the statistics.
     * 
     * @throws IOException if I/O fails.
     */

While it is a controversial topic, I'm not a fan of documentation that tells me nothing beyond what I could deduce from the function signature. It seems like wasted effort most of the time.

The next block is a little bit better:

    /**
     * Loads the byte histogram data only from the file named {@code fileName}.
     * 
     * @param fileName      the name of the file to load from.
     * @param byteHistogram the byte histogram for holding the statistics.
     * 
     * @throws FileNotFoundException if file named {@code fileName} is not 
     *                               found.
     * @throws IOException if I/O fails.
     */

But raises a few points: First, the wording of "Loads the byte histogram data only from" implies that there are methods which do load from multiple sources or are not side-effect free. Second, "if I/O fails" is not that helpful again. A more explicit version would look like this:

/**
 * Loads the data from the file under the given {@code fileName} into the given {@link ByteHistogram}.
 *
 * @param fileName The name of the file from which to load the data into the given {@link ByteHistogram}.
 * @param byteHistogram The {@link ByteHistogram} into which to load the data from the given file.
 * @throws FileNotFoundException If the given {@code fileName} does not denote an existing file.
 * @throws IOException If reading from the given {@code fileName} failed.
 */

Considering that many IDEs only display parts of the Javadoc based on the current context, repeating yourself is not a bad idea.

            } catch (IOException ex) {
                LOGGER.log(
                        Level.SEVERE, 
                        "Could not load the histogram from " + 
                        "standard input stream.");

You're swallowing the exception and its details here. That means that it will not be possible to tell what error/exception actually happened. Consider handing the exception itself to the logger so that it can be printed along with the error message.

            } catch (IOException ex) {
                LOGGER.log(
                        Level.SEVERE, 
                        "Could not load the histogram from " + 
                        "standard input stream.",
                        ex);