字符串，基本数据类型对象包装类

一、字符串

字符串可以分为两大类：String类, StringBuffer和StringBuilder

1.String类：创建之后不会再做修改和变动。

/*String类的三种构造函数演示*/
public class StringConstructorDemo {
	public static void main(String[] args){
		StringConstructorDemo();
	}
	public static void StringConstructorDemo(){
		String s = new String(); //等效于String s = "";不等效于String s = null;
		//构造函数： String(byte[] bytes)
		byte[] arr1 = {65, 66, 67, 68};
		String s1 = new String(arr1);
		System.out.println("s1 = " + s1); //s1 = ABCD
		//构造函数： String(char[] value)
		char[] arr2 = {'w', 'a', 'p', 'q', 'x'};
		String s2 = new String(arr2);
		System.out.println("s2 = " + s2); //s2 = wapqx
		//构造函数： String(char[] value, int offset, int count)
		String s3 = new String(arr2, 1, 3);
		System.out.println("s3 = " + s3); //s3 = apq
	}
}

String类的方法（按功能分）：
　　a.能创建并返回一个新的String对象实例: concat, replace,　replaceAll, substring, toLowerCase, toUpperCase, trim,toString.
　　b.查找: endsWith, startsWith, indexOf,，lastIndexOf.
　　c.比较: equals, equalsIgnoreCase,
　　d.字符及长度: charAt ，length.
　　Jdk1.5 增加了format函数： %序号$ 标识 宽度及精度 转换方式
　　String类的 matches, replaceAll, split可以使用正则表达式

public class StringMethodDemo {
	public static void main(String[] args){
		StringMethodDemo();
	}
	public static void StringMethodDemo(){
		String s = new String("abcdabe");
		System.out.println("length = "+s.length()); //获取字符串长度
		//查找
		System.out.println("char: "+s.charAt(2)); //根据位置获取字符
		System.out.println("index: "+s.indexOf('a')); //获取字符在字符串中第一次出现的位置
		System.out.println("index: "+s.indexOf('a', 1)); //从指定位置开始查找字符在剩余字符串中第一次出现的位置
		System.out.println("string: "+s.indexOf("ab")); //获取指定字符串在字符串中第一次出现的位置
		System.out.println("string: "+s.indexOf("ab", 2)); //从指定位置开始查找指定字符串在剩余字符串中第一次出现的位置
		System.out.println("lastIndex: " +s.lastIndexOf('a')); //获取字符在字符串中最后一次出现的位置
		//获取子串
		System.out.println("substring: " +s.substring(2)); 
		System.out.println("substring: " +s.substring(2,5)); //右端点取不到
		//转换
		String ss = "Amy. Lily. Henry";
		String[] arr = ss.split("\\."); //将字串变成字符串数组(切割)： String[] split(String regex)；
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i]);
		}
		System.out.println();
		char[] chs = ss.toCharArray(); //将字符串变成字符数组
		for(int i = 0; i < chs.length; i++){
			System.out.print(chs[i]);
		}
		System.out.println();
		byte[] bytes = ss.getBytes(); //将字符串变成字节数组
		for(int i = 0; i < bytes.length; i++){
			System.out.print(bytes[i]+" ");
		}
		System.out.println();
		System.out.println( "Abcde".toUpperCase()); //字符串中的字母转换成大写
		System.out.println( "aBCDE".toLowerCase()); //字符串中的字母转换成小写
		//替换
		String s1 = "Hello World";
		System.out.println(s1.replace('o', 'a')); //String replace(char oldCh,char newCh);
		System.out.println(s1.replace("llo", "y!")); //String replace(string oldStr,string newStr);
		//去除字符串两端空格
		System.out.println( "-" + "   ab   c   " .trim() + "-"); //String trim();
		//连接
		System.out.println( "I love ".concat("CS" )); //String concat(String str); 与"+"效果一致但效率更高
		//将其他类型数据转换成字符串
		System.out.println(String.valueOf(34)+1); 
		//判断
		System.out.println(s1.equalsIgnoreCase("HELLO WORLD")); //忽略大小写比较字符串内容
		System.out.println(s1.contains("llo")); //判断字符串中是否包含指定字符串
		System.out.println(s1.startsWith("He")); //字符串是否以指定字符串开头，结尾
		System.out.println(s1.endsWith("ld")); 
		//比较 int compareTo(String str);
		System.out.println("ab" .compareTo("A")); //按字典序比较，如果相等返回0.
		//返回字符串对象的规范化表示形式 String intern();
		String s2 = new String("abc");
		System.out.println(s2 == s2.intern()); //false (用equals(Object)方法判断)
	}
}

/*
 * 统计一个子串在整串中出现的次数
 */
public class StringTest{
	public static void main(String[] args){
		String str = "nbaernbatynbauinbaopnba";
		String key = "nba";
		int count = getKeyStringCount(str, key);
		System.out.println("count = "+count);
	}
	public static int getKeyStringCount(String str, String key){
		int count = 0;
		int index = 0;
		//用indexOf获取字串在字符串中出现的位置，如果找不到返回-1,跳出while循环
		while((index = str.indexOf(key))!=-1){
			//每找到一个字串，就把剩余字符串（substring（出现位置+子串的长度））赋给str变量，继续查找str。
			str = str.substring(index + key.length());
			count ++ ;
		}
		return count;
	}
}

/*获取两个字符串中最大相同的子串*/
public class StringTest2 {
	public static void main(String[] args){
		String s1 = "qwerabcdtyuiop";
		String s2 = "xcabcdvbn";
		String s =  getMaxSubstring(s1, s2);
		System.out.println("s = " + s);
	}
	public static String getMaxSubstring(String s1, String s2){
		String max = null, min = null;
		//max存入较长的字符串，min存入较短的字符串
		max = (s1.length() > s2.length())? s1:s2;
		min = max.equals(s1)? s2:s1;
		//将短的字符串依长度递减，每次递减都判断max中是否包含该长度的各种字串组合（通过a++，b++实现）。		
		for(int i = 0; i < min.length(); i ++){
			//a代表子串的开始位置，b代表子串的结束位置。
			for(int a = 0, b = min.length()-i; b != min.length()+1; a++,b++){
				String sub = min.substring(a,b); //获得子串
				if (max.contains(sub)) //判断max中是否包含子串
					return sub;
			}
		}
		return null;
	}
}

/*
 * 模拟一个trim功能方法，去除字符串两端的空白。
 */
public class StringTest3 {
	public static void main(String[] args){
		String s = "  ab   c   ";
		s = myTrim(s);
		System.out.println("-"+s+"-");
	}
	public static String myTrim(String s){
		int start = 0, end = s.length()-1;
		//从头开始判断字符是否是空格
		while(start <= end && s.charAt(start) == ' '){
				start++;
		}
		//从尾开始判断字符是否是空格
		while(start <= end && s.charAt(end) == ' '){
				end--;
		}
		return s.substring(start, end+1);
	}
}

/*
 * 将一个字符串翻转
 */
public class StringTest4 {
	public static void main(String[] args){
		String s = "Hello World";
		System.out.println("Before: "+ s);
		System.out.println("After: "+ reverseStr(s));
	}
	public static String reverseStr(String s){
		//将2字符串转换为字符数组，以便于交换
		char[] ch = s.toCharArray();
		//同时从头和尾开始遍历字符数组，交换头尾元素
		for(int start = 0, end = s.length()-1; start < end; start++, end--){
			char temp = ch[start];
			ch[start] = ch[end];
			ch[end] = temp;
		}
		//将字符数组转换为字符串
		return new String().valueOf(ch);
	}
}

2.StringBuffer和StringBuilder：创建之后允许再做更改和变化

StringBuffer类对象保存可修改的Unicode字符序列。在JDK1.5版本之后出现了　　StringBuilder，StringBuilder与StringBuffer类似，它效率更高，不考虑线程安全性。 　>　　StringBuffer：线程同步，有锁，效率低，用于但多线程
　　StringBuilder：线程不同步，无锁，效率高，用于单线程
　　下面详细说一说StringBuffer。
　　1）特点：a. 长度是可变的。（数组是固定长度）
　　　　　b. 可以存储不同类型数据。（数组只能操作一种类型）
　　　　　c. 最终要转成字符串进行使用。
　　2）构造方法
　　StringBuffer()
　　StringBuffer(int capacity)
　　StringBuffer(String initialString)

3）StringBuffer类的方法：append, insert, reverse, setCharAt, setLength

public class bufferMethodDemo {
	public static void main(String[] args){
		bufferMethod();
	}
	public static void bufferMethod(){
		StringBuffer sb = new StringBuffer();
		//添加
		sb.append(4).append(5);
		sb.insert(1,"numbernumber");
		System.out.println(sb);
		//删除
		sb.delete(1,3); //StringBuffer delete(int start,int end):删除[start,end)元素
		sb.deleteCharAt(2); //StringBuffer deleteCharAt(int index):删除指定位置的元素。
		System.out.println(sb);
		//查找
		System.out.println(sb.charAt(3)); //char charAt(int index); 查找角标为index的字符
		System.out.println(sb.indexOf("er")); //int indexO(String str); 查找字符串str首次出现的位置
		System.out.println(sb.lastIndexOf("er")); //int lastIndexOf(String str); 查找字符串str最后一次出现的位置
		//修改
		sb.replace(0, 3, "reqlace"); //StringBuffer replace(int start,int end,String str);
		System.out.println(sb);
		sb.setCharAt(2, 'p');
		System.out.println(sb); //void setCharAt(int index,char ch);
		//设置、获取长度
		//setLength:若小于其长度，则清除缓冲区中的一部分。若大于其长度，则扩充缓冲区，扩充部分空格填充。
		//当创建的StringBuffer内容长度大于16，会创建一个新数组，长度比旧数组要长。把旧数组的内容拷贝到新数组。
		sb.setLength(7); 
		System.out.println(sb+"--Length: "+sb.length()); 
		//反转
		System.out.println(sb.reverse());
	}
}

/*
 * 实例：将一个int数组变成字符串
 */
public class StringBuilderTest {
	public static void main(String[] args){
		int[] arr = {3, 1, 5, 4, 6};
		String s = arrayToString(arr);
		System.out.println(s);
	}
	public static String arrayToString(int[] arr){
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for(int i = 0; i < arr.length; i++){
			if(i != arr.length-1)
				sb.append(arr[i]).append(",");
			else
				sb.append(arr[i]).append("]");
		}
		return sb.toString();
	}
}

4)扩充知识　
　　java.util.StringTokenizer类提供了对字符串进行分割的功能。
　　构造：StringTokenizer(String str, String delim);
　　该类的重要方法有：
　　　　public int countTokens()；// 分割串的个数
　　　　public boolean hasMoreTokens()；// 是否还有分割串
　　　　public String nextToken()；// 得到下一分割串

二、基本数据类型对象包装类
1.概述

Java的基本数据类型用于定义简单的变量和属性将十分方便，但为了与面向对象的环境一致，Java中提供了基本数据类型的包装类（wrapper），它们是这些基本类型的面向对象的代表。
　　与8种基本数据类型相对应，基本数据类型的包装类也有8种，分别是：Character，Byte，Short，Integer，Long，Float，Double，Boolean。

2.特点

1）这些类都提供了一些常数：如Integer.MAX_VALUE（整数最大值）， Double.NaN(非数字)，Double.POSITIVE_INFINITY（正无穷）等。
2）提供了valueOf(String)，toString()：用于从字符串转换及或转换成字符串。
3）通过xxxxValue()方法可以得到所包装的值：如Integer对象的intValue()方法。
4）对象中所包装的值是不可改变的（immutable）。要改变对象中的值只有重新生成新的对象。
5）toString(), equals()等方法进行了覆盖。

6. 除了以上特点外，有的类还提供了一些实用的方法以方便操作。例如，Double类就提供了parseDouble(), max, min方法等。

3.用途

主要用于基本类型和字符串之间的转换，其次就是十进制的转换。
1）基本类型–>字符串
　　a. 基本类型数值+""
　　b. 基本数据类型.toString(基本类型数值);
2）字符串–>基本类型
　　a. 使用包装类中的静态方法xxx parseXxx(“xxx”);
　　int parseInt(String str);
　　long parseLong(String str);
　　boolean parseBoolean(String str);
　　只有Character没有parse方法。
　　b. 如果字符串被Integer进行对象的封装，可使用另一个非静态的方法，intValue。
将一个Integer对象转成基本数据类型值。
　　c. 用Integer的静态方法valueOf(String s);
3)十进制–>其他进制
　　String toBinaryString(int i);
　　String toOctalString(int i);
　　String toHexString(int i);
　　String toString(int i,int radix);
4）其他进制–>十进制
　　int parseInt(String s, int radix);

public class WrapperDemo {
	public static void main(String[] args){
		//整型最大值
		System.out.println(Integer.MAX_VALUE); //2147483647
		//基本类型-->字符串
		Integer i = new Integer(5);
		System.out.println(i+"");
		System.out.println(Integer.toString(12));
		//字符串-->基本类型
		Integer ii = new Integer("123");
		System.out.println(ii.intValue()); //123
		System.out.println(Integer.parseInt("123")+1); //124
		System.out.println(Long.parseLong("123456789012345678")+1); //123456789012345679
		System.out.println(Boolean.parseBoolean("true")); //true
		System.out.println(Integer.parseInt("123")+1); //124
		//十进制-->其他进制
		System.out.println(Integer.toBinaryString(60)); //111100
		System.out.println(Integer.toOctalString(60)); //74
		System.out.println(Integer.toHexString(60)); //3c
		System.out.println(Integer.toString(60, 16)); //3c
		
	}
}

/*
 * 对一个字符串中的数值进行从小到大的排序
 */
import java.util.Arrays;
public class WrapperTest {
	private static final String SPACE_SEPARATOR = " ";
	public static void main(String[] args){
		String numStr = "20 79 9 -7 88 36 29";
		System.out.println(numStr);
		System.out.println(sortNumStr(numStr));
	}
	public static String sortNumStr(String numStr){
		//将字符串变成字符数组
		String[] str_arr = stringToArray(numStr);
		//将字符串数组变成int数组
		int[] num_arr = toIntArray(str_arr);
		//对int数组排序
		mySortArray(num_arr);
		//将排序后的int数组变成字符串
		String finalStr = arrayToString(num_arr);
		return finalStr;
	}
	public static String[] stringToArray(String numStr){
		String[] str_arr = numStr.split(SPACE_SEPARATOR);
		return str_arr;
	}
	public static int[] toIntArray(String[] str_arr){
		int[] num_arr = new int[str_arr.length];
		for(int i = 0; i < str_arr.length; i++){
			num_arr[i]=Integer.parseInt(str_arr[i]);
		}
		return num_arr;
	}
	public static void mySortArray(int[] num_arr){
		Arrays.sort(num_arr);
	}
	public static String arrayToString(int[] num_arr){
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < num_arr.length; i++){
			if(i != num_arr.length-1)
				sb.append(num_arr[i]+SPACE_SEPARATOR);
			else
				sb.append(num_arr[i]);
		}
		return sb.toString();
	}
}