StringUtils工具类

最新推荐文章于 2024-05-03 03:33:15 发布
最新推荐文章于 2024-05-03 03:33:15 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： J2SE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangshuai198807/article/details/82499870
版权

package com.xiangshui;


import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * 字符串处理类
 * @author liuqixiang
 * @version 1.0 2018-09-07
 */
public class StringUtils {
     public static final String[] EMPTY_STRING_ARRAY = new String[0];
    /**
     * 判断字符串是否为全数字，如果为全数字返回true
     * @author liuqixiang
     * @param 参数1：待判断字符串
     * @return boolean
     * @version 1.0 2018-09-07
     **/
    public static boolean isAllNumber(String str){
        if(str!=""){
            for (int i=0; i<str.length(); i++) { 
                char c = str.charAt(i); 
                if (c<'0' || '9'<c) { 
                    return false; 
                } 
            }
            return true;
        }else{
            return false;
        }
    }
    /**
     * 判断字符串是否为全中文
     * @author liuqixiang
     * @param 参数1：待判断字符串
     * @return boolean
     * @version 1.0 2018-09-07
     */
    public static boolean isAllChinese(String str){
        if(str!=""){
            char[] c=str.toCharArray();
            for (int i = 0; i < c.length; i++) {
                Character.UnicodeBlock ub = Character.UnicodeBlock.of(c[i]);
                 if (ub != Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS 
                            && ub != Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS 
                            && ub != Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A 
                            && ub != Character.UnicodeBlock.GENERAL_PUNCTUATION 
                            && ub != Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION 
                            && ub != Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) { 
                        return false; 
                    } 
            }
            return true;
        }else{
            return false;
        }
    }
    /**
     * 判断第一个字符窜中包含第二个字符串的数量
     * @author liuqixiang
     * @param 参数1：待判断字符串；参数2：包含的字符串
     * @return int
     * @version 1.0 2018-09-07
     */
    public static int hasStrCount(String str1, String str2) {
        int sum = 0;
        if(StringUtils.isNull(str2)){
            return 0;
        }
        while (str1.indexOf(str2) != -1) {
            sum++;
            str1 = str1.substring(str1.indexOf(str2) + str2.length());
        }
        return sum;
    }
    /**
     * 将一个String[]中的某个字符串移到数组的末尾
     * @author liuqixiang
     * @param 参数1：待操作字符串数组；参数2：待移动的字符串
     * @return String[]
     * @version 1.0 2018-09-07
     */
    public static String[] moveToEnd(String[] sources, String str) {
        int head = 0;
        int end = sources.length - 1;
        while (head != end) {
            while (head != end) {
                if (sources[head].equals(str))
                    break;
                head++;
            }
            while (head != end) {
                if (!sources[end].equals(str))
                    break;
                end--;
            }
            if (head != end) {
                String temp = sources[head];
                sources[head] = sources[end];
                sources[end] = temp;
            }
        }
        return sources;
    }
    /**
     * 删除String[]中的某个字符串
     * @author liuqixiang
     * @param 参数1：待操作字符串数组；参数2：待删除的字符串
     * @return String[]
     * @version 1.0 2018-09-07
     */
    public static String[] delstr(String[] sources, String str) {
        sources = moveToEnd(sources, str);
        int size = 0;
        for (; size < sources.length; size++) {
            if (sources[size].equals(str))
                break;
        }
        String[] temp = new String[size];
        for (int i = 0; i < size; i++)
            temp[i] = sources[i];
        return temp;
    }
    /**
     * 将String[]转化为int[]
     * @author liuqixiang
     * @param 参数1：待操作的字符串数组
     * @return int[]
     * @version 1.0 2018-09-07
     */
    public static int[] pareInts(String[] sources) {
        int[] temp = new int[sources.length];
        for (int i = 0; i < sources.length; i++) {
            temp[i] = Integer.parseInt(sources[i]);
        }
        return temp;
    }
    /**
     * 将int[]转化为String[]
     * @author liuqixiang
     * @param 参数1：待操作的字符串数组
     * @return int[]
     * @version 1.0 2018-09-07
     */
    public static String[] pareStrings(int[] sources) {
        String[] temp = new String[sources.length];
        for (int i = 0; i < sources.length; i++) {
            temp[i] = sources[i]+"";
        }
        return temp;
    }
    /**
     * 获取第二个字符串在第一个字符串中出现位置的索引值
     * @param str1
     * @param str2
     * @return List
     */
    public static List indexOf(String str1,String str2){
        int len=str1.length();
        int dd=0;
        List list=new ArrayList();
        int count=hasStrCount(str1, str2);
        for (int i = 0; i <count; i++) {
            int index=str1.indexOf(str2)+dd;
            list.add(index);
            str1=str1.substring(str1.indexOf(str2)+1);
            dd=len-str1.length();
        }
        return list;
    }
    /**
     * 截取字符窜到指定字符窜，例如截取"qwertyuio"到'e'字符，结果为qwe
     * @author liuqixiang
     * @param 参数1：待截取的字符串；参数2：截取位置;参数3：位置序号;参数4:是否包含截取位置
     * @return String
     * @version 1.0 2018-09-07
     */
    public static String subString(String str1, String str2,int sqe,int type) {
        String restr="";
        List list=indexOf(str1, str2);
        int xhsize=0;
        if(list.size()<sqe||sqe<1){
            return "";
        }else{
            xhsize=sqe;
        }
        restr=str1.substring(0, (Integer)list.get(xhsize-1));
        if(type==1){
            restr+=str2;
        }
        return restr;
    }
    /**
     *去除字符窜多余的空格
     * @author liuqixiang
     * @param 参数1：待处理的字符串；参数2：处理类型，1表示去除左边的空格，2表示
     * 去除右边的空格，3表示去除两边的空格，4表示去除所有空格
     * @return String
     * @version 1.0 2018-09-07
     */
    public static String delNull(String str,String type) {
        if(type.equals("1")){
            return delLeftNull(str);
        }else if(type.equals("2")){
            return delRightNull(str);
        }else if(type.equals("3")){
            return str.trim();
        }else{
            return str.replaceAll(" ", "");
        }
    }
    /**
     *将int型转换为指定长度的字符串，不够位数前面添零
     * @author liuqixiang
     * @param 参数1：待处理的数字；参数2：位数
     * @return String
     * @version 1.0 2018-09-07
     */
    public static String toString(int value, int median) {
        String result = "";
        String valueString = String.valueOf(value);
        int valueMedian = valueString.length();
        if(valueMedian < median) {
            for(int i = 0, c = median - valueMedian; i < c; i++) {
                result = result + "0";
            }
            result = result + valueString;
        } else {
            result = valueString;
        }
        return result;
    }
    /**
     *判断字符窜数组中是否包含指定字符串
     * @author liuqixiang
     * @param 参数1：待操作的字符串数组；参数2：包含的字符串；参数3：是否大小写敏感
     * @return boolean
     * @version 1.0 2018-09-07
     */
    public static boolean isContain(String[] strings, String string,
            boolean caseSensitive) {
        for (int i = 0; i < strings.length; i++) {
            if (caseSensitive == true) {
                if (strings[i].equals(string)) {
                    return true;
                }
            }
            else {
                if (strings[i].equalsIgnoreCase(string)) {
                    return true;
                }
            }
        }
        return false;
    }
    /**
     *将字符串数组使用指定的分隔符合并成一个字符串。
     * @author liuqixiang
     * @param 参数1：待操作的字符串数组；参数2：表示分隔符，为null的时候使用""作为分隔符（即没有分隔符）
     * @return String
     * @version 1.0 2018-09-07
     */
    public static String toString(String[] array, String delim) {
        int length = array.length - 1;
        if (delim == null) {
          delim = "";
        }
        StringBuffer result = new StringBuffer(length * 8);
        for (int i = 0; i < length; i++) {
          result.append(array[i]);
          result.append(delim);
        }
        result.append(array[length]);
        return result.toString();
      }
    /**
     *替换String中所有的指定字符串为指定的新字符窜
     * @author liuqixiang
     * @param 参数1：待操作的字符串；参数2：需替换的字符窜；参数3：用作替换的新字符窜
     * @return String
     * @version 1.0 2018-09-07
     */
     public static String replaceAll(String str0,String str1,String str2)
       {
           if(str0==null || str0.equals("")) return str0;
             if(str1==null || str1.equals("")) str1=" ";
           String s="";
           try
           {
               while(str0.indexOf(str1)!=-1)
               {
                   s+=str0.substring(0,str0.indexOf(str1))+str2;
                   str2=str2.trim();
                   str0=str0.substring(str0.indexOf(str1)+str1.length());
               }
               s+=str0;
           }catch(Exception e)
           {
               e.printStackTrace();
           }
           if(s.equals(""))
               s=str0;
           return s;
       }
     /**
      * 验证字符窜是否为ip格式
      * @author liuqixiang
      * @param 参数1：待验证的字符串；
      * @return boolean
      * @version 1.0 2018-09-07
     */
     public static boolean isIp(String strIp){
            boolean bln=true;
            String[] str=strIp.split("\\.");
            String s=toString(str, "");
            if(isAllNumber(s)){
            try {
                StringTokenizer st = new StringTokenizer(strIp,".");
                int intCount=st.countTokens();
                while (st.hasMoreTokens()) {
                    String strTemp=st.nextToken();

                    try {
                        int intTemp = Integer.parseInt(strTemp);
                        if (intTemp > 255 || intTemp < 0) {
                            bln = false;
                        }
                    }
                    catch (NumberFormatException ex) {
                        ex.printStackTrace();
                        bln = false;
                    }
                }
                if(intCount!=4) bln = false;
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
            return bln;
            }else{
                return false;
            }
        }
     /**
         *验证字符窜是否为URL格式
         * @author liuqixiang
         * @param 参数1：待验证的字符串；
         * @return boolean
         * @version 1.0 2018-09-07
         */
     public static boolean isUrl(String strUrl){
            try {
                URL test = new URL(strUrl);
                return true;
            } catch (MalformedURLException mue) {
                return false;
            }
        }
     /**
         *去除字符窜左边多余的空格
         * @author liuqixiang
         * @param String
         * @return String
         * @version 1.0 2018-09-07
         */
        public static String delLeftNull(String str) {
            char[] c = str.toCharArray();
            for (int i = 0; i < c.length; i++) {
                if (c[i] != ' ') {
                    str = String.valueOf(c, i, c.length - i);
                    break;
                }
            }
            return str;
        }
        /**
         *去除字符窜右边多余的空格
         * @author liuqixiang
         * @param String
         * @return String
         * @version 1.0 2018-09-07
         */
        public static String delRightNull(String value) {
            String result = value;
            if(result == null) return result;
            char ch[] = result.toCharArray();
            int endIndex = -1;
            for(int i=ch.length-1; i > -1; i--) {
              if(Character.isWhitespace(ch[i])) {
                endIndex = i;
              }
              else {
                break;
              }
            }
            if(endIndex != -1) {
              result = result.substring(0, endIndex);
            }
            return result;
          }
        /**
         * 字符串大小写转换
         * @param str
         * @param type
         * @return
         */
        public static String shift(String str,int type){
            if(type==1){
                str=toBigString(str);
            }else if(type==2){
                str=toSmallString(str);
            }else{
                str=shiftBigOrSmall(str);
            }
            return str;
        }
        /**
         * 字母大小写互转
         * @param str
         * @return
         */
        public static String shiftBigOrSmall(String str) {
            int size = str.length();
            char[] chs = str.toCharArray();
            for (int i = 0; i < size; i++) {
                if (chs[i] <= 'Z' && chs[i] >= 'A') {
                    chs[i] = (char) (chs[i] + 32);
                } else if (chs[i] <= 'z' && chs[i] >= 'a') {
                    chs[i] = (char) (chs[i] - 32);
                }
            }
            return new String(chs);
        }
        /**
         * 将字符转换为大写字符串
         * @param str
         * @return
         */
        public static String toBigString(String str){
            int size = str.length();
            char[] chs = str.toCharArray();
            for (int i = 0; i < size; i++) {
                if (chs[i] <= 'z' && chs[i] >= 'a') {
                    chs[i] = (char) (chs[i] - 32);
                }
            }
            return new String(chs);
        }
        /**
         * 将字符转换为小写字符串
         * @param str
         * @return
         */
        public static String toSmallString(String str){
            int size = str.length();
            char[] chs = str.toCharArray();
            for (int i = 0; i < size; i++) {
                if (chs[i] <= 'Z' && chs[i] >= 'A') {
                    chs[i] = (char) (chs[i] + 32);
                }
            }
            return new String(chs);
        }
        /**
         * 判断字符串是否为空 为空返回true
         * @param str
         * @return
         */
        public static boolean isNull(String str){
            if(str==null||"null".equals(str)||"NULL".equals(str)){
                return true;
            }else{
                str=delNull(str, "4");
                if("".equals(str)){
                    return true;
                }else{
                    return false;
                }
            }
        }
        public static String toNotNullStr(Object str){
                return str==null?"":str.toString();
        }
        
        public static String strToNull(String str){
            return "".equals(str)?null:str;
      }
        /**
         * 获取字符串的字节长度
         * @param str
         * @return
         */
        public static int getByteLength(String str){
            if(!isNull(str)){
                String str2=str.replaceAll("[^\\x00-\\xff]","**");
                int len=str2.length();
                return len;
            }else{
                return 0;
            }
        }
        
        /**
         * 对字符串数组判断是否越界
         * @param str
         * @return
         */
        public static String getArrayValue (String[] StrArr,int index){
               if (StrArr==null) return "";
               int len = StrArr.length;
               if(index<len)return StrArr[index];
                return "";
        }
        
        /**
         * 数字转换为字符串，当为0时返回空
         * @param str
         * @return
         */
        public static String tranNumToString (int num){
            String returnStr ="";
            returnStr=toNotNullStr(num);
            return ("0".equals(returnStr))?returnStr="":returnStr;
        }
        public static String toLong(String str, int len){
            if(isNull(str)){
                str="";
            }
            int ln=str.getBytes().length;
            int bl=(len-ln)/2;
            for (int i = 0; i <bl; i++) {
                str=" "+str;
            }
            return str;
        }
        /**
         * 制定长度插入间隔符
         * @param str1 原字符串
         * @param str2 间隔符
         * @param n 指定长度
         * @return
         */
        public static String insertStr(String str1,String str2,int n){
            String restr="";
            int len=str1.length();
            int foe=len/n;
            for (int i = 0; i <foe; i++) {
                int end=i*n+n;
                restr+=str1.substring(i*n, end)+str2;
            }
            restr+=str1.substring(foe*n, len);
            return restr;
        }
        /**
         * 往右补空格到指定长度
         * @param str
         * @param n
         * @return
         */
        public static String bkg_right(String str,int n){
            String restr="";
            int nulllen=0;
            if(!isNull(str)){
                restr=str;
                int len=str.length();
                nulllen=n-len;
            }else{
                nulllen=n;
            }
            for (int i = 0; i < nulllen; i++) {
                restr+=" ";
            }
            return restr;
        }
        /**
         * 转化案号显示方式
         * @param ah
         * @return
         */
        public static String[] doAh(String ah){
            String[] str=new String[7];
            if(!isNull(ah)){
                int zf1=ah.indexOf("（");
                int zf2=ah.indexOf("）");
                if(zf1==-1){
                    zf1=ah.indexOf("(");
                }
                if(zf2==-1){
                    zf2=ah.indexOf(")");
                }
                int zf3=ah.indexOf("法");
                int zf4=ah.indexOf("字");
                int zf5=ah.indexOf("第");
                int zf6=ah.indexOf("号");
                if(zf1!=-1&&zf2!=-1&&zf3!=-1&&zf4!=-1&&zf5!=-1&&zf6!=-1){
                    if(zf6>zf5&&zf5>zf4&&zf4>zf3&&zf3>zf2&&zf2>zf1){
                        str[0]=ah.substring(0, zf1+1);
                        str[1]=ah.substring(zf1+1, zf2);
                        str[2]=ah.substring(zf2, zf3+1);
                        str[3]=ah.substring(zf3+1, zf4);
                        str[4]=ah.substring(zf4, zf5+1);
                        str[5]=ah.substring(zf5+1, zf6);
                        str[6]=ah.substring(zf6, zf6+1);
                    }
                }
            }
            if(str[0]==null){
                str[0]=ah;
            }
            return str;
        }
        /**
         * 补零
         * @param str
         * @return
         */
        public static String bl(String str,int length){
            int len=str.length();
            if(len<length){
                for (int i = 0; i <length-len; i++) {
                    str="0"+str;
                }
            }
            return str;
        }
        /**
         * @param list eg:1,2,3,5,6,7,10,11(正数)
         * @return 1-3、5-7、10-11
         * */
        public static String getSerialNumberString(List list){
            String result = "";
            if(list==null || list.size()==0){
                return "";
            }
            int lastNum=-1;
            int currentNum;
            int step = 0;
            for(int i=0;i<list.size();i++){
                String str = list.get(i).toString();                
                currentNum = Integer.parseInt(str);
                if(i==0){
                    result = str;                    
                }else {
                    if(!((lastNum+1)==currentNum)){
                        if(step==0){
                            result += "、" + currentNum;
                        }else{
                            result += "-" + lastNum + "、" + currentNum;                    
                        }
                        step = 0;
                        //result += "-" + lastNum + "、" + currentNum;
                    }else{
//                        if(i==list.size()-1){
//                            result += "-"+currentNum;
//                        }
                        step++;                    
                        if(i==list.size()-1&&lastNum!=-1){
                            result += "-"+currentNum;
                        }
                    }
                }
                lastNum = currentNum;
            }
            
            
            return result;
        }
        
     public static void main(String[] args) {
        /* String str="2011/11/30";
         System.out.println(str.replace("/", "-"));*/
         List list = new ArrayList(){};
         list.add(1);
         list.add(2);
         list.add(3);
         list.add(5);
         list.add(6);
         list.add(10);
         list.add(11);
         list.add(12);
         list.add(15);
        // StringUtils su = new StringUtils();
        // String result = su.getSerialNumberString(list);
        // System.out.println(result);
         
    }
}

香帅xs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
StringUtils 工具
weixin_44458365的博客
08-09 511
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> </dependency> 实验室：
StringUtils常用工具类
shawn的博客
04-10 1028
平常我们写代码是经常用到工具类，每次都要查，很麻烦，所以我搜集资料在这里总结一下，如果有不正确或不合理的地方，还请你评论执教，谢谢 \(0_0)/ 首先，我就先说说Java中最常见的判空处理在校验一个String为空时通常有以下几种情况： a.是否为null b.是否为"" c.是否为字符串" " （中间有空格） isBlank()方法可以一次性校验上面三种情况，返回true判空处理的Str...
StringUtils 字符串常用工具
03-17
NULL 博文链接：https://xylonwang.iteye.com/blog/467843
StringUtils检查字符串是否空或是null
热门推荐
u012269267的专栏
06-01 2万+
package com.test;import org.apache.commons.lang.StringUtils;public class Test {public static void main(String[] args) {//检查字符串是否为空或是null System.out.println("isEmpty:"+StringUtils.isEmpty(null));//判断字符
Java之StringUtils的常用方法
最新发布
2301_79655473的博客
05-03 574
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
java判空
Ssucre的博客
10-11 506
常用判空工具1 字符串判空（`org.apache.commons.lang3`）2 对象判空（`package java.util`）3 集合判空（`org.springframework.util`） 1 字符串判空（org.apache.commons.lang3） StringUtils.isEmpty() 判断null 和 空字符串，不能判断空格 StringUtils.isEmpty(null) = true StringUtils.isEmpty("")
StringUtils源码解读
weixin_48146191的博客
07-10 155
当我们使用 "object == null" 时，实际上是在判断对象引用所指向的内存地址是否为 null。如果对象引用的内存地址为 null，那么表示该对象为空；如果对象引用的内存地址不为 null，那么表示该对象不为空。isnull就是判断该对象是否指向空。isempty是结合了isnull，他先判断isnull是否为空，再判断集合里面是否为空，只要有一个为真的情况下就返回TRUE，举个例子。进入源码看到了我们进入了string终极类，看看它是怎么写的。测试当传入字符串为空的时候，返回什么。
java封装一个实用的StringUtil类
机智W_en的博客
06-06 731
在项目中经常会对String进行一些操作，除了一些开源框架中的StringUtils，我把在项目中经常要用的方法封装成了一个StringUtil类，可供大家学习借鉴。
StringUtils 工具类
12-11
包含对象转list、获取两个日期之间的所有日期、获取两个日期之间的所有日期（小时）、获取两个日期之间的所有日期（分钟）、根据文件路径创建所有文件夹、删除ArrayList中重复元素，保持顺序、判断字符串是否包含...
java自定义封装StringUtils常用工具类
08-27
Java 自定义封装 StringUtils 工具类 Java 中的字符串处理是非常重要的一部分，而 StringUtils 工具类则是 Java 中最常用的字符串处理工具类之一。今天，我们将详细介绍如何自定义封装一个 StringUtils 工具类，并...
Java中StringUtils工具类的一些用法实例
09-03
在Java编程中，Apache Commons Lang库提供了一个名为`StringUtils`的工具类，它扩展了Java标准库中的`String`类，提供了许多实用的字符串处理方法。这些方法在处理字符串时非常方便，尤其对于null安全性和空白字符的...
Java中StringUtils工具类进行String为空的判断解析
08-28
主要介绍了Java中StringUtils工具类进行String为空的判断解析，具有一定借鉴价值,需要的朋友可以参考下
StringUtil.java
03-25
StringUtil.java 2100+行代码 内容丰富
基于StringUtils工具类的常用方法介绍(必看篇)
08-29
基于StringUtils工具类的常用方法介绍 StringUtils工具类是Java中一个功能强大且常用的工具类，提供了许多实用的字符串操作方法。下面将对StringUtils工具类的常用方法进行介绍。 判断字符串是否为空 * isEmpty...
探索StringUtils3之StringUtils.isEmpty()和StringUtils.isBlank()的区别
★【World Of Moshow 郑锴】★
11-05 4240
StringUtils中有很多方法,常用的也许你除了isEmpty/isNotEmpty/isNotBlank/isBlank外,并不知道还有`isAnyEmpty/isNoneEmpty/isAnyBlank/isNoneBlank`的存在, come on ,让我们一起来探索`org.apache.commons.lang3.StringUtils;`这个工具类. #isEmpty系列#isBank系列#其他方法
StringUtil小方法：判断字符串是否为null或者““
qq_47637405的博客
07-27 420
可以单独在util包里进行调用。
StringUtils 工具类中判断一个string类型的值是否为空的几种方法
qq_32723447的博客
06-01 2066
StringUtils.isBlank(str)//判断某个字符串是否为空的标准是str==null或者str.length==0或者是str==""; StringUtils.isEmpty(str);//判断某个字符串是否为空的标准是str==null或者str.length==0 把一个字符串按逗号进行分割的方法： String ridStr=""; 循环得到一个list集合中的
Java中如何判断字符串、集合、对象是否为空
先知三日
10-20 288
Java标准库提供了isEmpty()方法来判断一个字符串是否为空。此外，Apache Commons Lang库的StringUtils类提供了isEmpty()和isBlank()方法，前者用于判断字符串是否为空或null，后者还会检查字符串是否只包含空白字符。Java标准库的Collection接口提供了isEmpty()方法来判断一个集合是否为空。此外，Apache Commons Lang库的CollectionUtils类提供了isEmpty()方法，可以同时检查集合是否为null或空。
Java中判断字符串为空(StringUtils工具类)
zhuoya_的博客
03-02 3271
@Test public void testStr(){ /*----------------【Start】isEmpty方法检查-----------------*/ System.out.println(StringUtils.isEmpty(""));//true System.out.println(StringUtils....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值