String与StringBuffer、数值包装类、自动装箱拆箱

1、     String类

String 类的最大特点是：一旦初始化就不能改变。例如：

String s = “abc”;这里的s可以改变指向，但是”abc”不能做任何改变。

String类的构造方法：

public String () 创建一个内容为空的字符串对象。

 Public String(Stringoriginal)创建一个内容为original的字符串对象。

public String(char[] value) 用字符数组创建字符串对象。

Public String(char[] value,int offset,int count)用字符数组的value[offset]至value[offset+count]创建字符串对象。

注意：

String s = new String(“good”);String s1 = newString(“good”);s!=s1因为s跟s1是两个不同的对象。

String s = “good”;String s2 = “good”; s1= s2;”good”是常量，被放在常量池中，在内存中只为它分配一次空间。

例如下面代码：

package HeimaLerning;

public class StringConDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
	
			stringConsDemo();
	}
	public static void stringConsDemo()
	{
		String s1= new String("good");
		String s2= new String("good");
		System.out.println(s1==s2);//false s1和s2是两个不同的对象
		System.out.println(s1.equals(s2));//String 类重写了Object中的equals()方法，改为比较两个
		//字符串的内容是否相同。
		
		char[] arr = {'w','i','u','l'};
		String s3 = new String(arr);//用字符数组建立字符串对象
		String s4 = new String(arr,1,3);//将arr[1}到arr[3]作为字符串内容。
		System.out.println(s3);
		System.out.println(s4);
		
		String s5= new String();
		String s6 = "";
		System.out.println(s5==s6);
		System.out.println(s5);
		System.out.println(s6);//内容相同。
		byte[] brr = {97,95,56,12,34};
		String s7 = new String(brr);
		System.out.println(s7);
		
	}
}

String主要方法：

 1,获取：

 1.1 获取字符串中字符的个数(长度).

 Int length();

 1.2 根据位置获取字符。

 charcharAt(intindex);

 1.3 根据字符获取在字符串中的第一次出现的位置.

 intindexOf(intch)

 intindexOf(intch,intfromIndex):从指定位置进行ch的查找第一次出现位置

 intindexOf(Stringstr);

 intindexOf(Stringstr,intfromIndex);

根据字符串获取在字符串中的第一次出现的位置.

 intlastIndexOf(intch)

 intlastIndexOf(intch,intfromIndex):从指定位置进行ch的查找第一次出现位置

 intlastIndexOf(String str);

 intlastIndexOf(String str,intfromIndex);

 1.4 获取字符串中一部分字符串。也叫子串.

 Stringsubstring(intbeginIndex, intendIndex)//包含begin不包含end。

 Stringsubstring(intbeginIndex);

 

 2，转换。

 2.1 将字符串变成字符串数组(字符串的切割)

 String[]  split(String regex):涉及到正则表达式.

 2.2 将字符串变成字符数组。

 char[]toCharArray();

 2.3 将字符串变成字节数组。

 byte[] getBytes();

2.4将字符串中的字母转成大小写。

StringtoUpperCase():大写

 StringtoLowerCase():小写

2.5  将字符串中的内容进行替换

String replace(char oldch,char newch);

 Stringreplace(String s1,String s2);

 2.6 将字符串两端的空格去除。

 String trim();

 2.7 将字符串进行连接。

 Stringconcat(string);

 

 3，判断

 3.1 两个字符串内容是否相同啊？

 booleanequals(Object obj);

 booleanequalsIgnoreCase(string str);忽略大写比较字符串内容。

 3.2 字符串中是否包含指定字符串？

 booleancontains(string str);

 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。

 booleanstartsWith(string);

*boolean endsWith(string);

4，替换

  String replace(oldchar,newchar);

5，切割

        String[] split(regex); 

6，子串。获取字符串中的一部分。

        String substring(begin);

        String substring(begin,end);

 7，转换，去除空格，比较。

        7.1 将字符串转成大写或则小写。

                   String toUpperCase();

                   String toLowerCase();

         7.2 将字符串两端的多个空格去除。

                  String trim(); 

        7.3 对两个字符串进行自然顺序的比较。

                  int compareTo(string);

String类练习题：

1、给定一个字符串数组，按照字典顺序进行从小到大的排序。

思路：（1）用选择或者冒泡都行。

     （2）比较字符串直接用compareTo(Stringstr)方法。

代码如下：

public static String[] sortString (String[] s)
	{
		String temp = null;
		for(int i  = 0;i<s.length;i++)
		{
			for(int j= i+1;j<s.length;j++)
			{
				if(s[i].compareTo(s[j])>0)
				{
					temp  = s[i];
					s[i]= s[j];
					s[j]= temp;
				}
					
			}
		}
		return s;
	}

 2，一个子串在整串中出现的次数。

思路：

 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。

 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，

 而剩余字符串的起始位是出现位置+子串的长度.

 3,以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录。

代码如下：

public static int countString (String str,String keyStr)
	{
		int num  = 0;
		
		int index =  -1;
		while((index = str.indexOf(keyStr))!= -1)
		{
			num++;
			str = str.substring(index+keyStr.length());
			
		}
		return num;
	}

3，两个字符串中最大相同的子串。

 

思路：

 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。

 如果存在，短的那个字符串就是最大子串。

 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。

如果存在就已找到，就不用在找了。

代码如下：

public static String maxSubString(String s1,String s2)
	{
		
		String max = (s1.length()>s2.length())?s1:s2;
		String min = (s1.length()>s2.length())?s2:s1;
		for(int i = 0;i<min.length();i++)
		{
			for(int prefix= 0, last= min.length()-i;last!=min.length()+1;prefix++,last++)
			{
				String sub = min.substring(prefix, last);
				if(max.contains(sub))
					return sub;
			}
		}
		return null;
	}

StringBuffer

 StringBuffer:就是字符串缓冲区。

 用于存储数据的容器。

 特点：

 1，长度的可变的。

 2，可以存储不同类型数据。

 3，最终要转成String进行使用。

 4，可以对字符串进行修改。

 

既然是一个容器对象。应该具备什么功能呢？

 1，添加：

 StringBufferappend(data);

 StringBufferinsert(index,data);

 2，删除：

 StringBufferdelete(start,end):包含头，不包含尾。

 StringBufferdeleteCharAt(int index):删除指定位置的元素

 3，查找：

 char charAt(index);

 intindexOf(string);

 intlastIndexOf(string);

 4，修改：

 StringBufferreplace(start,end,string);

 voidsetCharAt(index,char);

5、 反转：

StringBuffer reverse（）；

StringBuilder

 jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

 

 不同的是：

 StringBuffer是线程同步的。通常用于多线程。

 StringBuilder是线程不同步的。通常用于单线程。它的出现提高效率。

 

 

 jdk升级的三要素：

 1，简化书写。

 2，提高效率。

 3，增加安全性。

基本数据对象包装类

为了方便操作基本数据类型值，将其封装成了对象，是基本数据类型有了类的特性。

基本数据类型的包装类有：

 

 byte    Byte

 short   Short

 int     Integer

 long    Long

 float   Float

 double  Double

 char    Character

 Boolean Boolean

 该包装对象主要用基本类型和字符串之间的转换。

基本类型--->字符串

1,基本类型数值+""

 2,用String类中的静态方法valueOf(基本类型数值);

 3,用Integer的静态方法valueO(基本类型数值);

 字符串--->基本类型

 1,使用包装类中的静态方法xxxparseXxx("xxx类型的字符串");*****

 intparseInt("intstring");

 long parseLong("longstring");

 booleanparseBoolean("booleanstring");

 只有Character没有parse方法

 2,如果字符串被Integer进行对象的封装。

 可使用另一个非静态的方法，intValue();

 将一个Integer对象转成基本数据类型值。

自动拆箱与装箱

Jdk1.5之后java提供了对基本数据类型的自动装箱与拆箱功能。

例如：Integeri = 5;没有错误，java对基本数据int进行了自动的装箱，将其封装为Integer类型。

System.out.println(i)；也不会出错，java会将Integer自动拆箱为int型。