Java颜色工具类 Java基础之颜色工具类(超详细注释)

import java.util.HashMap;
import java.util.Map;

public class Color{
    private final String[] hex_letters = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};

    private Double alpha;// 透明度（0.0 ~ 1.0）

    private Integer red; // 红色值（0~255）
    private Integer green; // 绿色值（0~255）
    private Integer blue; // 蓝色值（0~255）
    private String rgb; // RGB值；格式：rgb(red, green, blue)
    private String rgba; // RGBA值；格式：rgb(red, green, blue, alpha)

    private String hexRed; // 十六进制红色值（00-FF）
    private String hexGreen; // 十六进制绿色值（00-FF）
    private String hexBlue; // 十六进制蓝色值（00-FF）
    private String hex; // 十六进制颜色值；格式：#hexRedhexGreenhexBlue

    /**
     * 无参构造器
     * 默认黑色不透明
     */
    public Color(){
        this.red = 0;
        this.green = 0;
        this.blue = 0;
        this.alpha = 1.0;
        this.hexRed = "00";
        this.hexGreen = "00";
        this.hexBlue = "00";
        this.rgb = "rgb(0, 0, 0)";
        this.rgba = "rgba(0, 0, 0, 1.0)";
        this.hex = "#000000";
    }

    /**
     * 通过RGB三值初始化
     *
     * @param red 红色值（0~255）
     * @param green 绿色值（0~255）
     * @param blue 蓝色值（0~255）
     */
    public Color(Integer red, Integer green, Integer blue){
        // 调用 [通过RGBA四值初始化]
        this(red, green, blue, 1.0);
    }

    /**
     * 通过RGBA四值初始化
     *
     * @param red 红色值（0~255）
     * @param green 绿色值（0~255）
     * @param blue 蓝色值（0~255）
     * @param alpha 透明度（0.0 ~ 1.0）
     */
    public Color(Integer red, Integer green, Integer blue, Double alpha){
        // 设置透明度
        this.setAlpha(alpha);

        // 设置rgb值
        this.setRed(red);
        this.setGreen(green);
        this.setBlue(blue);
    }

    /**
     * 通过颜色字符串初始化
     * @param colorStr 颜色字符串；格式为：rgb(red,green,blue) 或 rgba(red,green,blue,alpha) 或 #hexRedhexGreenhexBlue
     */
    public Color(String colorStr){
        // 字符串转大写、去空格
        colorStr = colorStr.replaceAll("\\s*", "").toUpperCase();

        if(colorStr.startsWith("#")) {
            this.alpha = 1.0;
            this.setHex(colorStr);
        } else if(colorStr.startsWith("RGB(") && colorStr.endsWith(")")) {
            this.alpha = 1.0;
            this.setRgb(colorStr);
        }else if (colorStr.startsWith("RGBA(") && colorStr.endsWith(")")) {
            this.setRgba(colorStr);
        }else {
            throw new ColorParseException("Color parsing failed, please check color code format. The format is: \"rgb(red,green,blue)\" or \"rgba(red,green,blue,alpha)\" or \"#hexRedhexGreenhexBlue\".");
        }
    }

    /**
     * 获取红色值
     * @return 红色值（0~255）
     */
    public Integer getRed(){
        return this.red;
    }

    /**
     * 设置红色值
     * @param red 红色值（0~255）
     */
    public void setRed(Integer red) {
        // 检查颜色值
        if(red < 0 || red > 255)
            throw new ColorOutOfRangeException("Red out of range, please set value in 0 ~ 255.");

        // 设置红色值
        this.red = red;
        // 红色值转十六进制红色值，并设置十六进制红色值
        this.hexRed = this.normalToHex(red);

        // 刷新
        this.refresh();
    }

    /**
     * 获取绿色值
     * @return 绿色值（0~255）
     */
    public Integer getGreen(){
        return this.green;
    }

    /**
     * 设置绿色值
     * @param green 绿色值（0~255）
     */
    public void setGreen(Integer green) {
        // 检查颜色值
        if(green < 0 || green > 255)
            throw new ColorOutOfRangeException("Green out of range, please set value in 0 ~ 255.");

        // 设置绿色值
        this.green = green;
        // 绿色值转十六进制红色值，并设置十六进制绿色值
        this.hexGreen = this.normalToHex(green);

        // 刷新
        this.refresh();
    }

    /**
     * 获取蓝色值
     * @return 蓝色值（0~255）
     */
    public Integer getBlue(){
        return this.blue;
    }

    /**
     * 设置蓝色值
     * @param blue 蓝色值（0~255）
     */
    public void setBlue(Integer blue) {
        // 检查颜色值
        if(blue < 0 || blue > 255)
            throw new ColorOutOfRangeException("Blue out of range, please set value in 0 ~ 255.");

        // 设置蓝色值
        this.blue = blue;
        // 绿色值转十六进制红色值，并设置十六进制绿色值
        this.hexBlue = this.normalToHex(blue);

        // 刷新
        this.refresh();
    }

    /**
     * 获取十六进制红色值
     * @return 十六进制红色值（00-FF）
     */
    public String getHexRed(){
        return this.hexRed;
    }

    /**
     * 设置十六进制红色值
     * @param hexRed 十六进制红色值（00-FF）
     */
    public void setHexRed(String hexRed) {
        // 去空格、转大写
        hexRed = hexRed.replaceAll("\\s*", "").toUpperCase();

        // 检查颜色值
        checkHexColorString(hexRed,"HexRed");

        // 设置十六进制红色值
        this.hexRed = hexRed;
        // 设置红色值
        this.red = hexToNormal(hexRed);

        // 刷新
        this.refresh();
    }

    /**
     * 获取十六进制绿色值
     * @return 十六进制绿色值（00-FF）
     */
    public String getHexGreen(){
        return this.hexGreen;
    }

    /**
     * 设置十六进制绿色值
     * @param hexGreen 十六进制绿色值（00-FF）
     */
    public void setHexGreen(String hexGreen) {
        // 去空格、转大写
        hexGreen = hexGreen.replaceAll("\\s*", "").toUpperCase();

        // 检查颜色值
        checkHexColorString(hexGreen,"HexGreen");

        // 设置十六进制绿色值
        this.hexGreen = hexGreen;
        // 设置绿色值
        this.green = hexToNormal(hexGreen);

        // 刷新
        this.refresh();
    }

    /**
     * 获取十六进制蓝色值
     * @return 十六进制蓝色值（00-FF）
     */
    public String getHexBlue(){
        return this.hexBlue;
    }

    /**
     * 设置十六进制蓝色值
     * @param hexBlue 十六进制蓝色值（00-FF）
     */
    public void setHexBlue(String hexBlue) {
        // 去空格、转大写
        hexBlue = hexBlue.replaceAll("\\s*", "").toUpperCase();

        // 检查颜色值
        checkHexColorString(hexBlue,"HexBlue");

        // 设置十六进制蓝色值
        this.hexBlue = hexBlue;
        // 设置蓝色值
        this.blue = hexToNormal(hexBlue);

        // 刷新
        this.refresh();
    }

    /**
     * 获取透明度
     * @return 透明度（0.0 ~ 1.0）
     */
    public Double getAlpha(){
        return this.alpha;
    }

    /**
     * 设置透明度
     * @param alpha 透明度（0.0 ~ 1.0）
     */
    public void setAlpha(Double alpha) {
        // 检查透明度
        if(alpha < 0 || alpha > 1)
            throw new ColorOutOfRangeException("Alpha out of range, please set value in 0.0 ~ 1.0 and keep one decimal place.");
        // 检查小数点
        String[] alphaSplit = alpha.toString().split("\\.");
        if(alphaSplit.length > 1)
            if(alphaSplit[1].length() > 1)
                throw new ColorOutOfRangeException("Alpha out of range, please set value in 0.0 ~ 1.0 and keep one decimal place.");

        // 设置透明度
        this.alpha = alpha;

        // 刷新
        this.refresh();
    }

    /**
     * 获取RGB值
     * @return RGB值；格式：rgb(red, green, blue)
     */
    public String getRgb(){
        return this.rgb;
    }

    /**
     * 设置RGB值
     * @param rgb RGB值；格式：rgb(red, green, blue)
     */
    public void setRgb(String rgb) {
        // 解析rgb字符串
        Integer[] rgbArray = parseRGB(rgb);

        // 设置颜色值
        this.setRed(rgbArray[0]);
        this.setGreen(rgbArray[1]);
        this.setBlue(rgbArray[2]);

        // 设置十六进制颜色值
        this.setHexRed(this.normalToHex(this.getRed()));
        this.setHexGreen(this.normalToHex(this.getGreen()));
        this.setHexBlue(this.normalToHex(this.getBlue()));

        // 刷新
        this.refresh();
    }

    /**
     * 获取RGBA值
     * @return RGBA值；格式：rgba(red, green, blue, alpha)
     */
    public String getRgba(){
        return this.rgba;
    }

    /**
     * 设置RGBA值
     * @param rgba RGBA值；格式：rgba(red, green, blue, alpha)
     */
    public void setRgba(String rgba) {
        // 解析rgb字符串
        Double[] rgbaArray = parseRGBA(rgba);

        // 设置颜色值
        this.setRed((int)(double)rgbaArray[0]);
        this.setGreen((int)(double)rgbaArray[1]);
        this.setBlue((int)(double)rgbaArray[2]);
        this.setAlpha(rgbaArray[3]);

        // 设置十六进制颜色值
        this.setHexRed(this.normalToHex(this.getRed()));
        this.setHexGreen(this.normalToHex(this.getGreen()));
        this.setHexBlue(this.normalToHex(this.getBlue()));

        // 刷新
        this.refresh();
    }

    /**
     * 获取十六进制颜色值
     * @return 十六进制颜色值；格式：#hexRedhexGreenhexBlue
     */
    public String getHex(){
        return this.hex;
    }

    /**
     * 设置HEX值
     * @param hex 十六进制颜色值；格式：#hexRedhexGreenhexBlue
     */
    public void setHex(String hex) {
        // 解析hex字符串
        String[] hexArray = parseHex(hex);

        // 设置十六进制颜色值
        this.setHexRed(hexArray[0]);
        this.setHexGreen(hexArray[1]);
        this.setHexBlue(hexArray[2]);

        // 设置颜色值
        this.setRed(this.hexToNormal(this.getHexRed()));
        this.setGreen(this.hexToNormal(this.getHexGreen()));
        this.setBlue(this.hexToNormal(this.getHexBlue()));

        // 刷新
        this.refresh();
    }


    /**
     * 解析RGB字符串
     * @param rgb RGB值；格式：rgb(red, green, blue)
     * @return 颜色值数组；0: red; 1: green; 2: blue;
     */
    private Integer[] parseRGB(String rgb){
        // 去空格、转大写
        rgb = rgb.replaceAll("\\s*", "").toUpperCase();

        // 检查是否为“rgb(”开头、“)”结束
        if(rgb.startsWith("RGB(") && rgb.endsWith(")"))
            rgb = rgb.substring(4, rgb.length()-1);

        // rgb字符串数组 通过“,”分割
        String[] rgbStrArray = rgb.split(",");

        // 判断数组长度是否小于1
        if(rgbStrArray.length < 1)
            throw new ColorParseException("RGB parsing failed, please check RGB format. The format is: \"rgb(red,green,blue)\" or \"red,green,blue\".");

        // String转int
        int red = Integer.parseInt(rgbStrArray[0]);
        int green = Integer.parseInt(rgbStrArray[1]);
        int blue = Integer.parseInt(rgbStrArray[2]);

        // 返回rgb颜色数组
        return new Integer[]{red, green, blue};
    }

    /**
     * 解析RGBA字符串
     * @param rgba RGBA值；格式：rgba(red, green, blue, alpha)
     * @return 颜色值数组；0: red; 1: green; 2: blue; 3: alpha;
     */
    private Double[] parseRGBA(String rgba){
        // 去空格、转大写
        rgba = rgba.replaceAll("\\s*", "").toUpperCase();

        // 检查是否为“rgba(”开头、“)”结束
        if(rgba.startsWith("RGBA(") && rgba.endsWith(")"))
            rgba = rgba.substring(5, rgba.length()-1);

        // rgb字符串数组 通过“,”分割
        String[] rgbaStrArray = rgba.split(",");

        // 判断数组长度是否小于1
        if(rgbaStrArray.length < 1)
            throw new ColorParseException("RGBA parsing failed, please check RGBA format. The format is: \"rgba(red,green,blue,alpha)\" or \"red,green,blue,alpha\".");

        // String转double
        double red = Double.parseDouble(rgbaStrArray[0]);
        double green = Double.parseDouble(rgbaStrArray[1]);
        double blue = Double.parseDouble(rgbaStrArray[2]);
        double alpha = Double.parseDouble(rgbaStrArray[3]);

        // 返回rgba颜色数组
        return new Double[]{red, green, blue, alpha};
    }

    /**
     * 解析HEX字符串
     * @param hex 十六进制颜色值
     * @return 颜色值数组；0: hexRed; 1: hexGreen; 2: hexBlue;
     */
    private String[] parseHex(String hex){
        // 字符串去空格、转大写
        hex = hex.replaceAll("\\s*", "").toUpperCase();

        // 去起始“#”
        if(hex.startsWith("#"))
            hex = hex.substring(1);

        // 声明颜色值
        String hexRed;
        String hexGreen;
        String hexBlue;

        // 检查字符串长度
        if(hex.length() == 3){
            // 取出颜色值
            hexRed = hex.substring(0, 1);
            hexGreen = hex.substring(1, 2);
            hexBlue = hex.substring(2);

            // 补全hexColor
            hexRed += hexRed;
            hexGreen += hexGreen;
            hexBlue += hexBlue;
        }else if(hex.length() == 6){
            // 取出颜色值
            hexRed = hex.substring(0, 2);
            hexGreen = hex.substring(2, 4);
            hexBlue = hex.substring(4);
        }else{
            throw new ColorParseException("Hex color parsing failed, please check hex color format. The format is: \"#hexColor\" or \"hexColor\", examples: \"#FFFFFF\" or \"#FFF\" or \"FFFFFF\" or \"FFF\".");
        }

        // 返回hex颜色数组
        return new String[]{hexRed, hexGreen, hexBlue};
    }

    /**
     * 生成RGB值
     * @return RGB值；格式：rgb(red, green, blue)
     */
    private synchronized String generateRgb(){
        // 准备结果
        String result = "rgb(";

        // 添加红色值
        result += this.getRed();
        result += ", ";
        // 添加绿色值
        result += this.getGreen();
        result += ", ";
        // 添加蓝色值
        result += this.getBlue();
        result += ")";

        // 返回结果
        return result;
    }

    /**
     * 生成RGBA值
     * @return RGBA值；格式：rgb(red, green, blue, alpha)
     */
    private synchronized String generateRgba(){
        // 准备结果
        String result = "rgba(";

        // 添加红色值
        result += this.getRed();
        result += ", ";
        // 添加绿色值
        result += this.getGreen();
        result += ", ";
        // 添加蓝色值
        result += this.getBlue();
        result += ", ";
        // 添加透明度
        result += this.getAlpha();
        result += ", ";

        // 返回结果
        return result;
    }

    /**
     * 生成十六进制值
     * @return 十六进制值；格式：#hexRedhexGreenhexBlue
     */
    private synchronized String generateHex(){
        // 准备结果
        String result = "#";

        // 添加红色值
        result += this.getHexRed();
        // 添加绿色值
        result += this.getHexGreen();
        // 添加蓝色值
        result += this.getHexBlue();

        // 返回结果
        return result;
    }

    /**
     * 十进制转十六进制
     * @param number 十进制数
     * @return 十六进制字符串
     */
    private String normalToHex(Integer number){
        // 十进制转十六进制
        String hexNumber = Integer.toHexString(number).toUpperCase();

        // 检查十六进制字符串长度
        if(hexNumber.length() == 1) // 一位
            hexNumber = 0 + hexNumber; // 前位+0

        // 返回十六进制字符串
        return hexNumber;
    }

    /**
     * 十六进制转十进制
     * @param hexStr 十六进制字符串
     * @return 十进制数
     */
    private Integer hexToNormal(String hexStr) {
        // 去空格转大写
        hexStr = hexStr.replaceAll("\\s*", "");

        // 准备结果
        int result = 0;

        // 十六进制字母集合
        Map<String, Integer> hexLettersMap = new HashMap<>();
        // 十六进制字符填充至集合
        for (int i = 0; i < hex_letters.length; i++) {
            hexLettersMap.put(hex_letters[i], i);
        }

        // 将十六进制字符串转为数组
        String[] hexStrArray = new String[hexStr.length()];
        for(int i = 0; i < hexStrArray.length; i++){
            hexStrArray[i] = hexStr.substring(i, i+1);
        }

        // 转十进制数
        for(int i = 0; i < hexStrArray.length; i++){
            result += hexLettersMap.get(hexStrArray[i]) * Math.pow(16, hexStrArray.length - 1 - i);
        }

        // 返回结果
        return result;
    }

    /**
     * 检查十六进制颜色字符串（两位：00~FF）
     * @param hexStr 十六进制字符串（00~FF）
     * @param errorFieldName 发生错误的字段名
     */
    private void checkHexColorString(String hexStr, String errorFieldName){
        // 去空格，转大写
        hexStr = hexStr.replaceAll("\\s*", "").toUpperCase();

        // 截取字符
        String firstLetter;
        String secondLetter;

        // 检查格式
        if(hexStr.length() == 1){
            firstLetter = secondLetter = hexStr;
        }else if(hexStr.length() == 2){
            firstLetter = hexStr.substring(0,1);
            secondLetter = hexStr.substring(1);
        }else{
            throw new ColorOutOfRangeException(errorFieldName + " out of range, please set value in 00 ~ FF.");
        }

        // 字符正确标识
        boolean firstRight = false;
        boolean secondRight = false;

        // 检查第一个字符
        for (String letter : hex_letters) {
            if(letter.equals(firstLetter)){
                firstRight = true;
                break;
            }
        }

        // 检查第二个字符
        for (String letter : hex_letters) {
            if(letter.equals(secondLetter)){
                secondRight = true;
                break;
            }
        }

        // 判断是否全部正确
        if(!firstRight || !secondRight)
            throw new ColorOutOfRangeException(errorFieldName + " out of range, please set value in 00 ~ FF.");
    }

    /**
     * 刷新
     */
    private void refresh(){
        // 生成并设置rgb值
        this.rgb = this.generateRgb();
        // 生成并设置rgba值
        this.rgba = this.generateRgba();
        // 生成并设置十六进制颜色值
        this.hex = this.generateHex();
    }

    /**
     * 对象转字符串
     * @return 字符串
     */
    public String toString(){
        return "Color: {" +
                "\n\tred: " + this.getRed() +
                ",\n\tgreen: " + this.getGreen() +
                ",\n\tblue: " + this.getBlue() +
                ",\n\talpha: " + this.getAlpha() +
                ",\n\trgb: " + this.getRgb() +
                ",\n\trgba: " + this.getRgba() +
                ",\n\thexRed: " + this.getHexRed() +
                ",\n\thexGreen: " + this.getHexGreen() +
                ",\n\thexBlue: " + this.getHexBlue() +
                ",\n\thex: " + this.getHex() +
                "\n}";
    }

    /**
     * 颜色超出范围异常
     */
    public static class ColorOutOfRangeException extends RuntimeException{
        public ColorOutOfRangeException(String message) {
            super(message);
        }
    }

    /**
     * 颜色解析异常
     */
    public static class ColorParseException extends RuntimeException{
        public ColorParseException(String message) {
            super(message);
        }
    }
}