java自定义封装StringUtils常用工具类

自定义封装StringUtils常用工具类,供大家参考,具体内容如下

package com.demo.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 字符串操作工具类
 * @author dongyangyang
 * @Date 2016/12/28 23:12
 * @Version 1.0
 *
 */
public class StringUtils {

 /**
  * 首字母变小写
  * @param str
  * @return
  */
 public static String firstCharToLowerCase(String str) {
  char firstChar = str.charAt(0);
  if (firstChar >= 'A' && firstChar <= 'Z') {
   char[] arr = str.toCharArray();
   arr[0] += ('a' - 'A');
   return new String(arr);
  }
  return str;
 }

 /**
  * 首字母变大写
  * @param str
  * @return
  */
 public static String firstCharToUpperCase(String str) {
  char firstChar = str.charAt(0);
  if (firstChar >= 'a' && firstChar <= 'z') {
   char[] arr = str.toCharArray();
   arr[0] -= ('a' - 'A');
   return new String(arr);
  }
  return str;
 }

 /**
  * 判断是否为空
  * @param str
  * @return
  */
 public static boolean isEmpty(final String str) {
  return (str == null) || (str.length() == 0);
 }

 /**
  * 判断是否不为空
  * @param str
  * @return
  */
 public static boolean isNotEmpty(final String str) {
  return !isEmpty(str);
 }

 /**
  * 判断是否空白
  * @param str
  * @return
  */
 public static boolean isBlank(final String str) {
  int strLen;
  if ((str == null) || ((strLen = str.length()) == 0))
   return true;
  for (int i = 0; i < strLen; i++) {
   if (!Character.isWhitespace(str.charAt(i))) {
    return false;
   }
  }
  return true;
 }

 /**
  * 判断是否不是空白
  * @param str
  * @return
  */
 public static boolean isNotBlank(final String str) {
  return !isBlank(str);
 }

 /**
  * 判断多个字符串全部是否为空
  * @param strings
  * @return
  */
 public static boolean isAllEmpty(String... strings) {
  if (strings == null) {
   return true;
  }
  for (String str : strings) {
   if (isNotEmpty(str)) {
    return false;
   }
  }
  return true;
 }

 /**
  * 判断多个字符串其中任意一个是否为空
  * @param strings
  * @return
  */
 public static boolean isHasEmpty(String... strings) {
  if (strings == null) {
   return true;
  }
  for (String str : strings) {
   if (isEmpty(str)) {
    return true;
   }
  }
  return false;
 }

 /**
  * checkValue为 null 或者为 "" 时返回 defaultValue
  * @param checkValue
  * @param defaultValue
  * @return
  */
 public static String isEmpty(String checkValue, String defaultValue) {
  return isEmpty(checkValue) ? defaultValue : checkValue;
 }

 /**
  * 字符串不为 null 而且不为 "" 并且等于other
  * @param str
  * @param other
  * @return
  */
 public static boolean isNotEmptyAndEquelsOther(String str, String other) {
  if (isEmpty(str)) {
   return false;
  }
  return str.equals(other);
 }

 /**
  * 字符串不为 null 而且不为 "" 并且不等于other
  * @param str
  * @param other
  * @return
  */
 public static boolean isNotEmptyAndNotEquelsOther(String str, String... other) {
  if (isEmpty(str)) {
   return false;
  }
  for (int i = 0; i < other.length; i++) {
   if (str.equals(other[i])) {
    return false;
   }
  }
  return true;
 }

 /**
  * 字符串不等于other
  * @param str
  * @param other
  * @return
  */
 public static boolean isNotEquelsOther(String str, String... other) {
  for (int i = 0; i < other.length; i++) {
   if (other[i].equals(str)) {
    return false;
   }
  }
  return true;
 }

 /**
  * 判断字符串不为空
  * @param strings
  * @return
  */
 public static boolean isNotEmpty(String... strings) {
  if (strings == null) {
   return false;
  }
  for (String str : strings) {
   if (str == null || "".equals(str.trim())) {
    return false;
   }
  }
  return true;
 }

 /**
  * 比较字符相等
  * @param value
  * @param equals
  * @return
  */
 public static boolean equals(String value, String equals) {
  if (isAllEmpty(value, equals)) {
   return true;
  }
  return value.equals(equals);
 }

 /**
  * 比较字符串不相等
  * @param value
  * @param equals
  * @return
  */
 public static boolean isNotEquals(String value, String equals) {
  return !equals(value, equals);
 }

 public static String[] split(String content, String separatorChars) {
  return splitWorker(content, separatorChars, -1, false);
 }

 public static String[] split(String str, String separatorChars, int max) {
  return splitWorker(str, separatorChars, max, false);
 }

 public static final String[] EMPTY_STRING_ARRAY = new String[0];

 private static String[] splitWorker(String str, String separatorChars, int max, boolean preserveAllTokens) {
  if (str == null) {
   return null;
  }
  int len = str.length();
  if (len == 0) {
   return EMPTY_STRING_ARRAY;
  }
  List<String> list = new ArrayList<String>();
  int sizePlus1 = 1;
  int i = 0, start = 0;
  boolean match = false;
  boolean lastMatch = false;
  if (separatorChars == null) {
   while (i < len) {
    if (Character.isWhitespace(str.charAt(i))) {
     if (match || preserveAllTokens) {
      lastMatch = true;
      if (sizePlus1++ == max) {
       i = len;
       lastMatch = false;
      }
      list.add(str.substring(start, i));
      match = false;
     }
     start = ++i;
     continue;
    }
    lastMatch = false;
    match = true;
    i++;
   }
  } else if (separatorChars.length() == 1) {
   char sep = separatorChars.charAt(0);
   while (i < len) {
    if (str.charAt(i) == sep) {
     if (match || preserveAllTokens) {
      lastMatch = true;
      if (sizePlus1++ == max) {
       i = len;
       lastMatch = false;
      }
      list.add(str.substring(start, i));
      match = false;
     }
     start = ++i;
     continue;
    }
    lastMatch = false;
    match = true;
    i++;
   }
  } else {
   while (i < len) {
    if (separatorChars.indexOf(str.charAt(i)) >= 0) {
     if (match || preserveAllTokens) {
      lastMatch = true;
      if (sizePlus1++ == max) {
       i = len;
       lastMatch = false;
      }
      list.add(str.substring(start, i));
      match = false;
     }
     start = ++i;
     continue;
    }
    lastMatch = false;
    match = true;
    i++;
   }
  }
  if (match || (preserveAllTokens && lastMatch)) {
   list.add(str.substring(start, i));
  }
  return (String[]) list.toArray(EMPTY_STRING_ARRAY);
 }

 /**
  * 消除转义字符
  * @param str
  * @return
  */
 public static String escapeXML(String str) {
  if (str == null)
   return "";
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < str.length(); ++i) {
   char c = str.charAt(i);
   switch (c) {
   case '\u00FF':
   case '\u0024':
    break;
   case '&':
    sb.append("&");
    break;
   case '<':
    sb.append("<");
    break;
   case '>':
    sb.append(">");
    break;
   case '\"':
    sb.append(""");
    break;
   case '\'':
    sb.append("'");
    break;
   default:
    if (c >= '\u0000' && c <= '\u001F')
     break;
    if (c >= '\uE000' && c <= '\uF8FF')
     break;
    if (c >= '\uFFF0' && c <= '\uFFFF')
     break;
    sb.append(c);
    break;
   }
  }
  return sb.toString();
 }

 /**
  * 将字符串中特定模式的字符转换成map中对应的值
  *
  * @param s
  *   需要转换的字符串
  * @param map
  *   转换所需的键值对集合
  * @return 转换后的字符串
  */
 public static String replace(String s, Map<String, Object> map) {
  StringBuilder ret = new StringBuilder((int) (s.length() * 1.5));
  int cursor = 0;
  for (int start, end; (start = s.indexOf("${", cursor)) != -1 && (end = s.indexOf("}", start)) != -1;) {
   ret.append(s.substring(cursor, start)).append(map.get(s.substring(start + 2, end)));
   cursor = end + 1;
  }
  ret.append(s.substring(cursor, s.length()));
  return ret.toString();
 }

 public static String replace(String s, Object... objs) {
  if (objs == null || objs.length == 0)
   return s;
  if (s.indexOf("{}") == -1)
   return s;
  StringBuilder ret = new StringBuilder((int) (s.length() * 1.5));
  int cursor = 0;
  int index = 0;
  for (int start; (start = s.indexOf("{}", cursor)) != -1;) {
   ret.append(s.substring(cursor, start));
   if (index < objs.length)
    ret.append(objs[index]);
   else
    ret.append("{}");
   cursor = start + 2;
   index++;
  }
  ret.append(s.substring(cursor, s.length()));
  return ret.toString();
 }

 /**
  * 字符串格式化工具,参数必须以{0}之类的样式标示出来.大括号中的数字从0开始。
  *
  * @param source
  *   源字符串
  * @param params
  *   需要替换的参数列表,写入时会调用每个参数的toString().
  * @return 替换完成的字符串。如果原始字符串为空或者参数为空那么将直接返回原始字符串。
  */
 public static String replaceArgs(String source, Object... params) {
  if (params == null || params.length == 0 || source == null || source.isEmpty()) {
   return source;
  }
  StringBuilder buff = new StringBuilder(source);
  StringBuilder temp = new StringBuilder();
  int startIndex = 0;
  int endIndex = 0;
  String param = null;
  for (int count = 0; count < params.length; count++) {
   if (params[count] == null) {
    param = null;
   } else {
    param = params[count].toString();
   }

   temp.delete(0, temp.length());
   temp.append("{");
   temp.append(count);
   temp.append("}");
   while (true) {
    startIndex = buff.indexOf(temp.toString(), endIndex);
    if (startIndex == -1) {
     break;
    }
    endIndex = startIndex + temp.length();

    buff.replace(startIndex, endIndex, param == null ? "" : param);
   }
   startIndex = 0;
   endIndex = 0;
  }
  return buff.toString();
 }

 public static String substringBefore(final String s, final String separator) {
  if (isEmpty(s) || separator == null) {
   return s;
  }
  if (separator.isEmpty()) {
   return "";
  }
  final int pos = s.indexOf(separator);
  if (pos < 0) {
   return s;
  }
  return s.substring(0, pos);
 }

 public static String substringBetween(final String str, final String open, final String close) {
  if (str == null || open == null || close == null) {
   return null;
  }
  final int start = str.indexOf(open);
  if (start != -1) {
   final int end = str.indexOf(close, start + open.length());
   if (end != -1) {
    return str.substring(start + open.length(), end);
   }
  }
  return null;
 }

 public static String substringAfter(final String str, final String separator) {
  if (isEmpty(str)) {
   return str;
  }
  if (separator == null) {
   return "";
  }
  final int pos = str.indexOf(separator);
  if (pos == -1) {
   return "";
  }
  return str.substring(pos + separator.length());
 }

 /**
 * 转换为字节数组
 * @param str
 * @return
 */
 public static String toString(byte[] bytes){
  try {
   return new String(bytes, "utf-8");
  } catch (UnsupportedEncodingException e) {
   return null;
  }
 }

 /**
 * 转换为字节数组
 * @param str
 * @return
 */
 public static byte[] getBytes(String str){
  if (str != null){
  try {
   return str.getBytes("utf-8");
   } catch (UnsupportedEncodingException e) {
   return null;
   }
  }else{
  return null;
  }
 }
 public static void main(String[] a){
  String escapeXML = escapeXML("\\");
  System.out.println(escapeXML);
 }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • Java中StringUtils工具类进行String为空的判断解析
  • Java中StringUtils工具类的一些用法实例
(0)

相关推荐

  • Java中StringUtils工具类进行String为空的判断解析

    判断某字符串是否为空,为空的标准是str==null或str.length()==0 1.下面是StringUtils判断是否为空的示例: StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false //注意在 StringUtils 中空格作非空处理 StringUtils.isEmpty(" ") = fals

  • Java中StringUtils工具类的一些用法实例

    StringUtils 方法的操作对象是 java.lang.String 类型的对象,是 JDK 提供的 String 类型操作方法的补充,并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出 NullPointerException ,而是做了相应处理,例如,如果输入为 null 则返回也是 null 等,具体可以查看源代码). 除了构造器,StringUtils 中一共有130多个方法,并且都是 static 的,所以我们可以这样调用 StringUtils.x

  • java自定义封装StringUtils常用工具类

    自定义封装StringUtils常用工具类,供大家参考,具体内容如下 package com.demo.utils; import java.util.ArrayList; import java.util.List; import java.util.Map; /** * 字符串操作工具类 * @author dongyangyang * @Date 2016/12/28 23:12 * @Version 1.0 * */ public class StringUtils { /** * 首字

  • java处理字节的常用工具类

    处理字节的常用工具类方法,供大家参考,具体内容如下 package com.demo.utils; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.nio.charset.Char

  • 详解Java常用工具类—泛型

    一.泛型概述 1.背景 在Java中增加泛型之前,泛型程序设计使用继承来实现的. 坏处: 需要进行强制类型转换 可向集合中添加任意类型的对象,存在风险 2.泛型的使用 List<String> list=new ArrayList<String>(); 3.多态与泛型 class Animal{} class Cat extends Animal{} List<Animal> list=new ArrayList<Cat>(); //这是不允许的,变量声明的

  • Java常用工具类汇总 附示例代码

    一.FileUtils private static void fileUtilsTest() { try { //读取文件内容 String readFileToString = FileUtils.readFileToString(new File("D:\\guor\\data\\test20211022000000.txt")); System.out.println(readFileToString); //删除文件夹 FileUtils.deleteDirectory(ne

  • java常用工具类 数字工具类

    本文实例为大家分享了java常用工具类,数字工具类的具体代码,供大家参考,具体内容如下 package com.jarvis.base.util; import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.Random; public class NumericHelper { /** * 描述:通过一个整数i获取你所要的哪几个(从0开始

  • java常用工具类 XML工具类、数据验证工具类

    本文实例为大家分享了java常用工具类的具体代码,供大家参考,具体内容如下 package com.jarvis.base.util; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.StringReader; import java.io.StringWriter; import java.net.URL; import java.util.Properties

  • java常用工具类 IP、File文件工具类

    本文实例为大家分享了java常用工具类的具体实现代码,供大家参考,具体内容如下 IP工具类 package com.jarvis.base.util; import java.io.IOException; import java.io.InputStreamReader; import java.io.LineNumberReader; /** * * * @Title: IpMacUtil.java * @Package com.jarvis.base.util * @Description

  • Java常用工具类 Random随机数、MD5加密工具类

    本文实例为大家分享了java常用工具类的具体代码,供大家参考,具体内容如下 Random随机数工具类 package com.jarvis.base.util; import java.util.Random; /** * * * @Title: RandomHelper.java * @Package com.jarvis.base.util * @Description: 随机数工具类 * @version V1.0 */ public class RandomHelper { /** *

  • Java常用工具类 UUID、Map工具类

    本文实例为大家分享了Java常用工具类 的具体代码,供大家参考,具体内容如下 UUID工具类 package com.jarvis.base.util; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; /** * A class that represents an immutable universally

  • java常用工具类 Reflect反射工具类、String字符串工具类

    本文实例为大家分享了java常用工具类的具体代码,供大家参考,具体内容如下 Reflect反射工具类 package com.jarvis.base.util; /** * * * @Title: ReflectHelper.java * @Package com.jarvis.base.util * @Description: 反射工具类 * @version V1.0 */ public class ReflectHelper { /** * 提指定的类载入以系统中 * * @param n

随机推荐