黑马程序员—String类与基本数据类型对象包装类

一、String类概念

String s1 = "abc"; //s1是一个类类型变量，"abc"是一个对象。字符串最大的特点：一旦被初始化就不可以被改变。

String s2 = new String("abc");  

//s1在内存中有两个对象。

//s2在内存中有一个对象。

System.out.println(s1.equals(s2));//String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。

String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。

二、对字符串的创建操作。

1.获取

1.1 字符串中包含的字符数，也就是字符串的长度。

int length():获取长度。

1.2 根据位置获取位置上的某个字符。

char charAt(int index):

1.3 根据字符获取该字符在字符串的位置。

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch, int fromIndex):从fromIndex指定的位置开始，获取ch在字符串中出现的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。

int indexOf(String str， fromIndex)：从fromIndex指定的位置开始，获取str在字符串中出现的位置。

2.判断

2.1 字符串中是否包含子串。

boolean contains(str);

特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。所以。也可以用于对指定判断是否包含。

if(str.indexOf("aa")! = -1) 该方法既可以判断，又可以获取出现的位置。

2.2 字符串是否有内容。

boolean isEmpty(str):原理就是判断长度是否为0.

2.3 字符串是否是以指定内容开头。

boolean startsWith(str);

2.4 字符串是否是以指定内容结尾。

boolean endsWith(str);

2.5 判断字符串内容是否相同，复写了Object类中的equals的方法。

boolean equals(str);

2.6 判断内容是否相同，并忽略大小写。

boolean equalsIgnoreCase(str);

3.转换

3.1 将字符数组转换成字符串。

构造函数：String(char[])

 String(char[],offset,count):将字符数组中的一部分转换成字符串。

静态方法：

 static String copyValueOf(char[]);

 static String copyValueOf(char[],data, int offset,int count);

 static String valueOf(char[]);

3.2 将字符串转成字符数组。**

char[] toCharArray();

3.3 将直接数组转换成字符串。

String(byte[]);

String(byte[],offset,count):将直接数组中的一部分转换成字符串。

3.4 将字符串转换成字节数组。

byte[] getByte();

3.5 将基本数据类型转换成字符串。

static String valueOf(int);

static String valueOf(double);

//3+"";//String.valueOf(3);

特殊：字符串和直接数组在转换过程中是可以指定编码表的。

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各种操演示：

class StringMethodDemo
{
	public static void method_6()
	{
		String s = "    Hello Java!       ";

		sop(s.tolowerCase());
		sop(s.toUpperCase());
		sop(s.trim());

		String s1 = "abc";
		String s2 = "def";

		sop(s1.compareTo(s2));
	}
	public static void method_sub()
	{
		String s = "abcdef";

		sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length());

	}
	public static void method_split()
	{
		String s = "zhansan,lisi,wangwu";
		String[] arr = s.split(",");
		for (int x=0;x<arr.length ; x++)
		{
			sop(arr[x]);	
		}
	}
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};

		String s = new String(arr,1,3);
		sop("s="+s);

		String s1 = "zxcvbnm";
		char[] chs = s1.toCharArray();

		for(int x=0; x<chs.length; x++)
		{
			sop("chs="+x)
		}

	}
	public static void method_is()
	{
		String str = "ArrayDemo.java";

		//判断文件名称是否是Array单词开头
		sop(str.startsWith("Array"));

		//判断文件名称是否是.Java的文件
		sop(str.endsWith(".java"));

		//判断文件名中是否包含Demo
		sop(str.conains("Demo"));
	}
	public static void method_get()
	{
		String str = "abcdefacgkmhhslholkdsncnkruohcbf";

		//长度
		sop(str.length());

		//根据索引获取字符
		sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException.

		//根据字符获取索引
		sop(str.indexOf('a',3));//如果没有找到返回-1。

		//反向索引字符出现的位置。
		sop(str.lastInddexOf(a));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class StringDemo
{
	public static void main(String[] args)
	{
		method_get();
		method_is();
		method_trans();
		method_split();
		method_sub();
		method_6();
	}
}

String练习：

/*
需求：获取两个字符串中最大相同子串。
"abcgjsldHelloWordgjisojisotjlkjr"
"hdHelloWordjuie"

思路：
	1.将短的那个字符串按照长度递减的方式获取到子串
	2.将获取到的子串在长的字符串中判断是否包含。
	3.如果不包含，继续寻找。如果包含，返回结果。
*/
class StringTest
{
	public static String getMaxSubString(String s1,String s2)
	{
		//判断字符串s1与s2哪个是长，哪个为短。
		String max = (s1.length()>s2.length())?s1:s2;
		String min = (max = s1)?s2:s1;
		
		for (int x = 0; x<min.length(); x++)
		{
			for (int y=0,z=min.length()-x;z!=min.length()+1;y++,z++ )
			{
				String temp = min.subString(y,z);	
				//System.out.println(temp);	
				
				//也可以使用：if(max.indexOf(temp)!=-1)
				if(max.contains(temp))
					return temp;
			}
			//如果没有找到返回空字符串
			return "";	
		}
	}
	
	public static void main(String[] args)
	{
		String s1 = "abcgjsldHelloWordgjisojisotjlkjr";
		String s2 = "hdHelloWordjuie";
		
		System.out.println("最大共同字符串为："+getMaxSubString(s1,s2));
	}
}

三、StringBuffer字符串缓冲区

StringBuffer是字符串缓冲区，是一个容器。
特点：

1.且长度是可以变化的。

2.可以操作多个数据类型，

3.最终会通过toString方法变成字符串。

功能：

1.存储

StringBuffer append();将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index,数据);可以将数据插入指定位置。

2.删除

StringBuffer delete(start,end);删除缓冲区中的数据，包含start，不包含end.

StringBuffer deleteCharAt(index);删除缓冲区中指定的部分。

3.获取

char charAt(int index);

int indexOf(String str);

int lastIndexOf(String str);

int length();

String substring(int start,int end);

4.修改

StringBuffer replace(int start,int end,String str);

void setCharAt(int index,char ch);

5.反转

StringBuffer reverse();

6.将缓冲区指定数据存到数组

void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

四、StringBuilder

JDK 1.5之后出现了StringBuilder.Java的升级就是为了提高效率，简化书写，提高安全性,StringBuilder的出现是为了提高效率。

StringBuffer是线程同步的。
StringBuilder是线程不同步的。

单线程开发建议使用StringBuilder.
将StringBuilder的实例用于多线程是不安全的。如果需要这样同步，则建议使用StringBuffer。

五、基本数据类型对象包装类

 将基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。下面我们来了解包装类的写法形式和常用方法。

1、基本数据类型对象包装类。

        byte                 Byte

        short                    Short
        int                             Integer
        long                         Long
        boolean                  Boolean
        float                         Float
        double                    Double

        char                        Character

2、基本数据类型转成字符串

基本数据类型+" "

基本数据类型.toString(基本数据类型值)；

如：Integer.toString(34);//将34整数变成"34"。

3、字符串转成基本数据类型。

xxx a=Xxx.parseXxx(string);//必须传入对应类型的字符串。

 如   inta=Integer.parseInt("123");//静态

booleanb=Boolean.parseBoolean("true");

Integeri=new Integer("123");

 intnum=i.intValue();//跟上面的静态方式的结果一样，但这种属于对象调用方式。

注意：

在使用时，Integer  x = null;上面的代码就会出现NullPointerException。

 
4、十进制转成其他进制。

toBinaryString();

toHexString(); 

toOctalString();

 
5、其他进制转成十进制。

parseInt(String,radix);

 如：int a= Intager.parseInt("3c",16);

JDK1.5版本以后出现的新特性：

 Integer x=new Integer(4);

等效于：Integer x=4;//自动装箱。

还可以直接进行运算：x=x+2;//x进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。x的拆箱动作等效：x.intValue()。

 
6、注意

Integer x=128;

Integer y=128;

x==y//false

Integer m=127;

Integer n=127;

m==n//true

原因:因为m和n指向了同一个Integer对象。因为当数值在byte范围内，对于新特性，如果该数组已经存在，则不会再开辟新的空间。