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

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

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

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

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 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);

}

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。