Java 颜色工具类（超详细注释）

梦里梦外; 2023-01-17 02:26 128阅读 0赞

# 颜色工具类（超详细注释） #

设置属性值自动格式化rgb值和十六进制颜色值。

import java.text.DecimalFormat;
    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 Integer red; // 红色值（0 ~ 255）
      private Integer green; // 绿色值（0 ~ 255）
      private Integer blue; // 蓝色值（0 ~ 255）
      private Integer alpha;// 透明度（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 hexAlpha; // 十六进制透明度（00 ~ FF）
    
      private String hex; // 十六进制颜色值；格式：#hexRedhexGreenhexBlue
    
      /**
       * 无参构造器 默认黑色不透明
       */
      public Color() {
        
        this.red = 0x00;
        this.green = 0x00;
        this.blue = 0x00;
        this.alpha = 0xFF;
        this.hexRed = "00";
        this.hexGreen = "00";
        this.hexBlue = "00";
        this.hexAlpha = "FF";
        this.rgb = "rgb(0, 0, 0)";
        this.rgba = "rgba(0, 0, 0, 1.0)";
        this.hex = "#FF000000";
      }
    
      /**
       * 通过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, 0xFF);
      }
    
      /**
       * 通过RGBA四值初始化
       *
       * @param red   红色值（0 ~ 255）
       * @param green 绿色值（0 ~ 255）
       * @param blue  蓝色值（0 ~ 255）
       * @param alpha 透明度（0 ~ 255）
       */
      public Color(Integer red, Integer green, Integer blue, Integer 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.setHex(colorStr);
        } else if (colorStr.startsWith("RGB(") && colorStr.endsWith(")")) {
        
          this.setAlpha(0xFF);
          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 ~ 255）
       */
      public Integer getAlpha() {
        
        return this.alpha;
      }
    
      /**
       * 设置透明度
       * 
       * @param alpha 透明度（0 ~ 255）
       */
      public void setAlpha(Integer alpha) {
        
        // 检查透明度
        if (alpha < 0 || alpha > 255)
          throw new ColorOutOfRangeException("Alpha out of range, please set value in 0 ~ 255 and keep one decimal place.");
    
        // 设置透明度
        this.alpha = alpha;
        // 设置十六进制透明度
        this.hexAlpha = normalToHex(alpha);
    
        // 刷新
        this.refresh();
      }
    
      /**
       * 获取十六进制透明度
       */
      public String getHexAlpha() {
        
        return this.hexAlpha;
      }
    
      /**
       * 设置十六进制透明度
       * 
       * @param hexAlpha 十六进制透明度（00 ~ FF）
       */
      public void setHexAlpha(String hexAlpha) {
        
        // 去空格、转大写
        hexAlpha = hexAlpha.replaceAll("\\s*", "").toUpperCase();
    
        // 检查颜色值
        checkHexColorString(hexAlpha, "HexAlpha");
    
        // 设置十六进制透明度
        this.hexAlpha = hexAlpha;
        // 设置透明度
        this.alpha = hexToNormal(hexAlpha);
    
        // 刷新
        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字符串
        int[] rgbArray = parseRGB(rgb);
    
        // 设置颜色值
        this.setRed(rgbArray[0]);
        this.setGreen(rgbArray[1]);
        this.setBlue(rgbArray[2]);
        this.setAlpha(0xFF);
    
        // 刷新
        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字符串
        int[] rgbaArray = parseRGBA(rgba);
    
        // 设置颜色值
        this.setRed(rgbaArray[0]);
        this.setGreen(rgbaArray[1]);
        this.setBlue(rgbaArray[2]);
        this.setAlpha(rgbaArray[3]);
    
        // 刷新
        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.setHexAlpha(hexArray[0]);
        this.setHexRed(hexArray[1]);
        this.setHexGreen(hexArray[2]);
        this.setHexBlue(hexArray[3]);
    
        // 刷新
        this.refresh();
      }
    
      /**
       * 解析RGB字符串
       * 
       * @param rgb RGB值；格式：rgb(red, green, blue)
       * @return 颜色值数组；0: red; 1: green; 2: blue;
       */
      private int[] 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 int[] {
         red, green, blue };
      }
    
      /**
       * 解析RGBA字符串
       * 
       * @param rgba RGBA值；格式：rgba(red, green, blue, alpha)
       * @return 颜色值数组；0: red; 1: green; 2: blue; 3: alpha;
       */
      private int[] 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转int
        int red = Integer.parseInt(rgbaStrArray[0]);
        int green = Integer.parseInt(rgbaStrArray[1]);
        int blue = Integer.parseInt(rgbaStrArray[2]);
        int alpha = getIntAlpha(Double.parseDouble(rgbaStrArray[3]));
    
        // 返回rgba颜色数组
        return new int[] {
         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 = null;
        String hexGreen = null;
        String hexBlue = null;
        String hexAlpha = null;
    
        switch (hex.length()) {
        
          case 3:
            // 指定透明度为不透明
            hexAlpha = "FF";
            // 取出颜色值
            hexRed = hex.substring(0, 1);
            hexGreen = hex.substring(1, 2);
            hexBlue = hex.substring(2);
            // 补全hexColor
            hexRed += hexRed;
            hexGreen += hexGreen;
            hexBlue += hexBlue;
            break;
          case 4:
            // 取出颜色值
            hexAlpha = hex.substring(0, 1);
            hexRed = hex.substring(1, 2);
            hexGreen = hex.substring(2, 3);
            hexBlue = hex.substring(3);
            // 补全hexColor
            hexAlpha += hexAlpha;
            hexRed += hexRed;
            hexGreen += hexGreen;
            hexBlue += hexBlue;
            break;
          case 6:
            // 指定透明度为不透明
            hexAlpha = "FF";
            // 取出颜色值
            hexRed = hex.substring(0, 2);
            hexGreen = hex.substring(2, 4);
            hexBlue = hex.substring(4);
            break;
          case 8:
            // 取出颜色值
            hexAlpha = hex.substring(0, 2);
            hexRed = hex.substring(2, 4);
            hexGreen = hex.substring(4, 6);
            hexBlue = hex.substring(6);
            break;
          default:
            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[] {
         hexAlpha, 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 += getDoubleAlpha(this.getAlpha());
        result += ")";
    
        // 返回结果
        return result;
      }
    
      /**
       * 生成十六进制值
       * 
       * @return 十六进制值；格式：#hexRedhexGreenhexBlue
       */
      private synchronized String generateHex() {
        
        // 准备结果
        String result = "#";
    
        // 添加透明度
        result += this.getHexAlpha();
        // 添加红色值
        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;
      }
    
      /**
       * 获取整型透明度
       * 
       * @param alpha 透明度（0.0 ~ 1.0）
       * @return 整型透明度
       */
      private Integer getIntAlpha(Double alpha) {
        
        if (alpha == null)
          return null;
        // 检查透明度是否超出范围
        if (alpha < 0 || alpha > 1)
          throw new ColorOutOfRangeException("Float alpha out of range, please set value in 0.0 ~ 1.0");
    
        return (int) Math.round(alpha * 255);
      }
    
      /**
       * 获取浮点型透明度
       * 
       * @param alpha 透明度（0 ~ 255）
       * @return 浮点型透明度
       */
      private Double getDoubleAlpha(Integer alpha) {
        
        if (alpha == null)
          return null;
        // 检查透明度是否超出范围
        if (alpha < 0 || alpha > 255)
          throw new ColorOutOfRangeException("Float alpha out of range, please set value in 0 ~ 255");
    
        // 保留一位小数
        DecimalFormat df = new DecimalFormat("#.#");
    
        return Double.parseDouble(df.format((double) alpha / 255));
      }
    
      /**
       * 检查十六进制颜色字符串（两位：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\thexAlpha: " + this.getHexAlpha() + 
          ",\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);
        }
      }
    }