这篇文章主要介绍Java基础之颜色工具类的示例分析，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！
1.SpringMVC，Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架。2.Shiro，Apache Shiro是Java的一个安全框架。3.Mybatis，MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。4.Dubbo，Dubbo是一个分布式服务框架。5.Maven，Maven是个项目管理和构建自动化工具。6.RabbitMQ，RabbitMQ是用Erlang实现的一个高并发高可靠AMQP消息队列服务器。7.Ehcache，EhCache 是一个纯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<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);
}
}
}以上是“Java基础之颜色工具类的示例分析”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注亿速云行业资讯频道！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
