After reviewing the feedback provided in the comments, I have made necessary adjustments to align with your requirements.

To begin, the rgb/hsl string needs to be parsed. This can be achieved efficiently by utilizing a combination of regular expressions and the String.split method:

private static final Pattern hexPattern = Pattern.compile("#[\\dA-Fa-f]{6}");
private static final Pattern rgbPattern = Pattern.compile("rgba?\\([^)]*\\)", Pattern.CASE_INSENSITIVE);
private static final Pattern hlsPattern = Pattern.compile("hlsa?\\([^)]*\\)", Pattern.CASE_INSENSITIVE);

The first Pattern matches any hex-encoded value, the second matches rgb(something) or rgba(something), and the third matches hsl or hsla. These patterns can be utilized as follows:

public static int[] extractRGB(String cssString) {
    if (hexPattern.matcher(cssString).matches())
        return obtainRgbFromHex(cssString);
    if (rgbPattern.matcher(cssString).matches())
        return obtainRgbFromRgb(cssString);
    if (hlsPattern.matcher(cssString).matches())
        return obtainRgbFromHsl(cssString);
    return null; // no match
}

private static int[] obtainRgbFromHex(String hexString) {
    int rgbValue = Integer.decode(hexString);
    Color color = new Color(rgbValue);
    return new int[] { color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha() };
}

private static int[] obtainRgbFromRgb(String rgbString) {
    String[] values = rgbString.split("[\\s,()]");
    String red = values[1];
    String green = values[2];
    String blue = values[3];
    String alpha = "1.0";
    if (values.length >= 5) {
        alpha = values[4];
    }
    return new int[] {
        parseValue(red, 255),
        parseValue(green, 255),
        parseValue(blue, 255),
        parseAlpha(alpha),
    };
}

private static int[] obtainRgbFromHsl(String hslString) {
    String[] values = hslString.split("[\\s,()]");
    String hue = values[1];
    String saturation = values[2];
    String lightness = values[3];
    String alpha = "1.0";
    if (values.length >= 5) {
        alpha = values[4];
    }
    int hueValue = parseValue(hue, 360);
    double sat = parsePercent(saturation);
    double light = parsePercent(lightness);
    int alphaValue = parseAlpha(alpha);
    return hslToRgb(hueValue, sat, light, alphaValue);
}

private static int[] hslToRgb(int hue, double saturation, double lightness, int alpha) {
    // Calculation logic will be implemented here
    int red = 0;
    int green = 0;
    int blue = 0;
    return new int[] { red, green, blue, alpha };
}

private static int parseValue(String value, int maximum) {
    if (value.endsWith("%")) {
        return (int) (parsePercent(value) * maximum);
    }
    return Integer.parseInt(value);
}

private static double parsePercent(String percentage) {
    return Integer.parseInt(percentage.substring(0, percentage.length() - 1)) / 100.0;
}

private static int parseAlpha(String alphaValue) {
    return (int) (Double.parseDouble(alphaValue) * 255);
}

The functionality of each method is as follows:

• extractRGB - This function takes the CSS string, identifies its format, and proceeds with the parsing process. If the format is invalid, it returns null. The returned array consists of r, g, b, and a values, ranging from 0 to 255.
• obtainRgbFromHex - Parses the hex string using Integer.decode and extracts the RGB values using Color.
• obtainRgbFromRgb - Extracts values from an rgb string (including rgba), splits the string, and parses each value to create an array.
• obtainRgbFromHsl - Behaves similarly to obtainRgbFromRgb, but for HSL values.
• hslToRgb - Logic for calculating r, g, and b from h, s, and l values.
• parseValue - Parses percentage values and calculates based on the provided maximum.
• parsePercent - Extracts and returns the percentage value as a double.
• parseAlpha - Parses alpha values and returns them as an integer within the 0-255 range.

Testing with rgb/rgba values has confirmed the functionality:

public static void main(String[] args) {
    System.out.println(Arrays.toString(extractRGB("#FF00CC")));
    System.out.println(Arrays.toString(extractRGB("rgb(255,0,0)")));
    System.out.println(Arrays.toString(extractRGB("rgba(255,0,0,0.5)")));
    System.out.println(Arrays.toString(extractRGB("rgba(100%,0%,30%,0.5)")));
}

The output of this test is:

[255, 0, 204, 255]
[255, 0, 0, 255]
[255, 0, 0, 127]
[255, 0, 76, 127]

Consider utilizing rounding for percentage values instead of direct casting to enhance accuracy.

If you have any further inquiries, please feel free to ask.

If you're looking to convert colors between HSB and RGB in Java, you can utilize the methods Color.HSBtoRGB and Color.RGBtoHSB. For instance:

int red = 255, green = 0, blue = 255;
float[] hsbValues = Color.RGBtoHSB(red, green, blue, null);
for (float value : hsbValues) {
    System.out.println(value);
}

Running this code will give you the following output:

0.5
1.0
1.0

These three float values represent the Hue, Saturation, and Brightness values respectively. When dealing with colors containing an alpha channel, the alpha value remains consistent when converting between RGB and HSB, meaning A == A.

To generate a new Color object using the obtained array:

Color newColor = Color.getHSBColor(hsbValues[0], hsbValues[1], hsbValues[2]);

Without additional information on your specific requirements for input and output, it's challenging to provide further assistance.

Update: Check out my alternative solution.

It seems that the current regex rules are not working properly as they allow incorrect strings like "rgba(1000,500%,500%,2)" and reject the correct format like "#fff".

I have created stricter and more accurate regex rules:

    String keywords_color_regex = "^[a-z]*$";
    String hex_color_regex = "^#[0-9a-f]{3}([0-9a-f]{3})?$";
    String rgb_color_regex = "^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$";
    String rgba_color_regex = "^rgba\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*((0.[1-9])|[01])\\s*\\)$";
    String hsl_color_regex = "^hsl\\(\\s*(0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*\\)$";

When dealing with rgba and hsla colors, my objective is to determine the actual displayed color. I am interested in finding a way to "blend" these colors with their background colors to calculate the final displayed color...