JAVA 字符串处理工具栏

JAVA 字符串处理工具栏（多年积累）

/**
 * 文件名: StringUtil.java
 * 包路径: com.github.niupengyu.core.util;
 * 创建描述
 *
 * @createPerson：
 * @createDate：Jan 8, 2013 12:08:20 PM
 * 内容描述：
 * 修改描述
 * @updatePerson：
 * @updateDate：Jan 8, 2013 12:08:20 PM
 * 修改内容:
 * 版本: V1.0
 */
package com.github.niupengyu.core.util;


import com.alibaba.fastjson.JSONObject;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 类:  <code> StringUtil </code>
 * 功能描述: String字符串操作工具栏
 * 创建人:
 * 创建日期: Apr 1, 2013 7:21:47 PM
 * 开发环境: JDK7.0
 */
public class StringUtil implements java.io.Serializable {
    private static final long serialVersionUID = 1L;

    private static final String reg = "\\[.*\\d+.*\\]";

    /**
     * 功能描述:传入一个对象判断是否为空
     * @param obj
     * @return boolean为空返回true
     */
    public static boolean isNull(Object obj) {
        return obj==null;
    }

    /**
     * 判断对象 是否不为空
     * @param obj
     * @return
     */
    public static boolean notNull(Object obj) {
        return obj!=null;
    }

    /**
     * 判断字符串是否为空
     * @param obj
     * @return
     */
    public static boolean isNull(String obj) {

        return obj == null || obj.isEmpty();
    }

    /**
     * 判断字符串是否不为空
     * @param obj
     * @return
     */
    public static boolean notNull(String obj) {
        return obj != null && !obj.isEmpty();
    }

    /**
     * 判断set 集合是否为空
     */
    public static boolean setIsNull(Set<?> mains) {
        return mains==null||mains.isEmpty();
    }

    /**
     * 判断map集合是否为空
     * @param mapSet
     * @return
     */
    public static boolean mapIsNull(Map<?, ?> mapSet) {

        return mapSet==null||mapSet.isEmpty();
    }

    /**
     * 从map 中获取一个值
     * @param mapSet map集合
     * @param key map的键
     * @param <T> 泛型
     * @return
     */
    public static <T> T mapValue(Map<?, ?> mapSet,String key){
        if(mapSet!=null&& mapSet.containsKey(key)){
            return (T) mapSet.get(key);
        }
        return null;
    }

    /**
     * 从map中获取一个 字符串值
     * @param mapSet map集合
     * @param key map键
     * @return
     */
    public static String mapValueString(Map<?, ?> mapSet,String key){
        if(mapSet!=null&& mapSet.containsKey(key)){
            return StringUtil.valueOf(mapSet.get(key));
        }
        return "";
    }

    /**
     * 从map中获取一个字符串值  为空 返回一个默认值
     * @param mapSet map集合
     * @param key 键
     * @param defaultValue 默认值
     * @return 值
     */
    public static String mapValueString(Map<?, ?> mapSet,String key,String defaultValue){
        if(mapSet!=null&& mapSet.containsKey(key)){
            return StringUtil.valueOf(mapSet.get(key),defaultValue);
        }
        return defaultValue;
    }

    /**
     * 判断list是否为空
     * @param mains
     * @return
     */
    public static boolean listIsNull(List<?> mains) {

        return mains==null||mains.isEmpty();
    }
  public static boolean listNotNull(List<?> mains) {

        return mains!=null&&!mains.isEmpty();
    }
    /**
     * 判断对象数组是否不为空
     * @param mains
     * @return
     */
    public static boolean arrNotNull(Object[] mains) {
        return mains != null && mains.length > 0;
    }

    /**
     * 判断对象数组是否为空
     * @param mains
     * @return
     */
    public static boolean arrayIsNull(Object[] mains) {
        return mains==null || mains.length ==0;
    }

    /**
     * 判断字符串数组是否为空
     * @param strs
     * @return
     */
    public static boolean isNull(String[] strs) {
        return (strs == null || strs.length < 1);
    }

    /**
     * 好像没什么卵用
     * @param str
     * @return
     */
    public static String[] split(String str) {
        String[] strs = str.split(" ");
        List<String> sets = new ArrayList<>();
        for (String s : strs) {
            if (" ".equals(s)) {
                continue;
            } else {
                sets.add(s);
            }
        }
        return sets.toArray(new String[sets.size()]);
    }

    /**
     * 判断map是否不为空
     * @param map
     * @return
     */
    public static boolean mapNotNull(Map map) {
        return map != null && !map.isEmpty();
    }

    /**
     * 判断字符串是否有为空格值
     * @param text
     * @return
     */
    public static boolean hasText(String text) {
        return !StringUtil.isNull(text.trim());
    }

    /**
     * 输出字符串 为空时返回空字符串
     * @param value
     * @return
     */
    public static String valueOf(String value) {
        return (isNull(value) ? "" : value);
    }

    /**
     * 将int转换为字符串输出 为空 返回空字符串
     * @param value
     * @return
     */
    public static String valueOf(Integer value) {

        return (isNull(value) ? "" : String.valueOf(value));
    }

    /**
     * 将一个对象以字符串形式输出 为空返回 空字符串
     * @param value
     * @return
     */
    public static String valueOf(Object value) {
        return (isNull(value) ? "" : String.valueOf(value));
    }

    /**
     * 判断是否为数组字符串
     * @param key
     * @return
     */
    public static boolean matchArr(String key) {
        Pattern pattern = Pattern.compile(reg);
        Matcher isNum = pattern.matcher(key);
        return isNum.matches();
    }

    /**
     * 好像没什么卵用
     * @param value
     * @param defaults
     * @param type
     * @param <T>
     * @return
     */
    public static <T> T valueOf(String value, String defaults, Class<T> type) {
        if (StringUtil.isNull(value)) {
            return type.cast(defaults);
        }
        return type.cast(value);
    }

    /**
     * 输出一个字符串 为空 返回默认值
     * @param value
     * @param defaults
     * @return
     */
    public static String valueOf(String value, String defaults) {
        if (StringUtil.isNull(value)) {
            return valueOf(defaults);
        }
        return valueOf(value);
    }

    /**
     * 返回数组中第一个非空对象
     * @param values
     * @param <T>
     * @return
     */
    public static <T> T valueOf(T ... values) {
        for(T value:values){
            if (StringUtil.notNull(value)) {
                return value;
            }
        }
        return null;
    }

    /**
     * 将一个对象转为字符串输出 为空 返回默认值
     * @param value
     * @param defaults
     * @return
     */
    public static String valueOf(Object value, String defaults) {
        if (StringUtil.isNull(value)) {
            return valueOf(defaults);
        }
        return valueOf(value);
    }

    /**
     * 然并卵
     * @param value
     * @param defaults
     * @return
     */
    public static String valueOf(Object value, Object defaults) {
        if (StringUtil.isNull(value)) {
            return valueOf(defaults);
        }
        return valueOf(value);
    }

   /* public static Integer valueOf(Integer value, Integer defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return value;
    }

    public static Long valueOf(Long value, Long defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return value;
    }

    public static Boolean valueOf(Boolean value, Boolean defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return value;
    }*/

    public static Integer integerValueOf(Integer value, Integer defaults) {
        if (value==null) {
            return defaults;
        }
        return value;
    }

    public static Integer integerValueOf(String value, Integer defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return Integer.parseInt(value);
    }

    public static Double doubleValueOf(Double value, Double defaults) {
        if (value==null) {
            return defaults;
        }
        return value;
    }

    public static Double doubleValueOf(String value, Double defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return Double.parseDouble(value);
    }



    public static Integer integerValueOf(Integer value,Integer value1, Integer defaults) {
        if (value!=null) {
            return value;
        }
        if (value1!=null) {
            return value1;
        }
        return defaults;
    }

    public static Long longValueOf(Long value, Long defaults) {
        if (value==null) {
            return defaults;
        }
        return value;
    }

    public static <T> T objectValueOf(T value, T defaults) {

        return value==null?defaults:value;
    }

    public static Long longValueOf(Long value,Long value1, Long defaults) {
        if (value!=null) {
            return value;
        }
        if (value1!=null) {
            return value1;
        }
        return defaults;
    }

    public static Boolean booleanValueOf(Boolean value, Boolean defaults) {
        if (value==null) {
            return defaults;
        }
        return value;
    }

    public static Boolean booleanValueOf(String value, boolean defaults) {
        if (StringUtil.isNull(value)) {
            return defaults;
        }
        return Boolean.valueOf(value);
    }

    public static Boolean booleanValueOf(Object value, Boolean defaults) {
        if (value==null) {
            return defaults;
        }
        return Boolean.class.cast(value);
    }

    public static Boolean booleanValueOf(Boolean value,Boolean value1, Boolean defaults) {
        if (value!=null) {
            return value;
        }
        if (value1!=null) {
            return value1;
        }
        return defaults;
    }

    /**
     * 截取指定字符串（判断长度）
     * @param str
     * @param length
     * @return
     */
    public static String subString(String str, int length) {
        int strLength = str.length();
        if (strLength > length) {
            return str.substring(0, length);
        }
        return str;
    }

    public static String[] valueOf(String[] mappersXml, String[] mappersXml1) {
        if (arrNotNull(mappersXml)) {
            return mappersXml;
        }
        return mappersXml;
    }

    public static List<String> valueOf(List<String> mappers, List<String> mappers1) {
        if (listIsNull(mappers)) {
            return mappers1;
        }
        return mappers;
    }

    public static Map<String,Object> mapValueOf(Map<String, Object> prop, Map<String, Object> prop1) {
        if(prop==null||prop.isEmpty()){
            return prop;
        }
        return prop1;
    }

    /**
     * 将多个字符串拼接成一个字符串
     * @param strings
     * @return
     */
    public static String append(Object ...strings) {
        StringBuilder sb=new StringBuilder();
        for(Object s:strings){
            sb.append(s);
        }
        return sb.toString();
    }

    /**
     * 指定分隔符拼接字符串 一般用于写 sql语句中的 (?,?,?,?) 部分
     * @param num
     * @param str
     * @param sep
     * @return
     */
    public static String join(int num,String str,String sep){
        StringBuilder sb=new StringBuilder();
        int size=num-1;
        for(int i=0;i<size;i++){
            sb.append(str).append(sep);
        }
        sb.append(str);
        return sb.toString();
    }

    /**
     * 将字符串按指定字符拼接  
     * @param sep
     * @param str
     * @return
     */
    public static String join(String sep,String ... str){
        StringBuilder sb=new StringBuilder();
        if(arrayIsNull(str)){
            return "";
        }
        int num=str.length;
        int size=num-1;
        int i=0;
        for(;i<size;i++){
            sb.append(str[i]).append(sep);
        }
        sb.append(str[i]);
        return sb.toString();
    }

    /**
     * 
     * @param sep
     * @param str
     * @return
     */
    public static String join(String sep,List<String> str){
        if(listIsNull(str)){
            return "";
        }
        StringBuilder sb=new StringBuilder();
        int num=str.size();
        int size=num-1;
        int i=0;
        for(;i<size;i++){
            sb.append(str.get(i)).append(sep);
        }
        sb.append(str.get(i));
        return sb.toString();
    }

    /**
     * 将字符串中 ${xxx} 替换为参数
     * @param content
     * @param kvs
     * @return
     */
    public static String parse$(String content, Map<String,String> kvs){
        Pattern p = Pattern.compile("(\\$\\{)([\\w]+)(\\})");
        /**/
        return parse(p,content,kvs);
    }


    /**
     * 将字符串中 {} 大括号括起来的部分 替换 为map中的值
     * @param content
     * @param kvs
     * @return
     */
    public static String parse(String content, Map<String,String> kvs){
        Pattern p = Pattern.compile("(\\{)([\\w]+)(\\})");
        return parse(p,content,kvs);
    }

    public static String parse(Pattern p, String content,Map<String,String> kvs){
        Matcher m = p.matcher(content);
        StringBuffer sr = new StringBuffer();
        while(m.find()){
            String group = m.group();
            m.appendReplacement(sr, String.valueOf(kvs.get(group)));
        }
        m.appendTail(sr);
        return sr.toString();
    }

    /**
     * 创建一个set集合
     * @param vars
     * @param <T>
     * @return
     */
    public static  <T> Set<T> createSet(T ... vars){
        Set<T> set=new HashSet<>();
        for(T obj:vars){
            set.add(obj);
        }
        return set;
    }

    /**
     * 创建一个list集合
     * @param vars
     * @param <T>
     * @return
     */
    public static  <T> List<T> createList(T ... vars){
        List<T> set=new ArrayList<>();
        for(T obj:vars){
            set.add(obj);
        }
        return set;
    }

    /**
     * 创建一个map集合
     * @param vars
     * @param <T>
     * @return
     */
    public static <T> Map createMap(T ... vars){
        Map set=new HashMap();
        for(int i=0;i<vars.length;i+=2){
            set.put(vars[i],vars[i+1]);
        }
        return set;
    }

    /**
     * 创建一个JSONObject 对象
     * @param vars
     * @return
     */
    public static JSONObject createJSONObject(Object ... vars){
        JSONObject set=new JSONObject();
        for(int i=0;i<vars.length;i+=2){
            set.put(String.valueOf(vars[i]),vars[i+1]);
        }
        return set;
    }
}