Commons-lang3

Brilliant Nemo

于 2025-07-17 15:44:59 发布

阅读量555

点赞数 13

CC 4.0 BY-SA版权

分类专栏： java常识文章标签： java

本文链接：https://blog.youkuaiyun.com/lzping_719/article/details/149422817

java常识专栏收录该内容

5 篇文章

订阅专栏

一、基本介绍

commons-lang3：常用工具类commons-lang3的学习使用-优快云博客

apache提供的众多commons工具包，号称Java第二API，而common里面lang3包更是被我们使用得最多的。因此本文主要详细讲解lang3包里面几乎每个类的使用，希望以后大家使用此工具包。

二、commons-lang3库的引用

Maven

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.9</version>
</dependency>

三、常用工具类

1. StringUtils

字符串的处理类（StringUtils)

//缩短到某长度,用...结尾.其实就是(substring(str, 0, max-3) + "...")
        //public static String abbreviate(String str,int maxWidth)
        StringUtils.abbreviate("abcdefg", 6);// ---"abc..."
 
        //字符串结尾的后缀是否与你要结尾的后缀匹配，若不匹配则添加后缀
        StringUtils.appendIfMissing("abc","xyz");//---"abcxyz"
        StringUtils.appendIfMissingIgnoreCase("abcXYZ","xyz");//---"abcXYZ"
 
        //首字母大小写转换
        StringUtils.capitalize("cat");//---"Cat"
        StringUtils.uncapitalize("Cat");//---"cat"
 
        //字符串扩充至指定大小且居中（若扩充大小少于原字符大小则返回原字符，若扩充大小为 负数则为0计算 ）
        StringUtils.center("abcd", 2);//--- "abcd"
        StringUtils.center("ab", -1);//--- "ab"
        StringUtils.center("ab", 4);//---" ab "
        StringUtils.center("a", 4, "yz");//---"yayz"
        StringUtils.center("abc", 7, "");//---"  abc  "
 
        //去除字符串中的"\n", "\r", or "\r\n"
        StringUtils.chomp("abc\r\n");//---"abc"
 
        //判断一字符串是否包含另一字符串
        StringUtils.contains("abc", "z");//---false
        StringUtils.containsIgnoreCase("abc", "A");//---true
 
        //统计一字符串在另一字符串中出现次数
        StringUtils.countMatches("abba", "a");//---2
 
        //删除字符串中的梭有空格
        StringUtils.deleteWhitespace("   ab  c  ");//---"abc"
 
        //比较两字符串，返回不同之处。确切的说是返回第二个参数中与第一个参数所不同的字符串
        StringUtils.difference("abcde", "abxyz");//---"xyz"
 
        //检查字符串结尾后缀是否匹配
        StringUtils.endsWith("abcdef", "def");//---true
        StringUtils.endsWithIgnoreCase("ABCDEF", "def");//---true
        StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true
 
        //检查起始字符串是否匹配
        StringUtils.startsWith("abcdef", "abc");//---true
        StringUtils.startsWithIgnoreCase("ABCDEF", "abc");//---true
        StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true
 
        //判断两字符串是否相同
        StringUtils.equals("abc", "abc");//---true
        StringUtils.equalsIgnoreCase("abc", "ABC");//---true
 
        //比较字符串数组内的所有元素的字符序列，起始一致则返回一致的字符串，若无则返回""
        StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"});//---"ab"
 
        //正向查找字符在字符串中第一次出现的位置
        StringUtils.indexOf("aabaabaa", "b");//---2
        StringUtils.indexOf("aabaabaa", "b", 3);//---5(从角标3后查找)
        StringUtils.ordinalIndexOf("aabaabaa", "a", 3);//---1(查找第n次出现的位置)
 
        //反向查找字符串第一次出现的位置
        StringUtils.lastIndexOf("aabaabaa", ‘b‘);//---5
        StringUtils.lastIndexOf("aabaabaa", ‘b‘, 4);//---2
        StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2);//---1
 
        //判断字符串大写、小写
        StringUtils.isAllUpperCase("ABC");//---true
        StringUtils.isAllLowerCase("abC");//---false
 
        //判断是否为空(注：isBlank与isEmpty 区别)
        StringUtils.isBlank(null);StringUtils.isBlank("");StringUtils.isBlank(" ");//---true
        StringUtils.isNoneBlank(" ", "bar");//---false
 
        StringUtils.isEmpty(null);StringUtils.isEmpty("");//---true
        StringUtils.isEmpty(" ");//---false
        StringUtils.isNoneEmpty(" ", "bar");//---true
 
        //判断字符串数字
        StringUtils.isNumeric("123");//---false
        StringUtils.isNumeric("12 3");//---false (不识别运算符号、小数点、空格……)
        StringUtils.isNumericSpace("12 3");//---true
 
        //数组中加入分隔符号
        //StringUtils.join([1, 2, 3], ‘;‘);//---"1;2;3"
 
        //大小写转换
        StringUtils.upperCase("aBc");//---"ABC"
        StringUtils.lowerCase("aBc");//---"abc"
        StringUtils.swapCase("The dog has a BONE");//---"tHE DOG HAS A bone"
 
        //替换字符串内容……（replacePattern、replceOnce）
        StringUtils.replace("aba", "a", "z");//---"zbz"
        StringUtils.overlay("abcdef", "zz", 2, 4);//---"abzzef"(指定区域)
        StringUtils.replaceEach("abcde", new String[]{"ab", "d"},
                new String[]{"w", "t"});//---"wcte"(多组指定替换ab->w，d->t)
 
        //重复字符
        StringUtils.repeat(‘e‘, 3);//---"eee"
 
        //反转字符串
        StringUtils.reverse("bat");//---"tab"
 
        //删除某字符
        StringUtils.remove("queued", ‘u‘);//---"qeed"
 
        //分割字符串
        StringUtils.split("a..b.c", ‘.‘);//---["a", "b", "c"]
        StringUtils.split("ab:cd:ef", ":", 2);//---["ab", "cd:ef"]
        StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2);//---["ab", "cd-!-ef"]
        StringUtils.splitByWholeSeparatorPreserveAllTokens("ab::cd:ef", ":");//-["ab"," ","cd","ef"]
 
        //去除首尾空格，类似trim……（stripStart、stripEnd、stripAll、stripAccents）
        StringUtils.strip(" ab c ");//---"ab c"
        StringUtils.stripToNull(null);//---null
        StringUtils.stripToEmpty(null);//---""
 
        //截取字符串
        StringUtils.substring("abcd", 2);//---"cd"
        StringUtils.substring("abcdef", 2, 4);//---"cd"
 
        //left、right从左(右)开始截取n位字符
        StringUtils.left("abc", 2);//---"ab"
        StringUtils.right("abc", 2);//---"bc"
        //从第n位开始截取m位字符       n  m
        StringUtils.mid("abcdefg", 2, 4);//---"cdef"
 
        StringUtils.substringBefore("abcba", "b");//---"a"
        StringUtils.substringBeforeLast("abcba", "b");//---"abc"
        StringUtils.substringAfter("abcba", "b");//---"cba"
        StringUtils.substringAfterLast("abcba", "b");//---"a"
 
        StringUtils.substringBetween("tagabctag", "tag");//---"abc"
        StringUtils.substringBetween("yabczyabcz", "y", "z");//---"abc"

扩展：

1. abbreviateMiddle

abbreviateMiddle截取指定字符串，中间使用指定字符代替

/**
    *
    * 截取指定的字符串，中间用指定字符代替。前面字符个数 + 代替字符个数 + 后2个字符 = 截取的字符个    数
    * 显示5个长度的字符串，除了最后一个中间用设置的符号代替
    * 长度不能小于   2
*/
    //截取9个字符，中间使用四个*代替
    String str2 = StringUtils.abbreviateMiddle("15889009897","****",9);
    System.out.println(str2); //158****97
    //字符刚好只有10个
    String s1 = StringUtils.abbreviateMiddle("1342354534", "**", 10);
    System.out.println(s1); //1342354534
    //截取5个字符
    String s2 = StringUtils.abbreviateMiddle("12345678910", "*", 5);
    System.out.println(s2); //12*10
    //截取长度不能小于2
    String s3 = StringUtils.abbreviateMiddle("12345678910", "*", 2);
    System.out.println(s3); //12345678910

2. abbreviate

abbreviate截取指定字符串，多的用指定字符代替

//显示6个长的的字符串，多的用三个点代替（...）
StringUtils.abbreviate("abc中文asdfdefg",6);//输出结果：abc...
StringUtils.abbreviate("这是中文哦可以全部显示吗",5);//这是...
StringUtils.abbreviate("abcdefgh",12); //abcdefgh
StringUtils.abbreviate("abcdaldf","**",3); //a**

3. contains

contains检测某个字符串中是否包含某个字符

 //检测abcde字符串中是否包含abc字符
  StringUtils.contains("abcde", "abc"); //true

4. containsAny

containsAny检测某个字符串中是否包含字符串1或者字符串2……

//检测字符串abcdef中是否保护abm或者y
StringUtils.containsAny("abcdef", "abm", "y"); //false

检测abcdefg字符串中是否包含 "b"或者"h"或者"N”字符串

StringUtils.containsAny("abcdefg", "b", "h", "N"); //true

5. defaultString

defaultString将 null空字符串转为 ""空字符串

//defaultString将 null空字符串转为 ""空字符串
StringUtils.defaultString(null);// ""
StringUtils.defaultString("");// ""
StringUtils.defaultString("bat");//"bat"

6. isEmpty & isNotEmpty

isEmpty和 isNotEmpty判断字符串是否为空

StringUtils.isEmpty(null);//true
StringUtils.isEmpty("");//true
StringUtils.isEmpty(" ");//false
StringUtils.isEmpty("bob");//false
StringUtils.isEmpty("  bob  ");//false
StringUtils.isNotEmpty(null);//false
StringUtils.isNotEmpty("");//false
StringUtils.isNotEmpty(" ");//true
StringUtils.isNotEmpty("bob");//true
StringUtils.isNotEmpty("  bob  ");//true

注意：

isEmpty和 isBlank区别

isEmpty认为 " "是不等于空的。

isBlank认为 " "是等于空的，具有一个前后去掉空格的意思。

7. replace

replace替换字符串

//方法：public static String replace(final String text, final String searchString, final String replacement) {}
 
//将 text字符串中的 searchString字符替换成 replacement
 
StringUtils.replace(null,,);//null
StringUtils.replace("",,);//""
StringUtils.replace("any",null,);//"any"
StringUtils.replace("any",,null);//"any"
StringUtils.replace("any","",);//"any"
StringUtils.replace("aba","a",null);//"aba"
StringUtils.replace("aba","a","");//"b"
StringUtils.replace("aba","a","z");//"zbz"

2. RandomStringUtils

随机数生成类（RandomStringUtils）

//随机生成n位数数字
RandomStringUtils.randomNumeric(n);
//在指定字符串中生成长度为n的随机字符串
RandomStringUtils.random(n, "abcdefghijk");
//指定从字符或数字中生成随机字符串
System.out.println(RandomStringUtils.random(n, true, false));  
System.out.println(RandomStringUtils.random(n, false, true));

3. NumberUtils

//从数组中选出最大值
NumberUtils.max(new int[] { 1, 2, 3, 4 });//---4
//判断字符串是否全是整数
NumberUtils.isDigits("153.4");//--false
//判断字符串是否是有效数字
NumberUtils.isNumber("0321.1");//---false

4. ArrayUtils

//创建数组
String[] array = ArrayUtils.toArray("1", "2");
//判断两个数据是否相等，如果内容相同， 顺序相同 则返回 true
ArrayUtils.isEquals(arr1,arr2);
//判断数组中是否包含某一对象
ArrayUtils.contains(arr, "33");
//二维数组转换成MAP
Map map = ArrayUtils.toMap(new String[][] { 
                { "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } });

5. DateUtils

//日期加n天
DateUtils.addDays(new Date(), n);
//判断是否同一天
DateUtils.isSameDay(date1, date2);
//字符串时间转换为Date
DateUtils.parseDate(str, parsePatterns);

6. StringUtile

/*
 * Copyright 2015-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.funtl.leesite.common.utils;
 
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import javax.servlet.http.HttpServletRequest;
 
import com.google.common.collect.Lists;
 
import org.apache.commons.lang3.StringEscapeUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.LocaleResolver;
 
/**
 * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
 *
 * @author Lusifer
 * @version 2013-05-22
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {
 
    private static final char SEPARATOR = '_';
    private static final String CHARSET_NAME = "UTF-8";
 
    /**
     * 转换为字节数组
     *
     * @param str
     * @return
     */
    public static byte[] getBytes(String str) {
        if (str != null) {
            try {
                return str.getBytes(CHARSET_NAME);
            } catch (UnsupportedEncodingException e) {
                return null;
            }
        } else {
            return null;
        }
    }
 
    /**
     * 转换为字节数组
     *
     * @param str
     * @return
     */
    public static String toString(byte[] bytes) {
        try {
            return new String(bytes, CHARSET_NAME);
        } catch (UnsupportedEncodingException e) {
            return EMPTY;
        }
    }
 
    /**
     * 是否包含字符串
     *
     * @param str  验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inString(String str, String... strs) {
        if (str != null) {
            for (String s : strs) {
                if (str.equals(trim(s))) {
                    return true;
                }
            }
        }
        return false;
    }
 
    /**
     * 替换掉HTML标签方法
     */
    public static String replaceHtml(String html) {
        if (isBlank(html)) {
            return "";
        }
        String regEx = "<.+?>";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(html);
        String s = m.replaceAll("");
        return s;
    }
 
    /**
     * 替换为手机识别的HTML，去掉样式及属性，保留回车。
     *
     * @param html
     * @return
     */
    public static String replaceMobileHtml(String html) {
        if (html == null) {
            return "";
        }
        return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>");
    }
 
    /**
     * 替换为手机识别的HTML，去掉样式及属性，保留回车。
     *
     * @param txt
     * @return
     */
    public static String toHtml(String txt) {
        if (txt == null) {
            return "";
        }
        return replace(replace(Encodes.escapeHtml(txt), "\n", "<br/>"), "\t", "&nbsp; &nbsp; ");
    }
 
    /**
     * 缩略字符串（不区分中英文字符）
     *
     * @param str    目标字符串
     * @param length 截取长度
     * @return
     */
    public static String abbr(String str, int length) {
        if (str == null) {
            return "";
        }
        try {
            StringBuilder sb = new StringBuilder();
            int currentLength = 0;
            for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
                currentLength += String.valueOf(c).getBytes("GBK").length;
                if (currentLength <= length - 3) {
                    sb.append(c);
                } else {
                    sb.append("...");
                    break;
                }
            }
            return sb.toString();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }
 
    public static String abbr2(String param, int length) {
        if (param == null) {
            return "";
        }
        StringBuffer result = new StringBuffer();
        int n = 0;
        char temp;
        boolean isCode = false; // 是不是HTML代码
        boolean isHTML = false; // 是不是HTML特殊字符,如&nbsp;
        for (int i = 0; i < param.length(); i++) {
            temp = param.charAt(i);
            if (temp == '<') {
                isCode = true;
            } else if (temp == '&') {
                isHTML = true;
            } else if (temp == '>' && isCode) {
                n = n - 1;
                isCode = false;
            } else if (temp == ';' && isHTML) {
                isHTML = false;
            }
            try {
                if (!isCode && !isHTML) {
                    n += String.valueOf(temp).getBytes("GBK").length;
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
 
            if (n <= length - 3) {
                result.append(temp);
            } else {
                result.append("...");
                break;
            }
        }
        // 取出截取字符串中的HTML标记
        String temp_result = result.toString().replaceAll("(>)[^<>]*(<?)", "$1$2");
        // 去掉不需要结素标记的HTML标记
        temp_result = temp_result.replaceAll("</?(AREA|BASE|BASEFONT|BODY|BR|COL|COLGROUP|DD|DT|FRAME|HEAD|HR|HTML|IMG|INPUT|ISINDEX|LI|LINK|META|OPTION|P|PARAM|TBODY|TD|TFOOT|TH|THEAD|TR|area|base|basefont|body|br|col|colgroup|dd|dt|frame|head|hr|html|img|input|isindex|li|link|meta|option|p|param|tbody|td|tfoot|th|thead|tr)[^<>]*/?>", "");
        // 去掉成对的HTML标记
        temp_result = temp_result.replaceAll("<([a-zA-Z]+)[^<>]*>(.*?)</\\1>", "$2");
        // 用正则表达式取出标记
        Pattern p = Pattern.compile("<([a-zA-Z]+)[^<>]*>");
        Matcher m = p.matcher(temp_result);
        List<String> endHTML = Lists.newArrayList();
        while (m.find()) {
            endHTML.add(m.group(1));
        }
        // 补全不成对的HTML标记
        for (int i = endHTML.size() - 1; i >= 0; i--) {
            result.append("</");
            result.append(endHTML.get(i));
            result.append(">");
        }
        return result.toString();
    }
 
    /**
     * 转换为Double类型
     */
    public static Double toDouble(Object val) {
        if (val == null) {
            return 0D;
        }
        try {
            return Double.valueOf(trim(val.toString()));
        } catch (Exception e) {
            return 0D;
        }
    }
 
    /**
     * 转换为Float类型
     */
    public static Float toFloat(Object val) {
        return toDouble(val).floatValue();
    }
 
    /**
     * 转换为Long类型
     */
    public static Long toLong(Object val) {
        return toDouble(val).longValue();
    }
 
    /**
     * 转换为Integer类型
     */
    public static Integer toInteger(Object val) {
        return toLong(val).intValue();
    }
 
    /**
     * 获得i18n字符串
     */
    public static String getMessage(String code, Object[] args) {
        LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Locale localLocale = localLocaleResolver.resolveLocale(request);
        return SpringContextHolder.getApplicationContext().getMessage(code, args, localLocale);
    }
 
    /**
     * 获得用户远程地址
     */
    public static String getRemoteAddr(HttpServletRequest request) {
        String remoteAddr = request.getHeader("X-Real-IP");
        if (isNotBlank(remoteAddr)) {
            remoteAddr = request.getHeader("X-Forwarded-For");
        } else if (isNotBlank(remoteAddr)) {
            remoteAddr = request.getHeader("Proxy-Client-IP");
        } else if (isNotBlank(remoteAddr)) {
            remoteAddr = request.getHeader("WL-Proxy-Client-IP");
        }
        return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
    }
 
    /**
     * 驼峰命名法工具
     *
     * @return toCamelCase("hello_world") == "helloWorld"
     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
     * toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }
 
        s = s.toLowerCase();
 
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
 
            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }
 
        return sb.toString();
    }
 
    /**
     * 驼峰命名法工具
     *
     * @return toCamelCase("hello_world") == "helloWorld"
     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
     * toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toCapitalizeCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = toCamelCase(s);
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }
 
    /**
     * 驼峰命名法工具
     *
     * @return toCamelCase("hello_world") == "helloWorld"
     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
     * toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toUnderScoreCase(String s) {
        if (s == null) {
            return null;
        }
 
        StringBuilder sb = new StringBuilder();
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
 
            boolean nextUpperCase = true;
 
            if (i < (s.length() - 1)) {
                nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
            }
 
            if ((i > 0) && Character.isUpperCase(c)) {
                if (!upperCase || !nextUpperCase) {
                    sb.append(SEPARATOR);
                }
                upperCase = true;
            } else {
                upperCase = false;
            }
 
            sb.append(Character.toLowerCase(c));
        }
 
        return sb.toString();
    }
 
    /**
     * 如果不为空，则设置值
     *
     * @param target
     * @param source
     */
    public static void setValueIfNotBlank(String target, String source) {
        if (isNotBlank(source)) {
            target = source;
        }
    }
 
    /**
     * 转换为JS获取对象值，生成三目运算返回结果
     *
     * @param objectString 对象串
     *                     例如：row.user.id
     *                     返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
     */
    public static String jsGetVal(String objectString) {
        StringBuilder result = new StringBuilder();
        StringBuilder val = new StringBuilder();
        String[] vals = split(objectString, ".");
        for (int i = 0; i < vals.length; i++) {
            val.append("." + vals[i]);
            result.append("!" + (val.substring(1)) + "?'':");
        }
        result.append(val.substring(1));
        return result.toString();
    }
 
    /**
     * 通过正则表达式获取内容
     *
     * @param regex 正则表达式
     * @param from  原字符串
     * @return
     */
    public static String[] regex(String regex, String from) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(from);
        List<String> results = new ArrayList<String>();
        while (matcher.find()) {
            for (int i = 0; i < matcher.groupCount(); i++) {
                results.add(matcher.group(i + 1));
            }
        }
        return results.toArray(new String[]{});
    }
 
}

7. BeanUtils

7.1 基本介绍

BeanUtils提供对Java反射和自省API的包装，其主要目的是利用反射机制对JavaBean的属性进行处理，简化JavaBean封装数据的操作。

好处： BeanUtils给对象封装参数的时候会进行类型自动转换。

BeanUtls工具类的实现主要包含：Apache commons包实现的BeanUtils工具类，以及spring-beans实现的BeanUtils的工具类。

7.2 JavaBean

JavaBean就是一个类，但该类需要满足以下三个条件：

类必须使用public修饰。
提供无参数的构造器。
提供getter和setter方法访问属性。

7.3 两个概念

字段：就是成员变量，字段名就是成员变量名。

属性：属性名通过setter/getter方法去掉set/get前缀，首字母小写获得。

比如：setName()--> Name--> name

一般情况下，字段名和属性名是一致的。

7.4 常用操作

对JavaBean的属性进行赋值和取值。getProperty() setProperty()
将一个JavaBean所有属性赋值给另一个JavaBean对象中。 copyProperties
将一个Map集合的数据封装到一个JavaBean对象中。 populate

public static void setProperty(Object bean, String name, Object value)：给指定对象bean的指定name属性赋值为指定值value，如果指定的属性不存在，则什么也不发生
 
public static String getProperty(Object bean, String name)：获取指定对象bean指定name属性的值，如果指定的属性不存在，则会抛出异常，当属性的类型是数组类型时，获取到的值数组中的第一个值。
    
public static void copyProperties(Object dest, Object orig)：将对象orig的属性值赋值给对象dest对象对应的属性，只有属性名名相同且类型一致的才会赋值成功。
 
public static void populate(Object bean, Map<String, ? extends Object> properties)：将一个Map集合中的数据封装到指定对象bean中对象bean的属性名和Map集合中键要相同。

7.5 应用

1. JavaBean 的属性进行赋值和取值

/*
1. Beanutils给对象设置属性的时候是依赖了setXXX方法。
2. BeanUtils获取对象的属性时依赖的是getXXX方法。
*/
public class BeanUtilDemo {
    public static void main(String[] args) throws Exception {
     
        //得倒字节码对象
        Class clazz = Class.forName("com.beanutils.User");
        
        //利用Class对象创建对象
        User s = (User) clazz.newInstance();
        
        //给对象封装数据
        BeanUtils.setProperty(s, "id", "001"); //给对象设置属性  
        //参数一： 对象，  参数二：属性名, 参数三： 属性的值。
        BeanUtils.setProperty(s, "name", "小芸");
        //参数一： 对象，  参数二：属性名, 参数三： 属性的值。
        BeanUtils.setProperty(s, "age", "18");
        
        System.out.println("id:"+ BeanUtils.getProperty(s, "id"));
        //参数一： 对象，  参数二： 获取的属性的属性名
        
        System.out.println(s);
    }
}
 
class User {
 
    private int id;
    private int age;
    private String name;
    private double sal;
 
    public User(String name) {
        this.name = name;
    }
 
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public User() {
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void sleep(int i){
        System.out.println(name+"满满的睡了"+i+"小时。。。");
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getSal() {
        return sal;
    }
 
    public void setSal(double sal) {
        this.sal = sal;
    }
}

将一个JavaBean对象的属性赋值给另一个JavaBean对象，只要两个JavaBean对象的属性名称名称相同就会赋值，不同的不赋值.

将一个Map集合的数据封装到一个JavaBean对象中

//模拟的注册
public class BeanUtilsDemo {
    
    public static void main(String[] args) throws Exception {
        
        Scanner scanner = new Scanner(System.in);
        
        //创建Map集合
        Map<String,String> map = new HashMap<String, String>();
        
        System.out.println("请输入您的身份证:");
        String id = scanner.next();
        map.put("id", id);
        
        System.out.println("请输入您的姓名:");
        String name = scanner.next();
        map.put("name", name);
        
        System.out.println("请输入您的年龄:");
        String age = scanner.next();
        map.put("age", age);
        
        
        //给对象封装数据 ， 数据全部都在Map中。
        User s = new User();
        
        //把map中的数据封装到对象上。
        BeanUtils.populate(s, map);
        
        System.out.println("用户信息是："+ s);
    }
}

2. 自定义BeanUtils工具类

//自定义的工具类
public class MyBeanUtils {
    public static  Object  populate(Class clazz , Map<String,String> param) {
        Object bean = null;
        try {
            //利用class对象创建对象
            bean = clazz.newInstance();
            BeanUtils.populate(bean, param);
        } catch (Exception e) {
            throw new RuntimeException(e);  
             //如果一个方法内部抛出了一个非运行时异常，那么必须在方法上也要声明抛出。 
            // 如果一个方法内部抛出了一个运行时异常的时候，方法上可以声明抛出也可以不声明抛出。
        }
        return bean;
    }
}

7.6 应用场景

在我们实际项目开发过程中，我们经常需要将不同的两个对象实例进行属性复制，从而基于源对象的属性信息进行后续操作，而不改变源对象的属性信息。比如：DTO数据传输对象和数据对象DO，我们需要将DO对象进行属性复制到DTO，但是对象格式又不一样，所以我们需要编写映射代码将对象中的属性值从一种类型转换成另一种类型。通常会调用其set/get方法，有些时候，但是我们很不喜欢写很多冗长的b.setF1(a.getF10))这样的代码，于是我们需要简化对象拷贝方式。为了解决这一痛点，就诞生了一些方便的BeanUtils类库，比如：常用的有apache 的 BeanUtils,spring的BeanUtils等拷贝工具类。