java学习笔记之String的方法

                String str = "AwoDeCSDN";

		// charAt(int index)
		// 返回指定index 位置的字符，
		char charAt = str.charAt(5);

		// codePointAt(int index)
		// 返回指定index 位置的字符的Unicode 编码
		int codePointAt = str.codePointAt(0);

		// codePointBefore(int index)
		// 返回指定index-1 位置的字符的Unicode 编码
		int codePointBefore = str.codePointBefore(1);

		// codePointCount(int beginIndex, int endIndex)
		// 返回endIndex - beginIndex 之间有多少个Unicode
		// 编码，endIndex>=beginIndex（必须，不然报错）
		// str.codePointCount(0, str.length()) == str.length()
		int codePointCount = str.codePointCount(0, str.length());

		String sss = "acD";
		String sss1 = "aBd";
		// compareTo(String anotherString)
		// 比较两个字符串相同角标位置的字符的ASCII值，
		// A.compareTo（B），A[i]-B[i]
		int compareTo = sss.compareTo(sss1);

		// compareToIgnoreCase(String str)
		// 比较两个字符串相同角标位置的字符的ASCII值，
		// A.compareToIgnoreCase（B），A[i]-B[i], 忽略大小写即 f = F
		int compareToIgnoreCase = sss.compareToIgnoreCase(sss1);

		// concat(String str) 连接两个字符串，和"+"类似
		// Java字符串连接效率比较之String.concat() 连接符+号 和StringBuilder类,
		// http://blog.csdn.net/lhy55040817/article/details/5456620
		String concat = sss.concat(sss1);
		String concat1 = sss + sss1;
		// equals(Object anObject) 用于比较两个对象的内容是否一样
		// equals = true 一样返回true
		boolean equals = concat.equals(concat1);

		// contains(CharSequence s)
		// A.contains（B） 检查A中有没有和B相似的片段 ，有 返回true
		String test = "123456";
		String test1 = "1";
		boolean contains = test.contains(test1);

		// contentEquals(CharSequence cs)
		// 我测试了几个值 得出的结论是A.contentEquals（B） 一样返回true
		// 和A.equals（B）应该是一样的，（只是通过几个值的测试推测出来的结论，有待进一步证实）
		String test2 = "123";
		String test3 = "123";
		boolean contentEquals = test2.contentEquals(test3);

		// contentEquals(StringBuffer sb) 和 contentEquals(CharSequence cs) 一样

		// copyValueOf(char[] data) 需要注意 这是一个静态方法
		// 将一个char 数组转换成一个string 输出，和Sting的构造方法 String(char[] value) 作用一样
		String test4 = null;
		char[] test5 = { '1', '2', '3', '4', 'a' };
		test4 = String.copyValueOf(test5);

		// copyValueOf(char[] data, int offset, int count) 需要注意 这是一个静态方法
		// 和 Sting的构造方法 String(char[] value, int offset, int count) 作用一样

		// endsWith(String suffix)
		// A.endwith(B) A 是不是以B 为后缀，是返回true。
		String test6 = "wodecsdn.blog";
		String test7 = "blog";
		boolean endsWith = test6.endsWith(test7);

		// equalsIgnoreCase(String anotherString) 和 compareToIgnoreCase(String
		// str)有点类似 忽略大小写，比较两个对象
		String test8 = "Blog";
		String test9 = "blog";
		boolean equalsIgnoreCase = test8.equalsIgnoreCase(test9);

                // format(Locale l, String format, Object... args)  注意这是一个静态方法
		// 感谢： http://blog.csdn.net/lonely_fireworks/article/details/7962171
		Date date = new Date();
		// b的使用，月份简称
		String str1 = String.format(Locale.ENGLISH, "ENGLISH月份简称：%tb", date);
		String str11 = String.format(Locale.CHINA, "CHINA月份简称：%tb", date);
		String str111 = String.format(Locale.CANADA, "CANADA月份简称：%tb", date);
		System.out.println(str1);
		System.out.println(str11);
		System.out.println(str111);
		// B的使用，月份全称
		str1 = String.format(Locale.US, "英文月份全称：%tB", date);
		System.out.println(str1);
		System.out.printf("本地月份全称：%tB%n", date); 

运行结果：

ENGLISH月份简称：Apr
CHINA月份简称：四月
CANADA月份简称：Apr
英文月份全称：April
本地月份全称：四月

// format(String format, Object... args)
		// 通过 format 格式化，并返回一个String对象
		String[] str = { "wode csdn blog", "欢迎进入:" };
		String f = "1%0$6s1 1%1$6s1 1%2$15s";
		String format = String.format(f, str[1], str[0]);
		System.out.println(format);

运行结果：1 欢迎进入:1 1 欢迎进入:1 1 wode csdn blog

有两点点不明白，第一个：%0和%1 为什么是一个？，第二个：6s和15s为什么间距一样？

求路过的大牛们指点。

// getBytes() 
		String str = "1234Aa";
		byte[] bytes = str.getBytes();
		for (int i = 0; i < bytes.length; i++) {
			System.out.print(bytes[i] + "\t");
		}

运行结果：49 50 51 52 65 97

		// getBytes(Charset charset)  和 getBytes(String charsetName) 类似
		String str = "我";
		byte[] bytes = str.getBytes(Charset.forName("utf-8"));
		for (int i = 0; i < bytes.length; i++) {
			System.out.print(bytes[i] + "\t");
		}

运行结果：-26 -120 -111

// getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
		// A.getChars（srcBegin，srcEnd，B， dstBegin ）
		// srcBegin srcEnd 指 A中的位置 从srcBegin到srcEnd-1这一段，替换掉从B[dstBegi]开始替换
		// 需要注意srcEnd >= srcBegin 并且 dstBegin +（srcEnd - srcBegin）<=B.length
		String str = "abcdef";
		char[] c = { '1', '2', '3', '4', '5' };
		str.getChars(1, 4, c, 0);
		System.out.print(str + "\t");
		System.out.print(String.valueOf(c) + "\t");

运行结果：abcdef bcd45

// hashCode() 返回此字符串的哈希码
		String str = "abcdef";
		int hashCode = str.hashCode();
		System.out.print(hashCode + "\t");

运行结果：-1424385949

// indexOf(int ch)
		// 根据ASCII码从str中查找有没有匹配的，
		// 如 ASCII码 97 是a, hashCode = 0,表示有匹配的，并且下标为0
		String str = "abcdef";
		int hashCode = str.indexOf(97);
		System.out.print(hashCode + "\t");

运行结果： 0

// indexOf(int ch, int fromIndex)
		// 根据ASCII码从str中查找有没有匹配的，
		// 如 ASCII码 97 是a, hashCode = 0,表示有匹配的，并且下标为0
		// fromIndex 表示从下标几开始，无上限
		String str = "abcdef";
		int hashCode = str.indexOf(97, 100);
		System.out.print(hashCode + "\t");

运行结果： -1

		// indexOf(String str) 和 indexOf(int ch)差不多
		// 区别就是参数变了
		String str = "abcdef";
		int hashCode = str.indexOf("c");
		System.out.print(hashCode + "\t");

运行结果： 2

	// indexOf(String str, int fromIndex) 和 indexOf(int ch, int fromIndex) 一样
		String str = "abcdef";
		int hashCode = str.indexOf("c",88);
		System.out.print(hashCode + "\t");

// intern()
		// 感谢： http://blog.csdn.net/lz12366007/article/details/4667313                                                                                                                                
		// isEmpty() 判断是否为空 根据api 的解释他只判断了长度为 0 的情况，
// 并没有判断 str = null 或者 str = " " 这两种情况为空
// str = null; str.isEmpty(); 会报错
String str = null;
boolean hashCode = str.isEmpty();
System.out.print(hashCode + "\t");

	// join(CharSequence delimiter, CharSequence... elements)
		// 使用 delimiter 连接 elements 的每一个对象，如果对象为null，则使用null填充原来的位置,
		// join (CharSequence delimiter, Iterable 
		// elements) 和这个类似
		String str = "/";
		String str1 = null;
		String hashCode = String.join(str, "aaa", str1, "c", "ddd");
		System.out.print(hashCode + "\t");

运行结果：aaa/null/c/ddd

// lastIndexOf(int ch) 和 lastIndexOf (int ch, int fromIndex)
		// indexOf (String ch) 和 indexOf ( String ch , int fromIndex)
		// lastIndexOf(int ch) 和 lastIndexOf (int ch, int fromIndex)
		// indexOf ( String ch ) 和 indexOf ( String ch , int fromIndex) 这几个很类似，
		// lastIndexOf (int ch, int fromIndex) 的 fromIndex api 的解释是 "searching
		// backward starting at the specified index." 我的理解是从 String[fromIndex]
		// string[0]搜索

length()  不再多说；

// matches(String regex) 正则验证
		String str1 = "bcdefa";
		boolean hashCode = str1.matches("[a-z]{6}");
		System.out.print(hashCode + "\t");

运行结果：

// offsetByCodePoints(int index, int codePointOffset)
		// 感谢： http://blog.csdn.net/afeiluo/article/details/38020305
		String str1 = "bcdefa";
		int hashCode = str1.offsetByCodePoints(0, str1.length());
		System.out.print(hashCode + "\t");

// regionMatches(boolean ignoreCase, int toffset, String other, int
		// ooffset, int len)
		// regionMatches(int toffset, String other, int ooffset, int len)
		// ignoreCase 为真忽略大小写，从str 下标为toffset开始，长度为len的字符串
		// 与从str1 下标为ooffset开始，长度为len的字符串 进行比较
		String str = "bcdefa1";
		String str1 = "1bcdefa";
		boolean regionMatches = str.regionMatches(false, 0, str1, 1,
				str.length() - 1);
		System.out.print(regionMatches + "\t");

// replace(CharSequence target, CharSequence replacement)
		// 上面这两个替换类似，将oldChar 或者target 替换成newChar 或者replacement
		// 下面这两个除了能实现上面两个的功能之外，还可以通过改变regex 参数完成上面两个无法完成的 
		// replaceAll(String regex, String replacement)
		// replaceFirst(String regex, String replacement)
		//	区别是 all 和 fist ，一个是改变全部， 一个是只改变第一次匹配成功的
		String str = "abcd dd aa";
		String replace = str.replace('a', 'A');
		String replace1 = str.replace("a", "A");
		String replace2 = str.replaceAll("[a-c]", "D");
		String replace3 = str.replaceFirst("d", "D");

		System.out.println("replace :" + replace);
		System.out.println("replace1 :" + replace1);
		System.out.println("replace2 :" + replace2);
		System.out.println("replace3 :" + replace3);

	// split(String regex, int limit)
		// regex 正则表达式或者一个字符串为分隔符，limit 表示分组的多少
		// 如果使用第一个方法分成6个字符串，limit 为5，使用第二个方法只会分成5个字符串
		// limit>=1 时生效
		String str = "zacbd";
		String[] split = str.split("[a-b]", 10);
		for (int i = 0; i < split.length; i++) {
			System.out.println(split[i] + i + "\t");
		}

// substring(int beginIndex)
		// str.substring(3) => bd
		// subSequence(int beginIndex, int endIndex)
		// substring(int beginIndex, int endIndex)
		// str.substring(0,str.length()) => zacbd
		// str.substring(1,2) => a
		String str = "zacbd";
		String split = str.substring(0, str.length());
		System.out.println(split + "\t");

// toCharArray()  将字符串转化成字符数组返回     
// toLowerCase() 将字符串中的字母全部转换成小写
// toString()   将字符串中的字母全部转换成大写
// toLowerCase(Locale locale)  locale 指定一种语言
// toUpperCase(Locale locale)
// toString()
// trim() 去除前后空格

valueOf(boolean b)
valueOf(char c)
valueOf(char[] data)
valueOf(double d)
valueOf(float f)
valueOf(int i)
valueOf(long l)
valueOf(Object obj)
以上都是静态方法，将参数转化成String 返回

valueOf(char[] data, int offset, int count)
将data[offset]开始，长度为count的字符数组转化成string

终