StringUtils工具类

最新推荐文章于 2019-09-16 11:25:53 发布
最新推荐文章于 2019-09-16 11:25:53 发布
阅读量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
08-21
String工具类 StringUtils
Java之StringUtils的常用方法
最新发布
2301_79655473的博客
05-03 571
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
StringUtils全览
俊哥
08-24 1146
org.apache.commons.lang.StringUtils中常用的方法，这里主要列举String中没有，且比较有用的方法： 1. 检查字符串是否为空： static boolean isBlank(CharSequence str) 判断字符串是否为空或null;
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安全性和空白字符的...
基于StringUtils工具类的常用方法介绍(必看篇)
08-29
基于StringUtils工具类的常用方法介绍 StringUtils工具类是Java中一个功能强大且常用的工具类，提供了许多实用的字符串操作方法。下面将对StringUtils工具类的常用方法进行介绍。 判断字符串是否为空 * isEmpty...
Java中StringUtils工具类进行String为空的判断解析
08-28
Java中StringUtils工具类进行String为空的判断解析 在Java中，StringUtils工具类提供了多种方法来判断一个字符串是否为空或非空，这些方法都是非常有用的。在本文中，我们将详细介绍StringUtils工具类中关于String...
string-utils:一些基本的字符串实用程序
06-15
字符串工具 概要 包含一些用于格式化和操作字符串的基本实用程序： StringUtils.format 的工作方式类似于 .Net 中的 String.Format。 代码示例 s1 = StringUtils.format("The {0} is against the {1}.", "chair", "wall"); // s1 == "The chair is against the wall." s2 = StringUtils.format("{0}: Getting ready to publish", new Date()); // s2 == "Mon Aug 05 2013 21:21:11 GMT-0500 (CDT): Getting ready to publish" 动机 作者需要类似于 .Net 中的 String.Format() 函数的 Javascri
StringUtils（最新）
12-04
StringUtils（最新的哦）
StringUtil类的常用方法
fengjianchao_vip的专栏
04-27 2674
StringUtils 方法的操作对象是 java.lang.String 类型的对象，是 JDK 提供的 String 类型操作方法的补充，并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出  NullPointerException ，而是做了相应处理，例如，如果输入为 null 则返回也是 null 等，具体可以查看源代码)。 除了构造器，String...
StringUtils函数全集
yyyangjun的专栏
02-09 895
StringUtils中方法的操作对象是java.lang.String类型的对象，是JDK提供的String类型操作方法的补充，并且是null安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理，例如，如果输入为null则返回也是null等，具体可以查看源代码)。 除了构造器，StringUtils中一共有130多个方法，并且都是...
StringUtils工具类常用方法汇总1(判空、转换、移除、替换、反转)
ly13108472239的博客
09-16 155
[StringUtils工具类常用方法汇总1(判空、转换、移除、替换、反转)] 原文见(https://www.cnblogs.com/guiblog/p/7787569.html)   Apache commons lang3包下的StringUtils工具类中封装了一些字符串操作的方法，非常实用，使用起来也非常方便。最近自己也经常在项目中使用到了里面的一些方法，在这里将常用的方法总结了一下，方...
StringUtils工具类的常用方法
weixin_33881050的博客
07-25 95
StringUtils 方法的操作对象是 java.lang.String 类型的对象，是对 JDK 提供的 String 类型操作方法的补充，并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出  NullPointerException ，而是做了相应处理，例如，如果输入为 null 则返回也是 null 等，具体可以查看源代码)。除了构造器，StringUtils...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值