黑马程序员--java基础复习之String类StringBuffer及基本数据类型包装类

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

字符串，是我们平时接触最多的，正如我此刻正在通过键盘敲字一样，就是在文本输入框中输入字符串。包括我们平时用QQ等交流工具，以及在百度谷歌中输入关键字，等操作的都是字符串。那么，在JAVA中，是如何定义字符串和操作它呢？

根据JAVA中万物皆对象的思想，我们也将 字符串看作是一个特殊的对象。这个对象一旦初始化就不能改变。

看到这里，也许很多小伙伴也和我第一次一样，都惊呆了。。。。。

因为我们平时在使用的时候，都会这样：

String a="abc";
a="def";

这不就改变了么，怎么会叫一旦初始化就不能改变呢？听我慢慢道来

在java中将字符串看作一个对象，那么其类型String就是一个类，String类。

那么，"abc"就是一个对象，根据我们前面学习的，引用型变量a指向"abc"在堆内存的地址。

当a="def"时，是将对象"def"在内存中的地址值赋给引用型变量a，即a不再指向"abc"。

String s1="abc";
		
String s2=new String("abc");

 上面两句代码中，s1和s2有什么区别吗？

s1和s2的区别：

s1在内存中有一个对象，即"abc"

s2在内存中有两个对象，即new String()  和"abc"

String类代表字符串，java程序中的所有字符串字面值(如"abc")都作为此类的实例实现。

再看一下面这段代码：

<span style="white-space:pre">		</span>String s1="abc";		
		String s2=new String("abc");
				
		System.out.println(s1==s2);//结果为false   比较的是地址值，两者指向不同的对象，所以为false
		System.out.println(s1.equals(s2));//结果为true   String类复写了Object类中equals方法，该方法用于判断字符串是否相同

从上面可以看出

1、s1和s2分别指向两个不同的对象。

2、String类复写了Object类中的equals方法，使其用于判断字符串的面值是否相同

再看下一段代码：

		String s1="abc";		
		
		String s3="abc";		
		System.out.println(s1==s3);

结 果为true  。疑惑：按刚才上面的理解，s1和s3应该是分别指向不同的对象，所以结果应该是false 才对。这里为何是true呢？

原因，"abc"为一个常量，因为它初始化后不可改变，所以它存放位置不是在堆内存中，而是在常量池中。为了节省空间，当在定义s3时，在常量池中已经存在了，所以s3直接指向“abc”，所以s1和s2指向的是同一个对象。

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在字符串中第一次出现的位置

1、4 int indexOf(String ch):返回的是字符串ch在字符串中第一次出现的位置
int indexOf(String ch,int fromIndex):从fromIndex指定位置开始获取字符串ch在字符串中第一次出现的位置
int lastIndexOf(int ch)|int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String ch)  |int lastIndexOf(String ch,int fromIndex)

方法示例：

class StringMethodTest
{
	public static void method_get()
	{
		 String str="adfhghj";	
		 sop("原字符串："+str);
		 //获取长度
		 sop("方法：length():"+str.length());
		 //根据索引获取字符
		 sop("方法：charAt(4):"+str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException
		 //根据字符获取索引
		 sop("方法:indexOf('g',2):"+str.indexOf('g',2));//若没有找到，则返回-1
		 
	}
			
	public static void main(String[] args)
	{
		method_get();
				
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

结果：
 
2、判断
2、1 字符串中是否包含某一个子串
boolean contains(String str)
特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1。表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
eg:if(str.indexOf("aa")!=-1) 则包含。即可以判断，又可获取所在位置
2、2 字符串中是否有内容
boolean isEmpty()  原理就是判断长度length()是否为0
2、3 字符串是否是以指定内容开头
boolean startsWith(String str)
2、4 字符串是否是以指定内容结尾
boolean endsWith(String str)
2、5 判断字符串内容是否相同。复写了Object中的equals方法
boolean equals(str);
2、6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

代码示例：

public static void method_Is()
	{
	    String str="ArrayDemo.java";
		sop(str.startsWith("Array"));
		sop(str.endsWith(".java"));
		sop(str.contains("Demo"));
	}

结果：

3、转换
3、1 将字符数组转成字符串
构造函数：String(char[] ch) 将字符数组转成字符串
String(char[],int offset,int cout);将字符数组中的一部分转成字符串
静态方法:static String copyValueOf()
static String valueOf(char[])
3、2 将字符串转成字符数组
char[] toCharArray();
3、2 将字节数组转成字符串
String(byte[])
3、4 将字符串转成字节数组
byte[] getBytes();
3、5 将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)

特殊：字符串和字节数组在转换过程中，是可以指定编码表

看一个实例：

class StringMethodTest
{
	public static void main(String[] args)
	{
		
		sop("("+myReverse(" df ss ")+")");
		sop("("+myReverse(" df ss ",2,4)+")");
	
	}
				
	
	//练习，将字符串中的某两个位置间的字符反转(含头不含尾)
	public static String myReverse(String str,int x,int y)
	{
		//字符串变成字符数组
		char[] ch=str.toCharArray();
		//反转数组
		reverse(ch,x,y);
		//将数组变成字符串
		return new String(ch);
	}
	
	//练习二，将字符串反转
	public static String myReverse(String str)
	{
		/*******方式一******
		if(str!=null)
		{
			char[] ch=new char[str.length()];
			int j=0;
			for(int i=str.length()-1;i>=0;i--)
			{
				ch[j]=str.charAt(i);
				j++;
			}
			
			return new String(ch);
		}
		return null;
		*/
		/*****************方式二******************/
		//思路：
		//1、将字符串变成数组
		//2、对数组反转
		//3、将数组变成字符串
		
		//字符串变成字符数组
		char[] ch=str.toCharArray();
		//反转数组
		reverse(ch,0,ch.length);
		//将数组变成字符串
		return new String(ch);
		
		/***********方式三****************/
		//return myReverse(str,0,str.length());
		
	}
	//反转数组
	public static void reverse(char[] arr,int x,int y)
	{
		for(int start=x,end=y-1;start<end;start++,end--)
		{
			//数组中两个元素互换位置
			swap(arr,start,end);
		}
	}
	
	//数组中的两个元素位置互换
	public static void swap(char[] arr,int x,int y)
	{
		char temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;
	}
		
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

4、替换
String replace(char oldchar,char newchar)
String replace(char oldString,char newString)

应用实例：

class StringMethodTest
{				
	
	public static void method_replace()
	{
		String s="hello java";
		String s1=s.replace('a','n');
		
		String s2=s.replace("java","world");//将java替换为world
		sop(s);
		sop(s1);
		sop(s2);
	}		
	
	public static void main(String[] args)
	{		
		method_replace();
		
	}
	
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

5、切割
String[] split();

	public static void method_split()
	{
		String s="zs,ls,ww,zl";
		String[] arr=s.split(",");
		
		for(int x=0;x<arr.length;x++)
		{
			sop(arr[x]);
		}
	}

结果：

6、子串
String substring(int begin);//从指定位置开始到结尾,如果角标不存在，会出现字符串角标越界异常
String substring(int begin,int end);//从指定位置到另一个指定位置，包含头不包含尾

如下：

	public static void method_sub()
	{
		String s="asfafasd";
		sop(s.substring(2));
		sop(s.substring(2,3));
	}

7、转换
7、1 将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();

7、2 将字符串两端的多个空格去除
String trim()
7、3 对两个字符串进行自然顺序的比较
int compartTo(String)

public static void method_7()
	{
		String str="   hello JAVA ";
		sop(str.toUpperCase());//转成大写
		sop(str.toLowerCase());//转成小写
		sop(str.trim());//将字符串两端的多个空格去除
	}

结果：

看下面的例子：

class StringMethodTest
{
	public static void main(String[] args)
	{		
		sop(getMaxSubString("ddajavaklldadf","adfjavad"));		
		
	}
	
	//获取两个字符串中最大相同子串。
	//思路：
	//1、将短的那个子串按照长度递减的方式获取到。
	//2、将每次获取到的子串去长串中判断是否包含，如果包含，则找到
	public static String getMaxSubString(String str,String key)
	{
		//外循环为循环次数
		for(int x=0;x<key.length();x++)
		{
			//子串从最长长度开始
			for(int y=0,z=key.length()-x;z!=key.length()+1;y++,z++)
			{			
				String temp=key.substring(y,z);
				if(str.contains(temp))
					return temp;
			}
		}
		return "";
	}		
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

StringBuffer

StringBuffer 是字符串缓冲区
是一个容器
特点：
1、长度是可变化的。
2、可以直接操作多个数据类型
3、最终会通过toString方法变成字符串

什么时候使用StringBuffer?

当数据类型不确定，个数不确定，最终要变成字符串的时候可以用缓冲区StringBuffer

1、存储
StringBuffer append();将指定的数据作为参数，添加到已有数据的结尾处。
StringBuffer insert(int index,数据):可以将数据插入指定index位置

2、删除
StringBuffer delete(start,end);删除缓冲区中的数据，含头不含尾
StringBuffer deleteCharAt(index);删除指定位置的字符
3、获取
   char charAt();
   int indexOf(char ch);
   int lastIndexOf(char ch);
   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)

class StringBufferDemo
{
	public static void main(String[] args)
	{
		//add();
		//new StringBufferDemo().method_Del();
		//method_update();
		method_getChars();
	}
	
	public static void method_getChars()
	{
		StringBuffer sb=new StringBuffer("adfrgrf");
		char[] chs=new char[6];
		sb.getChars(1,4,chs,1);
		
		for(int x=0;x<chs.length;x++)
		{
			sop("chs["+x+"]="+chs[x]);
		}
	}
	
	//修改
	public static void method_update()
	{
		StringBuffer sb=new StringBuffer("asdfdf");
		//替换
		sb.replace(1,3,"java");
		sop(sb);
		//修改指定位置的字符
		sb.setCharAt(2,'q');
		sop(sb);
	}
	
	//删除
	public void method_Del()
	{
		StringBuffer sb=new StringBuffer("abcdefghijklmn");
		sop(sb);
		//删除
		sb.delete(2,4);
		sop(sb);
		//删除指定位置的字符
		sb.deleteCharAt(2);//sb.delete(2,3);
		sop(sb);
		//清空
		sb.delete(0,sb.length());
		sop(sb);
		
	}
	
	//添加
	public static void add()
	{
		StringBuffer sb=new StringBuffer();
		sb.append("af").append(true).append(23);
		sop(sb);
		//向StringBuffer中指定位置插入字符串
		sb.insert(2,"www");
		sop(sb);
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

在JDK1.5版本之后出现了StringBuffer。
StringBuffer是线程同步，多线程时使用
StringBuilder是线程不同步的 ，单线程时使用

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

以后开发建议使用StringBuilder

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

byte  Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character


基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。

基本数据类型转字符串
基本数据类型+""
基本数据类型.toString(基本数据类型值)

eg:Integer.toString(34);//将34整数变成"34"

字符串转成基本数据类型
方式一：
    Integer.parseInt("123");
xxx a=Xxx.parseXss("数据");

方式二：
Integer i=new Integer("123");
int num=i.intValue();

十进制转成其他进制
toBinaryString();  二进制
toHexString();  十六进制
toOctalString(); 八进制

其他进制转成十进制
static int parseInt()

实例代码：

class IntegerDemo
{
	public static void main(String[] args)
	{		
		trans();
	}
	
	public static void trans()
	{
		//十进制转十六进制
		sop(Integer.toHexString(60));
		//十进制转二进制
		sop(Integer.toBinaryString(-6));
		//十进制转八进制		
		sop(Integer.toOctalString(50));
		
		int x=Integer.parseInt("110",2);//将数据转换成指定进制，默认是十进制
		sop(x);
		sop(Integer.parseInt("3c",16));/<span style="font-family: Arial, Helvetica, sans-serif;">/将数据转换成十六进制</span>

		
	}
	
	//打印
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

结果：