一个比较好的String类的扩展

最新推荐文章于 2021-07-22 15:56:16 发布
最新推荐文章于 2021-07-22 15:56:16 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckytjx/article/details/48920845
版权 
package tool;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtil {
	public static final String SLASH = getSlash();
	public static final String BACKSLASH = getBackslash();
	public static final String URL_SLASH = getURLSlash();
	public static final String BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	private static final int[] wi = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10,
			5, 8, 4, 2, 1 };

	private static final int[] vi = { 1, 0, 88, 9, 8, 7, 6, 5, 4, 3, 2 };
	private static int[] ai = new int[18];

	public static String getSlash() {
		return "/";
	}

	public static String getBackslash() {
		return "\\";
	}

	public static String getURLSlash() {
		return "//";
	}

	public static String getHTMLBlank() {
		return " ";
	}

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

	//比较
	public static boolean compare(String a, String b) {
		if ((isEmpty(a)) && (isEmpty(b)))
			return true;
		if ((!isEmpty(a)) && (!isEmpty(b))) {
			return a.equals(b);
		}
		return false;
	}

	//去除大小写比较
	public static boolean compareIgnoreCase(String a, String b) {
		if ((isEmpty(a)) && (isEmpty(b)))
			return true;
		if ((!isEmpty(a)) && (!isEmpty(b))) {
			return a.equalsIgnoreCase(b);
		}
		return false;
	}

	//复制
	public static String copy(String src, int len) {
		if (src == null)
			return null;
		if (src.length() > len) {
			return (len <= 0) ? null : src.substring(0, len);
		}
		return src;
	}

	//删除某字符串
	public static String delete(String src, String delStr) {
		if ((isEmpty(src)) || (isEmpty(delStr)))
			return src;
		StringBuffer buffer = new StringBuffer(src);
		for (int index = src.length(); (index = src.lastIndexOf(delStr, index)) >= 0;) {
			buffer.delete(index, index + delStr.length());

			index = index - delStr.length();
		}

		return buffer.toString();
	}

	//插入
	public static String insert(String src, String anotherStr, int offset) {
		if ((isEmpty(src)) || (isEmpty(anotherStr)))
			return src;
		StringBuffer buffer = new StringBuffer(src);
		if ((offset >= 0) && (offset <= src.length()))
			buffer.insert(offset, anotherStr);
		return buffer.toString();
	}

	//追加
	public static String append(String src, String appendStr) {
		if ((isEmpty(src)) || (isEmpty(appendStr))) {
			return src;
		}
		StringBuffer buffer = new StringBuffer(src);
		buffer.append(appendStr);
		return buffer.toString();
	}

	//替换
	public static String replace(String src, String oldStr, String newStr,
			boolean isCaseSensitive) {
		if ((isEmpty(src)) || (isEmpty(oldStr)) || (newStr == null))
			return src;
		String s = (isCaseSensitive) ? src : src.toLowerCase();
		String o = (isCaseSensitive) ? oldStr : oldStr.toLowerCase();
		StringBuffer buffer = new StringBuffer(src);
		for (int index = s.length(); (index = s.lastIndexOf(o, index)) >= 0;) {
			buffer.replace(index, index + o.length(), newStr);

			index = index - o.length();
		}

		return buffer.toString();
	}

	
	public static String replace(String src, String oldStr, String newStr,
			boolean isCaseSensitive, int index) {
		if ((src == null) || (src.length() == 0) || (oldStr == null)
				|| (oldStr.length() == 0) || (index <= 0))
			return src;
		if (newStr == null)
			newStr = "";
		String s = (isCaseSensitive) ? src : src.toLowerCase();
		String o = (isCaseSensitive) ? oldStr : oldStr.toLowerCase();
		StringBuffer buffer = new StringBuffer(src);
		int length = o.length();

		int pos;
		for (pos = s.indexOf(o, 0); pos >= 0; pos = s.indexOf(o, pos + length))
			if (--index == 0)
				break;

		if (pos >= 0 && index == 0)
			buffer.replace(pos, pos + length, newStr);
		return buffer.toString();
	}

	public static String[] split(String str, String delimiter) {
		ArrayList array = new ArrayList();
		int index = 0;
		int begin = 0;
		String[] result = new String[0];
		if (isEmpty(str))
			return result;
		while (true) {
			index = str.indexOf(delimiter, begin);
			if (index == begin) {
				if (index >= 0)
					array.add("");
				begin += delimiter.length();
			}

			if (index <= begin)
				break;
			int end = index;
			array.add(str.substring(begin, end));
			begin = index + delimiter.length();
		}
		if ((begin >= 0) && (begin < str.length()))
			array.add(str.substring(begin));
		if (str.endsWith(delimiter))
			array.add("");
		if (array.size() > 0) {
			result = new String[array.size()];
			array.toArray(result);
		}
		return result;
	}

	public static String[] splitWithoutEmpty(String str, String delimiter) {
		ArrayList array = new ArrayList();
		int index = 0;
		int begin = 0;
		String[] result = new String[0];
		if (isEmpty(str))
			return new String[0];
		while (true) {
			index = str.indexOf(delimiter, begin);
			if (index == begin) {
				if (index > 0)
					array.add("");
				begin += delimiter.length();
			}

			if (index <= begin)
				break;
			int end = index;
			array.add(str.substring(begin, end));
			begin = index + delimiter.length();
		}
		if ((begin >= 0) && (begin < str.length()))
			array.add(str.substring(begin));
		if (array.size() > 0) {
			result = new String[array.size()];
			array.toArray(result);
		}
		return result;
	}

	public static String reverse(String str) {
		if (isEmpty(str)) {
			return str;
		}
		StringBuffer buffer = new StringBuffer(str);
		buffer.reverse();
		return buffer.toString();
	}

	public static String quote(String str) {
		if (isEmpty(str))
			return "\"\"";
		StringBuffer buffer = new StringBuffer(str);
		if (!str.startsWith("\""))
			buffer.insert(0, "\"");
		if (!str.endsWith("\""))
			buffer.append("\"");
		return buffer.toString();
	}

	public static String extractQuotedStr(String str) {
		if (isEmpty(str))
			return str;
		StringBuffer buffer = new StringBuffer(str);
		int index = str.length();
		while (buffer.charAt(buffer.length() - 1) == '"') {
			buffer.deleteCharAt(buffer.length() - 1);
			index = buffer.length();
			if (index <= 0)
				break;
		}
		if (buffer.length() == 0)
			return "";
		do {
			buffer.deleteCharAt(0);
			index = buffer.length();
			if (index <= 0)
				break;
		} while (buffer.charAt(0) == '"');

		return buffer.toString();
	}

	public static String strChar(String str, char c) {
		if ((str == null) || (str.length() == 0))
			return null;
		for (int i = 0; i < str.length(); ++i) {
			if (str.charAt(i) == c)
				return str.substring(i);
		}
		return null;
	}

	public static String strRChar(String str, char c) {
		if ((str == null) || (str.length() == 0))
			return null;
		for (int i = str.length() - 1; i >= 0; --i) {
			if (str.charAt(i) == c)
				return str.substring(i);
		}
		return null;
	}

	public static String[] toArray(Object[] array) {
		if ((array == null) || (array.length == 0))
			return null;
		String[] result = new String[array.length];
		for (int i = 0; i < array.length; ++i) {
			if (array[i] != null)
				result[i] = array[i].toString();
		}
		return result;
	}

	public static String[] toArray(Vector list) {
		if ((list == null) || (list.size() == 0))
			return null;
		String[] result = new String[list.size()];
		for (int i = 0; i < list.size(); ++i) {
			Object obj = list.get(i);
			if (obj != null) {
				result[i] = list.get(i).toString();
			}
		}
		return result;
	}

	public static List copyToList(String[] array, List list, int index) {
		if ((array == null) || (array.length == 0))
			return list;
		if ((list == null) || (index < 0))
			return list;
		for (int i = 0; i < array.length; ++i) {
			if (list.size() <= i + index)
				list.add(index + i, array[i]);
			else
				list.set(index + i, array[i]);
		}
		return list;
	}

	public static boolean contains(Object[] array, String str) {
		if ((array == null) || (array.length == 0))
			return false;
		if (str == null)
			return false;
		for (int i = 0; i < array.length; ++i) {
			Object obj = array[i];
			if ((obj != null) && (str.equals(obj.toString()))) {
				return true;
			}
		}
		return false;
	}

	public static int indexOf(Object[] array, String str) {
		if ((array == null) || (array.length == 0))
			return -1;
		if (str == null)
			return -1;
		for (int i = 0; i < array.length; ++i) {
			Object obj = array[i];
			if ((obj != null) && (str.equals(obj.toString()))) {
				return i;
			}
		}
		return -1;
	}

	public static boolean isValidEmail(String theEmail) {
		boolean cbool = 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(theEmail);
			boolean isMatched = matcher.matches();
			if (isMatched)
				cbool = true;
		} catch (Exception e) {
			e.printStackTrace();
			return cbool;
		}
		return cbool;
	}

	public static String trimLeft(String str) {
		if (str == null)
			return null;
		int length = str.length();
		if (length == 0)
			return "";
		StringBuffer buffer = new StringBuffer(str);
		int index;
		for (index = 0; index < length && buffer.charAt(index) == ' '; index++)
			;
		if (index == length)
			return "";
		else
			return buffer.substring(index);
	}

	public static String trimRight(String str) {
		if (str == null)
			return null;
		int length = str.length();
		if (length == 0)
			return "";
		StringBuffer buffer = new StringBuffer(str);
		int index;
		for (index = length - 1; index >= 0 && buffer.charAt(index) == ' '; index--)
			;
		if (index < 0 && buffer.charAt(0) == ' ')
			return "";
		else
			return buffer.substring(0, index + 1);
	}

	public static String trimAll(String str) {
		return str.trim();
	}

	public static String removeNull(String str) {
		return (str != null) ? str : "";
	}

	public static String removeNull(Object str) {
		return (str != null) ? str.toString() : "";
	}

	public static boolean strInArray(String[] strs, String str,
			boolean caseSensitive) {
		if ((strs != null) && (strs.length > 0)) {
			for (int i = 0; i < strs.length; ++i) {
				if (caseSensitive) {
					if (strs[i].equals(str))
						return true;
				} else if (strs[i].equalsIgnoreCase(str)) {
					return true;
				}
			}
		}

		return false;
	}

	public static boolean idCardVerify(String idcard) {
		if (idcard.length() == 15) {
			idcard = idCardUptoeighteen(idcard);
		}
		if (idcard.length() != 18) {
			return false;
		}
		String verify = idcard.substring(17, 18);

		return verify.equals(getIdCardVerify(idcard));
	}

	public static String getIdCardVerify(String eightcardid) {
		int remaining = 0;
		if (eightcardid.length() == 18) {
			eightcardid = eightcardid.substring(0, 17);
		}
		if (eightcardid.length() == 17) {
			int sum = 0;
			for (int i = 0; i < 17; ++i) {
				String k = eightcardid.substring(i, i + 1);
				ai[i] = Integer.parseInt(k);
			}
			for (int i = 0; i < 17; ++i) {
				sum += wi[i] * ai[i];
			}
			remaining = sum % 11;
		}
		return (remaining == 2) ? "X" : String.valueOf(vi[remaining]);
	}

	public static String idCardUptoeighteen(String fifteencardid) {
		if (fifteencardid.length() != 15)
			return null;
		String eightcardid = fifteencardid.substring(0, 6);
		eightcardid = eightcardid + "19";
		eightcardid = eightcardid + fifteencardid.substring(6, 15);
		eightcardid = eightcardid + getIdCardVerify(eightcardid);
		return eightcardid;
	}

	public static boolean isPhoneNum(String phoneCode) {
		Pattern p = Pattern.compile("[0][1-9]{2,3}[1-9]{6,8}");
		Matcher m = p.matcher(phoneCode);
		boolean b = m.matches();
		return b;
	}

	public static String arrayToString(String[] str) {
		if (str == null)
			return "";
		StringBuffer rStr = new StringBuffer("");
		for (int i = 0; i < str.length; ++i) {
			rStr.append(str[i]);
			rStr.append(",");
		}

		if (rStr.toString().length() > 0) {
			rStr.setLength(rStr.length() - 1);
		}
		return rStr.toString();
	}

	public static boolean isNullOrEmpty(Object o) {
		return (o == null) || (String.valueOf(o).trim().length() == 0);
	}
}

luckytjx
关注
专栏目录
扩展C++ string类
passion_wu128的专栏
08-03 4767
头文件如下：
Java类加载器--手写一个String类能否被类加载器加载？
Doit_kang的博客
07-06 3524
谈到Java的类加载器，大家应该都不陌生。但最近在逛面经分享时看到这样一个问题：“手写一个String类能否被类加载器加载？”笔者自己试了下，发现这个问题几乎把类加载器的原理都考了一遍，不信咱们就来碰一碰它。
扩展String类
weixin_34290096的博客
05-06 164
  因为.Net Framework中的String类是封闭的，所以我们不能从它进行派生来扩展它的功能。  虽然String类已经提供了很多有用的方法来让我们进行字符串的处理和操作，但是有时候一些特殊的的要求还是不能能到满足。  一个例子就是：假如有一个因为句子，比如：“how are you”,我们需要把每个单词的首字母都改成大写，当然人工改写很大一篇文章是很费力的，但是我们查阅.Net Fra...
JavaSE————String类功能扩展
11-21 210
//String类扩展功能实现 public class Strings{ public static void main(String[] args){ // System.out.println(repeat('a',0)); // System.out.println(repeat('a',-4)); // System.out.println(repeat('a',...
学用 ASP.Net 之 "字符串" (4): string 类的扩展方法
weixin_33748818的博客
12-31 220
学到这里, 真是开眼界了...有太多陌生的概念. string 类的扩展方法大都继承自 IEnumerable&lt;T&gt; 接口, 这些方法也大都可以在 foreach 语句中实现, 但这些方法太方便了. 尽管 string 类重载了其中很多方法, 但真正适合字符串操作的方法并不多; 此时我感觉, 前两天定下的学习计划出了问题, 因为仅用字符串很难理清这组方法; 不过要继续......
string 类的扩展方法
lswlovetsw的专栏
12-02 575
string 类的扩展方法列表(基本相同于 IEnumerable 接口的成员列表): Aggregate//累加 All//是否都满足条件 Any//是否有一个满足条件 AsEnumerable// AsParallel// AsQueryable// Average//平均值 Cast// Concat//连接 Contains//是否包含 Count//总数 DefaultIfEmp
扩展String功能方法
10-09
扩展String功能方法：一直好忙，没有时间写属于自己的东西，但是看着一天天不更新心情也不是个滋味，只有从网上收罗一些比较好的东东贴上。
StringEmoji：String快速的String扩展类，用于处理与Emoji相关的任务
02-05
一个快速的5.0字符串扩展类，用于处理与表情符号有关的任务。 CocoaPods安装 pod 'StringEmoji', :git => 'https://github.com/piterwilson/StringEmoji.git' 用法 import StringEmoji 文献资料 字符串扩展 var ...
SwiftString, 一个全面的，轻量级的字符串扩展，用于 Swift.zip
09-18
SwiftString, 一个全面的，轻量级的字符串扩展，用于 Swift SwiftString SwiftString是Swift的轻量级字符串扩展。 这个库有助于为常见字符串操作搜索 with，并希望它们在一个地方进行测试覆盖。安装SwiftString可以...
扩充String类
u012519969的专栏
01-22 699
1
【Java】String类扩展功能实现
Qingmou's_blog
11-25 1078
重复某个字符 //String类扩展功能实现 public class Strings{ /** * 重复某个字符 * * 例如： * 'a' 5 =&gt; "aaaaa" * 'a' -1 =&gt; "" * * @param c 被重复的字符 * @param count 重复...
Swift常用的String类扩展
懒人改变世界
03-15 1438
常用的扩展// 字符串类扩展 extension String { /// 获取字符串绘制的高度 /// /// - parameter font : 要绘制的字体，将会影响行高等 /// - parameter width : 绘制的宽度 /// - returns : 字符串绘制的最大高度 func getMaxHeight
String类详解笔记----拓展
m0_57249797的博客
07-22 123
目录 String类对象实例化 字符串比较 字符串常量 两种实例化方式比较（共享设计模式的应用） 字符串常量池 字符串修改分析 主方法组成分析 String类常用方法 JavaDoc文档介绍 字符串与字符 字符串与字节 字符串比较 字符串查找 字符串替换 字符串拆分 字符串截取 字符串格式化 其他操作方法 本章概要 引言:在实际项目开发中，String是一个必须使用的程序类，可以说是项目的核心组成类。在java程序里所有的字符串都要使用"“进行定义，同时也可以利
java string 扩展_JAVA学习笔记之String常用函数和String扩展
weixin_30118803的博客
02-12 346
处理String的常用工具函数：subString(); //前面包含，后面不包含。 (适合大多数API)trim(); //去掉字符串前面后面的空格常用的String函数：通过字符串中特定的符号，将字符串分割为多个字符串数组：Split(); //分割很严格参数是String//String s1 = “caihongwang，时彦芳，李梦川”;//String[] s2 = s1.split(...
java-String扩展
x__torrey的博客
10-18 413
StringBuffer      概述：线程安全的可变字符序列。      与String区别： 前者长度和内容可变可变，节省资源 后者不可变 StringBuilder       概述：线程不安全的可变字符序列。效率高，用于字符串缓冲区被单个线程使用的时候。       特点：比StringBuffer效率更高。 String，StringBuffer和StringBuild...
Java—String类扩展功能实现
qq_39663771的博客
11-25 910
//String类扩展功能实现 public class Strings{ /** * 1.重复某个字符 * * 例如： * 'a' 5 =&gt; "aaaaa" * 'a' -1 =&gt; "" * * @param c 被重复的字符 * @param count 重复...
String类功能扩展实现
LSMSMD0526的博客
11-24 803
String类是Java语言中常用的一个类，基本在所有的项目开发中都会用到。String类的实例化方式有两种： 1.直接赋值 String str = "Hello Bit";//str是一个对象，那么 "Hello Bit"就应该保存在堆内存中 System.out.println(str); 直接赋值是最常用的实例化方式，但是String 本身是一个类，既然是类，那么类中一定存在构造方法。S...
String的扩展方法
litternannan的博客
04-19 426
String的扩展方法 模板字符串中可以解析变量 let name = '这是一个字符串’； let sayHello = 'hello,my name is ${name}'; //$可以将字符串直接引用 模板字符串可以换行 let result = { name: "xiaonannan", age: 20, }; //可以换行 let html = ' &l...
string扩展方法可以返回一个不是string的类吗？
最新发布
06-12
是的，string扩展方法也可以返回一个与string类型不同的实例。在.NET框架中，扩展方法是一种静态方法，它定义在静态类中，而且其第一个参数是扩展方法要操作的类型。对于string类型，扩展方法的第一个参数必须是this...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值