What is the most efficient approach for finding solid colors in 7000 images using BufferedImage and Java?

I have a method which calculates and returns the percentage of pixels in an image that have the most common color - I have over 7000 images which i need to iterate over to get the percentage for each jpg.

The method below iterates over 6000 jpgs to return the percentage of most common color in each jpg. This takes over 6-7 minutes to iterate over all jpgs.

public static double calculatePercentage(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int totalPixels = width * height;
        Map<Integer, Integer> colorCounts = new HashMap<>();

        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int color = image.getRGB(x, y);
                colorCounts.put(color, colorCounts.getOrDefault(color, 0) + 1);
            }
        }

        int mostCommonColorCount = colorCounts.values().stream().max(Integer::compareTo).orElse(0);
        double percentage = (double) mostCommonColorCount / totalPixels;

        return percentage;
    }

Is there an efficient way to check for solid colors and iterate this program faster over 7000 images. Basically I am trying to identify those jpgs which have plain solid colors (like a black, blue or white color).

Most likely speed of image load is a big cause of a performance issue, but for the calculation step you could experiment with counter as AtomicInteger over autoboxed Integer, and parallel Instream to handle multiple rows at same time. Something like:

public static double calculatePercentage(BufferedImage image) {
    int width = image.getWidth();
    int height = image.getHeight();
    int totalPixels = width * height;
    ConcurrentHashMap<Integer, AtomicInteger> colorCounts = new ConcurrentHashMap<>();
    IntStream.range(0, height).parallel().forEach(y -> {
        for (int x = 0; x < width; x++) {
            colorCounts.computeIfAbsent(image.getRGB(x, y), c -> new AtomicInteger()).incrementAndGet();
        }
    });
    int mostCommonColorCount = colorCounts.values().stream().mapToInt(AtomicInteger::get).max().orElse(0);
    double percentage = (double) mostCommonColorCount / totalPixels;

    return percentage;
}

You should experiment with loading images too - you might find speed of reading File->BufferedImage vs File->byte[]->BufferedImage differs between different types of storage (I have noticed that the latter is faster for photos on my NAS drive).

One thing you can do to reduce the duration is promote your local variables to fields.

This will create re-usability.

Map<Integer, Integer> colorCounts;
int width, height;
int totalPixels;

int mostCommonColorCount;
double percentage;

public void calculatePercentage(BufferedImage image) {
    width = image.getWidth();
    height = image.getHeight();
    totalPixels = width * height;

    colorCounts = new HashMap<>();

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int color = image.getRGB(x, y);
            colorCounts.put(color, colorCounts.getOrDefault(color, 0) + 1);
        }
    }

    mostCommonColorCount = 0;
    for (int count : colorCounts.values())
        if (count > mostCommonColorCount) mostCommonColorCount = count;

    percentage = (double) mostCommonColorCount / totalPixels;
}

Example with one image, 1,920 x 1,280 JPEG (24-bit color) 170.97 kB.

Output

726 ms
0.044464518229166666

Alternately, you can create two threads, one to load the next image into memory, while the current calculation is running.
This will typically increase speed significantly.

The method image.getRGB is very slow and not recommended to access the pixel values.

If you want to go through all the pixel values faster, use the getRaster(), but the fastest is to access the DataBuffer (which is just an array). See this discussion or this one about how to access pixel values using the Raster or the DataBuffer (latter highly recommended).