颜色工具类(超详细注释)

设置属性值自动格式化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基础之颜色工具类(超详细注释)的文章就介绍到这了,更多相关Java颜色工具类内容请搜索程序员的世界以前的文章或继续浏览下面的相关文章希望大家以后多多支持程序员的世界!

Java基础之颜色工具类(超详细注释)的更多相关文章

  1. JVM系列(三):JVM创建过程解析

    上两篇中梳理了整个java启动过程中,jvm大致是如何运行的。即厘清了我们认为的jvm的启动过程。但那里面仅为一些大致的东西,比如参数解析,验证,dll加载等等。把最核心的loadJavaVM()交给了一个dll或者so库。也就是真正的jvm我们并没有接触到,我们仅看了一个包装者或者是上层应用的实现......

  2. 解决Mybatis-plus和pagehelper依赖冲突的方法示例

    简介MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。启动即会自动注入基本 CURD,性能基本无损耗,直接面向对象操作Mybati-plus本身自带分页功能,但是我个人一直是使用pagehelpe......

  3. Java中类的定义和初始化示例详解

    类的定义类的定义格式//创建类class ClassName{field ;//成员属性/字段method;//方法}class为定义类的关键字,ClassName为类的名字,{ }为类的主体;例如:class Person{public String name ; //成员属性public int......

  4. 文件监控性能问题【BUG】

    文件监控性能问题【BUG】背景:JAVA写了一个文件夹目录监控的程序,使用的是org.apache.commons.io.monitor 包,项目稳定运行了一个月,现场反馈,文件夹数据处理越来越慢,等到数据推送到前端要好几分钟,于是开始了寻找问题的路程。监控代码之前写的文件监控代码问题发现我在Ap......

  5. java实现打印日历

    本文实例为大家分享了java实现打印日历的具体代码,供大家参考,具体内容如下效果图代码:/***需要实现的目标:根据输入的年月打印出本月的日历表*说明:1900年1月1日刚好是星期一,所以需要计算出从1900 年到当前年月的前一个月总*共经历了几天,然后根据每周七天,用总天数除以7取余数,此余数就是......

  6. Java关于继承、重写与重载、封装、接口的硬核干货

    Java语言在面向对象方面的知识点复杂繁琐,但是几乎是每个小伙伴学习编程必须踩的坑,其实,面向对象的底层都是一些计算机底层知识的结合,所以,不注重基础的程序猿,一定不是一个可以走的远的程序猿。那么,今天,我们先逐一地深入了解继承、重载、接口和构造器的知识。在学习这篇文章之前,如果有小伙伴对new过程......

  7. Java并发编程实战(5)- 线程生命周期

    在这篇文章中,我们来聊一下线程的生命周期。在这篇文章中,我们来聊一下线程的生命周期。目录概述操作系统中的线程生命周期Java中的线程生命周期Java线程状态转换运行状态和阻塞状态之间的转换运行状态和无时限等待状态的切换运行状态和有时限等待状态的切换初始化状态和运行状态的切换运行状态和终止状态的切换手......

  8. java中instanceof 关键字作用和实际用途详解

    instanceof1. instanceof 是Java中的一个关键字,Java中的关键子都是小写。2. instanceof关键字的作用是判断左边对象是否是右边类(这里有很多人说是对象,所以注意这里是类,并不是对象)的实例(通俗易懂的说就是:子类对象,或者右边类本身的对象)返回的boolean类......

  9. Java中Jackson快速入门

    Java生态圈中有很多处理JSON和XML格式化的类库,Jackson是其中比较著名的一个。虽然JDK自带了XML处理类库,但是相对来说比较低级,使用本文介绍的Jackson等高级类库处理起来会方便很多。引入类库由于Jackson相关类库按照功能分为几个相对独立的,所以需要同时引入多个类库,为了方便......

  10. Java中,那些关于String和字符串常量池你不得不知道的东西

    老套的笔试题在一些老套的笔试题中,会要你判断s1==s2为false还是true,s1.equals(s2)为false还是true。String s1 = new String("xyz");String s2 = "xyz";System.out.prin......

随机推荐

  1. 解决使用pandas聚类时的小坑

    问题背景:之前运行测试好好的程序,忽然出现了报错,还是merge时候的类型错误,这个bug有点蹊跷。问题分析:代码:进行聚类之后计算平均值与方差tmp_df = df[['object1', 'float']].groupby(['object1']).head(20).groupby(['obje......

  2. Android 常见bug汇总及解决方案

    作为开发人员,平时总会遇到各种各样的问题,之前都没有收集bug的习惯,遇到相同的问题总会有种莫名的熟悉感,或许把问题都汇总,方便查找,也可以给大家踩踩坑,后面会陆续更新补充!1、关于使用OkHttp运行时出现的错误报错如下:Static interface methods are o......

  3. c# Linq查询详解

    c#提供的ling查询极大的遍历了集合的查询过程,且使用简单方便,非常的有用。下面将分别用简单的例子说明:ling基本查询、延迟查询属性、类型筛选、复合from字句、多级排序、分组查询、联合查询、合并、分页、聚合操作符、并行linq、取消长时间运行的并行ling查询。Lambda表达式简介:/*La......

  4. php微信小程序解包过程实例详解

    这个解包只能看个大概1.找到小程序压缩包1.1、手机root或安装模拟器(我用的是夜神)1.2、在模拟器上安装微信(用android5系统的模拟器,低版本小程序容易打不开)1.3、打开登陆微信后,打开小程序1.4、打开模拟器自带的文件管理器来到目录:/data/data/com.tencent.mm......

  5. Winform 窗体自适应

    前言在使用 Winform 开发过程中,经常发些因为显示器分辨率、窗体大小改变,控件却不能自适应变化,几经查找资料,和大佬的代码。经过细小修改,终于可以让窗体在外界影响下,窗体内背景图片、控件都会自适应变化大小(类似于网页的响应式)。代码完整代码如下:using System;using Syste......

  6. 讲讲Java8的Optional类

    前言Java 8中引入了 Optional 类来解决 NullPointerException 与繁琐的 null 检查,该类首次出现在 Guava。Java 8 才成为类库中的一部分。入门Optional 是一个封装值的类,用于保存类型为 T 的值;本质上,Optional 就是一个容器。举例来说......

  7. MySQL mysqladmin客户端的使用简介

    mysqladmin是MySQL官方提供的shell命令行工具,它的参数都需要在shell命令行里面执行,当我们使用mysqladmin的时候,必须指定两类参数,一类是连接参数,另外一类是命令参数,连接参数用来指定相应的连接信息,而命令参数用来指定命令信息,例如可以用来检查服务器的配置和当前状态、创......

  8. ASP下通过Adodb.Stream实现多线程下载大文件

    有个朋友 做 某种小众音乐交换站的(他们那个行业的昵图网),需要用到付费下载。尝试过 防盗链,不太理想,最终使用了 Adodb.Stream 读取,直接输出。解决了 盗版的问题,但是新的问题又来了。Adodb.Stream 这种方式 电脑还好说,大部分电脑浏览器都支持。移动端 很多 浏览器为了 加速......

  9. sqlserver查询去掉重复数据的实现

    说明:只要数据表“列名”数据相同,则说明是两条重复的数据(ID为数据表的主键自动增长)。推荐使用方法一-- 方法一select * from 表名 A where not exists(select 1 from 表名 where 列名=A.列名 and ID补充:SQL SERVER 查询去重 P......

  10. Python 日志打印之logging.getLogger源码分析

    日志打印之logging.getLogger源码分析日志打印之logging.getLogger源码分析By:授客 QQ:1033553122 #实践环境WIN 10Python 3.6.5#函数说明logging.getLogger(name=None)getLogger函数位于logging/_......