package yqw.java.util;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtils {

private static final Pattern validNumber = Pattern.compile("^[\\d\\.]+$|^0x[\\dA-Fa-f]+$");
    private static final Pattern validStr = Pattern.compile("[\\w\\d\\u4E00-\\u9FA5]+");
    private static final Pattern valueTypePat = Pattern.compile("(\\d+\\.?\\d*)([ilfdD])");
    private static final Pattern validPhone = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");
    private static final Pattern validEmail = Pattern.compile("^([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)*"
            + "@([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)+[\\.][A-Za-z]{2,3}([\\.][A-Za-z]{2})?$");
    private static char punct[] = { ',', '.', '!', '?', ';', ':', ',', '。', '!', '?', ';', ':', '、' };

/**
     * 验证邮箱
     *
     * @param email
     * @return
     */

public static boolean checkEmail(String email) {
        boolean flag = false;
        try {
            String check = "^([a-z0-9A-Z]+[-|_|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
            Pattern regex = Pattern.compile(check);
            Matcher matcher = regex.matcher(email);
            flag = matcher.matches();
        } catch (Exception e) {
            flag = false;
        }
        return flag;
    }

/**
     * 验证手机号码,11位数字,1开通,第二位数必须是3456789这些数字之一 *
     *
     * @param mobileNumber
     * @return
     */
    public static boolean checkMobileNumber(String mobileNumber) {
        boolean flag = false;
        try {
            // Pattern regex =
            // Pattern.compile("^(((13[0-9])|(15([0-3]|[5-9]))|(18[0,5-9]))\\d{8})|(0\\d{2}-\\d{8})|(0\\d{3}-\\d{7})$");
            Pattern regex = Pattern.compile("^1[345789]\\d{9}$");
            Matcher matcher = regex.matcher(mobileNumber);
            flag = matcher.matches();
        } catch (Exception e) {
            e.printStackTrace();
            flag = false;

}
        return flag;
    }

/**
     * 将字符串中的标点符号过滤掉
     *
     * @param str
     * @return
     */
    public static String TrimPunctuation(String str) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); ++i) {
            boolean need_filter = false;
            for (int j = 0; j < punct.length; ++j) {
                if (punct[j] == str.charAt(i)) {
                    need_filter = true;
                    break;
                }
            }

if (!need_filter) {
                result.append(str.charAt(i));
            }
        }

return result.toString();
    }

/**
     * 判断是否包含标点
     */
    public static boolean ContainsPunctuation(String str) {
        for (int i = 0; i < str.length(); ++i) {
            for (int j = 0; j < punct.length; ++j) {
                if (punct[j] == str.charAt(i)) {
                    return true;
                }
            }
        }

return false;
    }

// 将日期简单格式化
    public static String FormatDateInFormat(Date date, String format) {
        SimpleDateFormat fmt = new SimpleDateFormat(format);
        return fmt.format(date);
    }

public static String FormatDateTime(Date date) {
        return FormatDateInFormat(date, "yyyy-MM-dd HH:mm:ss");
    }

public static String FormatDateTime(Calendar date) {
        return FormatDateTime(date.getTime());
    }

public static String FormatDate(Date date) {
        return FormatDateInFormat(date, "yyyy-MM-dd");
    }

public static String FormatDateForQuery(Date date) {
        return FormatDateInFormat(date, "yyyyMMdd");
    }

public static String FormatDate(Calendar date) {
        return FormatDateInFormat(date.getTime(), "yyyy-MM-dd");
    }

public static String CalendarToString(Calendar date) {
        return FormatDateInFormat(date.getTime(), "yyyy-MM-dd");
    }

/**
     * 将时间字符串解析为calendar
     */
    public static Calendar StringToCalender(String str_date) {
        Date date = StringToDate(str_date);
        Calendar cal = new GregorianCalendar();
        cal.setTime(date);
        return cal;
    }

/**
     * 使用指定日期格式解析日期字符串
     *
     * @param dateStr
     *            日期字符串
     * @param dateFormat
     *            日期格式,SimpleDateFormat能够识别的格式
     * @return 成功返回Date,失败返回null
     */
    public static Date StringToDateInFormat(String dateStr, String dateFormat) {
        SimpleDateFormat fmt = new SimpleDateFormat(dateFormat);
        try {
            return fmt.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

public static Date StringToDate(String date) {
        return StringToDateInFormat(date, "yyyy-MM-dd");
    }

public static Date StringToDateInQuery(String date) {
        return StringToDateInFormat(date, "yyyyMMdd");
    }

// 将时长格式化为时分秒的样式
    public static String FormatTimeDuration(int sec) {
        return String.format("%02d:%02d", sec / 60, sec % 60);
    }

// 对字符串数组进行trim
    public static String[] TrimStringArray(String[] arr) {
        assert (arr != null);
        Vector<String> lst = new Vector<String>();
        for (int i = 0; i < arr.length; ++i) {
            String item = arr[i];
            item.trim();
            if (!item.isEmpty())
                lst.add(item);
        }

if (lst.size() == 0) {
            return null;
        } else {
            String[] str_arr = new String[lst.size()];
            for (int i = 0; i < lst.size(); ++i) {
                str_arr[i] = lst.get(i);
            }
            return str_arr;
        }
    }

// 对get方式过来的中文参数的乱码进行转码
    public static String StringToUTF8(String param) throws Exception {
        return new String(param.getBytes("ISO-8859-1"), "UTF-8");
    }

// 判断字符串是否为空
    // 包括是否为null,是否为空字符串,过滤完空格后是否为空字符串
    public static boolean IsAbsEmpty(final String str) {
        if (str == null) {
            return true;
        } else {
            return str.trim().isEmpty();
        }
    }

// 判断字符串是否为空
    // 包括是否为null,是否为空字符串,过滤完空格后是否为空字符串
    public static boolean IsAbsEmpty(final StringBuffer str) {
        if (str == null) {
            return true;
        } else {
            return IsAbsEmpty(str.toString());
        }
    }

// 判断字符串是否为空
    // 包括是否为null,是否为空字符串,过滤完空格后是否为空字符串
    public static boolean IsAbsEmpty(final StringBuilder str) {
        if (str == null) {
            return true;
        } else {
            return IsAbsEmpty(str.toString());
        }
    }

/**
     * 将字符串值转换为指定类型
     *
     * @param val
     *            字符串字面值
     * @param type
     *            目标类型 支持包括int, long, date, string, float, double
     * @return 转换后的对象
     */
    public static Object ConvertToType(String val, String type) {
        Matcher mat = valueTypePat.matcher(val);
        boolean matRet = mat.matches();
        if (matRet) {
            val = mat.group(1);
        }

try {
            if (type.matches("i|int")) {
                return Integer.valueOf(val);
            } else if (type.matches("l|long")) {
                return Long.valueOf(val);
            } else if (type.matches("s|string")) {
                return val;
            } else if (type.matches("f|float")) {
                return Float.valueOf(val);
            } else if (type.matches("d|double")) {
                return Double.valueOf(val);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

public static String ToShortType(String type) {
        if (type.matches("i|int")) {
            return "i";
        } else if (type.matches("l|long")) {
            return "l";
        } else if (type.matches("s|string")) {
            return "";
        } else if (type.matches("f|float")) {
            return "f";
        } else if (type.matches("d|double")) {
            return "d";
        } else if (type.matches("D|date")) {
            return "D";
        } else {
            return null;
        }
    }

/**
     * 通过后缀表示类型,进行转换 后缀类型,包括i,l,f,d,D
     */
    public static Object ConvertToType(String val) {
        Matcher mat = valueTypePat.matcher(val);
        boolean matRet = mat.matches();

if (!matRet) {
            // 没匹配则之间返回原始字符串
            return val;
        }

try {
            String type = mat.group(2);
            String value = mat.group(1);

if (type.equals("i")) {
                return Integer.valueOf(value);
            } else if (type.equals("l")) {
                return Long.valueOf(value);
            } else if (type.equals("f")) {
                return Float.valueOf(value);
            } else if (type.equals("d")) {
                return Double.valueOf(value);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

/**
     * 根据后缀判断类型
     */
    public static String DetectType(String val) {
        Matcher mat = valueTypePat.matcher(val);
        boolean matRet = mat.matches();
        if (!matRet)
            return null;

return mat.group(2);
    }

/**
     * 从字符串形式的年-月-日中提取出 年-月
     *
     * @param fileDate
     *            原始日期字符串
     * @return 返回的年-月字符串
     */
    public static String ExtractMonth(String fileDate) {
        String[] date = fileDate.split("-");
        assert date.length >= 3;
        return date[0] + "-" + date[1];
    }

public static String ExtractMonth(Calendar date) {
        return String.format("%4d-%02d", date.get(Calendar.YEAR), date.get(Calendar.MONTH));
    }

/**
     * 从字符串中解析出列表,分隔符支持;,: 该方法会将空节点剔除掉
     *
     * @param str
     *            字符串
     * @return 解析后的列表
     */
    public static List<String> ParseList(String str) {
        final String splitter = "[;,:]";
        return ParseList(splitter);
    }

public static List<String> ParseList(String str, String splitter, boolean trimEmpty) {
        List<String> lst = new Vector<String>();
        String[] splits = str.split(splitter, -1);
        for (String item : splits) {
            if (trimEmpty && IsAbsEmpty(item))
                continue;
            lst.add(item);
        }

return lst;
    }

/**
     * 将字符串列表,使用分号分割
     *
     * @param lst
     *            字符串列表
     * @return 返回整合后的字符串
     */
    public static String CollectionToStringWithSemicolon(Collection<? extends Object> lst) {
        StringBuilder str = new StringBuilder();
        for (Object item : lst) {
            str.append(item.toString()).append(";");
        }
        if (str.length() > 0)
            str.deleteCharAt(str.length() - 1);
        return str.toString();
    }

/**
     * 从字符串中解析出map key和value之间使用:分割,节点之间使用;分割
     *
     * @param str
     *            原始字符串
     * @return 解析后的map
     */
    public static Map<String, String> ParseMap(String str) {
        return ParseMap(str, ";", ":");
    }

/**
     * 从字符串中解析出map 可指定分割符
     */
    public static Map<String, String> ParseMap(String str, String item_split, String kv_split) {
        String[] splits = str.split(item_split);
        Map<String, String> map = new HashMap<String, String>();
        for (String item : splits) {
            String[] key_val = item.split(kv_split);
            if (key_val.length == 1) {
                map.put(key_val[0], "");
            } else if (key_val.length >= 2) {
                map.put(key_val[0].trim(), key_val[1].trim());
            }
        }
        return map;
    }

/**
     * 从字符串中解析出map key和value之间使用:分割,节点之间使用;分割
     *
     * @param str
     *            原始字符串
     * @return 解析后的map
     */
    public static Map<String, Integer> ParseIntegerMap(String str) {
        String[] splits = str.split("[;,]");
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String item : splits) {
            String[] key_val = item.trim().split(":");
            if (key_val.length != 2)
                continue;

map.put(key_val[0].trim(), Integer.valueOf(key_val[1].trim()));
        }
        return map;
    }

/**
     * 将map对象转为字符串,节点之间使用;,key val之间使用:
     */
    public static String MapToStringWithSemicolon(Map<String, ? extends Object> map) {
        return MapToString(map, ";", ":");
    }

/**
     * 将map转换为字符串,分隔符可指定
     *
     * @param item_split
     *            节点之间的字符串
     * @param kv_split
     *            键值对质检的字符串
     */
    public static String MapToString(Map<String, ? extends Object> map, String item_split, String kv_split) {
        StringBuilder str = new StringBuilder();
        for (Map.Entry<String, ? extends Object> item : map.entrySet()) {
            str.append(item.getKey()).append(kv_split).append(item.getValue()).append(item_split);
        }
        if (str.length() > 0)
            str.deleteCharAt(str.length() - 1);
        return str.toString();
    }

/**
     * 用于将两条存在一一对应关系的字符串,解析为map
     */
    public static Map<String, Integer> ParseIntegerMapFromPairString(String str_key, String str_val) {
        List<String> key_lst = ParseList(str_key);
        List<String> val_lst = ParseList(str_val);
        if (key_lst.size() != val_lst.size())
            return null;

Map<String, Integer> final_map = new HashMap<String, Integer>();
        for (int i = 0; i < key_lst.size(); ++i) {
            final_map.put(key_lst.get(i), Integer.valueOf(val_lst.get(i)));
        }
        return final_map;
    }

public static List<Integer> ParseIntegerList(String str) {
        List<String> lst = ParseList(str);
        List<Integer> int_lst = new ArrayList<Integer>();
        for (String item : lst) {
            int_lst.add(Integer.valueOf(item));
        }

return int_lst;
    }

/**
     * 使用指定的分隔符合并两个字符串 分隔符会和第一个字符串末尾、第二个字符串的开头出现的对应字符进行合并
     *
     * @param one
     *            第一个字符串
     * @param two
     *            第二个字符串
     * @param splitter
     *            分隔符
     * @return 合并后的字符串
     */
    public static String CombineWithSplitter(String one, String two, String splitter) {
        StringBuilder finalStr = new StringBuilder();
        int splitterPos = one.lastIndexOf(splitter);
        if ((splitterPos != -1) && (splitterPos + splitter.length() == (one.length()))) {
            finalStr.append(one.substring(0, splitterPos));
        } else {
            finalStr.append(one);
        }

if (finalStr.length() > 0)
            finalStr.append(splitter);

splitterPos = two.indexOf(splitter);
        if (splitterPos == 0) {
            finalStr.append(two.substring(splitterPos + splitter.length()));
        } else {
            finalStr.append(two);
        }

return finalStr.toString();
    }

/**
     * 前缀补充
     *
     * @param prefix
     *            前缀字符串
     * @param str
     *            原始字符串
     * @return 补充哦功能后的字符串
     */
    public static String PrependPrefix(String prefix, String str) {
        return prefix + str;
    }

/**
     * 删除前缀
     */
    public static String RemovePrefix(String prefix, String str) {
        int index = str.indexOf(prefix);
        if (index != 0) {
            return str.substring(index + prefix.length());
        } else {
            return str;
        }
    }

/**
     * 生成固定长度的随即字符串
     *
     * @param length
     *            字符串长度
     */
    public static String RandomString(int length) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < length; ++i) {
            str.append((char) ('A' + (int) (Math.random() * 26)));
        }

return str.toString();
    }

/**
     * 判断是否包含非法字符、特殊字符
     */
    public static boolean IsValidChar(String str) {
        return validStr.matcher(str).matches();
    }

/**
     * 路径统一格式化
     */
    public static String NormalizePath(String path) {
        return path.replace("\\", "/");
    }

/**
     * 获取文件不带扩展名的路径
     *
     * @param source
     *            文件路径
     * @return 文件名
     */
    public static String GetFileNameWithoutExt(String source) {
        String fileName = new File(source).getName();
        int pos = fileName.indexOf(".");
        if (pos == -1) {
            return fileName;
        } else {
            return fileName.substring(0, pos);
        }
    }

/**
     * 判断字符串是否是数字
     *
     * @param input
     *            字符串
     */
    public static boolean IsValidInteger(String input) {
        try {
            Integer.valueOf(input);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

/**
     * 判断字符串是否是浮点型数字
     *
     * @param input
     *            字符串
     */
    public static boolean IsValidFloat(String input) {
        try {
            Float.valueOf(input);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

/**
     * 验证邮箱格式是否合法
     *
     * @param email
     *            邮箱名
     * @return 是否合法
     */
    public static boolean IsValidEmail(String email) {
        return validEmail.matcher(email).matches();
    }

/**
     * 验证手机号是否合法
     *
     * @param phone
     *            手机号
     * @return 是否合法
     */
    public static boolean IsValidPhone(String phone) {
        return validPhone.matcher(phone).matches();
    }

/**
     * 生成组合路径
     *
     * @param base
     *            父目录
     * @param sub
     *            子路径
     */
    public static String CombinePath(String base, String sub) {
        // 如果是根目录,直接合并
        if (base.equals("/")) {
            return base + sub;
        }
        return CombineWithSplitter(base, sub, "/");
    }

/**
     * 全角转半角
     *
     * @param str
     *            字符串
     */
    public static String FullToHalf(String str) {
        StringBuffer sb = new StringBuffer();
        try {
            for (int i = 0; i < str.length(); i++) {
                if (str.substring(i, i + 1).equals(" ") || str.substring(i, i + 1).equals(" ")) {
                    sb.append(" ");
                    continue;
                }
                byte[] temp = str.substring(i, i + 1).getBytes("unicode");
                if (temp[2] == -1) {
                    temp[3] = (byte) (temp[3] + 32);
                    temp[2] = 0;
                }
                sb.append(new String(temp, "unicode"));
            }
        } catch (Exception e) {
        }
        return sb.toString();
    }

/**
     * 小数转百分数
     */
    public static String DecimalToPercent(double num) {
        return String.format("%.2f", (double) (Math.round(num * 10000) / 100.f));
    }

/**
     * 生成唯一令牌
     */
    public static String UUID() {
        return UUID.randomUUID().toString();
    }

/**
     * 清理掉前后的空白字符
     */
    public static Object TrimBlank(String version) {
        return version.replaceAll("^\\s+|\\s+$", "");
    }

public static boolean IsTrue(String value) {
        return value.toLowerCase().matches("1|true");
    }

public static boolean IsFalse(String value) {
        return value.toLowerCase().matches("0|false");
    }

/**
     * 判断str是否匹配regExp正则表达式
     *
     * @param regExp
     *            正则表达式
     * @param str
     *            字符串
     * @return 是否匹配
     */
    public static boolean IsMatch(String regExp, String str) {
        Pattern pattern = Pattern.compile(regExp);
        Matcher mat = pattern.matcher(str);
        return mat.matches();
    }

}

字符串处理工具StringUtils的更多相关文章

  1. 用户代理字符串识别工具源码与slf4j日志使用

    User Agent中文名为用户代理,简称 UA,它是一个特殊字符串头,使得服务器能够识别客户使用的操作系统及版本.CPU 类型.浏览器及版本.浏览器渲染引擎.浏览器语言.浏览器插件等.UA也成为了, ...

  2. Java操作字符串的工具类

    操作字符串的工具类 import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStre ...

  3. 玩程序 之 一 . 字符串处理工具(可通过C#脚本扩展)

    平常喜欢写点小东西玩玩,既可以娱乐自己满足自己的虚荣心,又可以方便工作和学习,今天且拿出一个来,与大家一起分享!  1. 软件介绍 言归正传,先看看需求,有这样一串字符串 abc,def,ghi,jk ...

  4. java 二进制数字符串转换工具类

    java 二进制数字符串转换工具类 将二进制转换成八进制 将二进制转换成十进制 将二进制转换成十六进制 将十进制转换成二进制 package com.iteye.injavawetrust.ad; i ...

  5. Java随机字符串:随机数字字符串,工具类

    Java中生成随机数,字符串的工具类 1. 调用方法需要传入生成字符串的长度和需要的类型 生成随机数字 生成随机字母字符串 生成随机字符串+数字等 ......... 2. 总共8种类型,具体看工具类 ...

  6. bash的内置字符串处理工具

    bash内置字符串处理工具: 1.字符串切片: ${var:offset:number} 取字符串的子串: ${var:  -length} 取字符串的最右侧的length个字符.注意:冒号右侧必须有 ...

  7. 字符串处理工具Guava使用总结

    字符串处理工具Guava使用总结 在java开发过程中对字符串的处理是非常频繁的,google的guava工具对字符串的一些处理进行优化,使我们开发过程中让自己的代码看去更加美观,清爽. 1:mave ...

  8. C# 数据库链接字符串加密工具

    有些项目尤其是WinForm或者是WPF项目,针对一些工具形式的小项目,不想软件流出去之后,懂程序的的拿到手之后一看配置文件就知道了我们数据库的用户名和密码,如果外网能访问的话,那就麻烦大了.所以这里 ...

  9. xml转Map,对象,Map转xml,inputs tram 转xml 字符串的工具类方法

    众所周知,大家在微信开发工程中,由于微信开发文档中,对于消息的接收发送都是基础xml数据的(太坑了),所以我们需要对XML进行解析转换: 1.我们先引入所需要的依赖 dom4j (解析xml的),xs ...

随机推荐

  1. 死磕并发之CountDownLatch解析

    CountDownLatch解析 CountDownLatch是什么 CountDownLatch是基于AQS的阻塞工具,阻塞一个或者多个线程,直到所有的线程都执行完成. CountDownLatch ...

  2. 洛谷 P1134 阶乘问题 题解

    题面 很裸的边取模边乘.注意因为进位的原因模数应该比较大: 另外,这道题是一道标准的分块打表例题(那样的话数据就可以更大了),可以用来练习分块打表: #include<bits/stdc++.h ...

  3. PHP常见数组排序方法小结

    1.简单数组排序 sort() 函数和rsort() 函数: 语法规则: bool sort(array &array [,int sort_flags] bool rsort(array & ...

  4. Python常用库整理

    Python常用库整理 Python中到底有哪些库会让程序员爱不释手?以至于一次上瘾,造成永久性伤害(这句话好像在哪里见过),今天我们就来整理一番这样的库,欢迎各位在评论区或者私信我添加或者修改相关库 ...

  5. Python字符串和正则表达式中的反斜杠('\')问题

    在Python普通字符串中 在Python中,我们用'\'来转义某些普通字符,使其成为特殊字符,比如 In [1]: print('abc\ndef') # '\n'具有换行的作用 abc defg ...

  6. ElasticSearch5.3安装IK分词器并验证

    ElasticSearch5.3安装IK分词器 之前使用Elasticsearch安装head插件成功了,但是安装IK分词器却失败了.貌似是ElasticSearch5.0以后就不支持直接在elast ...

  7. 093、如何用Graylog 管理日志? (2019-05-17 周五)

    参考https://www.cnblogs.com/CloudMan6/p/7821817.html   上节我们已经部署好了 Graylog ,现在学习如何使用他来管理日志.   首先运行测试容器, ...

  8. luogu P2481 [SDOI2010]代码拍卖会

    luogu 题目中的那个大数一定是若干个1+若干个2+若干个3...+若干个9组成的,显然可以转化成9个\(\underbrace {111...1}_{a_i个1}(0\le a_1\le a_2\ ...

  9. tomcat部署项目时 报错Tomcat version 7.0 only supports J2EE 1.2, 1.3, 1.4, and Java EE 5 and 6 Web modules

    Tomcat version 7.0 only supports J2EE 1.2, 1.3, 1.4, and Java EE 5 and 6 Web modules 解决方法: 找到文件 .set ...

  10. Delphi 帮助的使用