黑马程序员 笔记（十二）——String、StringBuffer、StringBulider

　　------- android培训、java培训、期待与您交流！ ----------

String类

String类适用与描述字符串事物，像我们在生活中发送的短信、QQ消息都是字符串。我们学习字符串最主要学习的是字符串的特性（一旦被初始化就不可被改变）以及其方法的使用。

概述

概念：

字符串是一个特殊的对象，字符串一旦初始化，就不可以被改变
在Java中，描述字符串在java.lang包中String类。被final修饰。

Java中字符串的基本认识：

String s1 = "abc"; s1是一个类类型变量，s1指向的对象可以改变，但是这个字符串一旦被初始化就不可改变。意思就是说s1可以指向另一个字符串对象，但是原有的字符串对象不可改变。
字符串在内存中是

String s1 = new String("abc")和String s2 = "abc"的区别

String s1 = new String("abc")创建的是两个对象

String s2 = "abc"创建的是一个对象。

String类中equals方法：

String类复写了Object类中equals方法，在String类中equals的比较方式与内存地址无关。因为该类复写了hashCode方法，返回的不再是内存地址值。

常见的操作：

获取

获取字符串的长度： int length();
根据位置获取某个位置上的某个字符。 char charAt(int index);
根据字符获取该字符在字符串中的位置（第一次出现的位置）： int indexof(int ch);

从指定位置开始，获取字符在字符串中出现的位置： int indexof(int ch,int fromIndex);
字符串在字符串中第一次出现的位置（如果不存在则返回负数）： int indexOf(Sting str)
字符串在字符串中从指定位置开始第一次出现的位置:
int intdexof(Sting str,int fromIndex);
以上这些方法还有反向查找int lastIndexof(int ch); int lastIntdexof(int ch,int fromIndex); int lastIndexOf(Sting str)； int
lastIntdexof(Sting str,int fromIndex);使用方式一样，只是检索的方向是从右到左。

判断

字符串中是否包含某一个字串： boolean contains(String str)

indexOf(String str)用于判断指定字符串在已有字符串中的位置，如果返回为-1则说明，该串不存在。所以indexOf(String str)也可以用来判断是否包含指定字符串。

字符串中是否有内容(原理：判断字符串的长度是否为0): boolean ifEmpty()
字符串是否是一指定内容开头： boolean startsWith(String str)
字符串是否是一指定内容结尾（用于判断文件类型）： boolean endsWith(String str)
判断字符串的内容是否相同：boolean equals(String str)
判断内容是否相同，并忽略大小写： boolean equalsIgnoreCase(String str)

常见功能：
转换：

将字符串转成大写或小写

转换成大写 String toUpperCase()
转化成小写 String toLowerCase()

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

通过构造函数String(char[])可知在开始的时候可以将字符数组转成字符串。
通过构造函数String(char[] value, int offset, int count)可知在开始时可以将字符数组从指定位置开始选取指定的长度，组成一个字符串。
静态方法 static String copyValueof(char[]) 调用方法将字符数组转成字符串。
静态方法 static String copyValueof(char[] data, int offset, int count) 调用方法将字符数组从指定位置开始选取指定的长度，组成一个字符串。

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

通过构造函数String(byte[])可知在开始的时候可以将字节数组转成字符串
通过构造函数String(byte[] value, int offset, int count)可知在开始时可以将字节数组从指定位置开始选取指定的长度，组成一个字符串

将字符串转换成字符数组

char[] toCharArray()

将字符串转换成字节数组

byte[] getBytes();
特殊：字符串和字节数组的转换过程中，是可以指定编码表的。

将基本类型数据转化成字符串

static String valueOf(int)
static String valueOf(double)

切割和替换

替换

替换字符串中的字符:String replace(oldchar,newchar);如果替换的字符不存在返回的是原字符串。
替换字符串：String replace(CharSequence target,CharSequence replacement)

切割

在字符串中在指定的地方切割 String[] split(String regex)
获取字符串的子串,从指定地方开始到结尾 String substring(begin)
获取字符串的子串,从指定地方开始到指定位置结束 String substring(begin，end)包含头不包含尾

比较和去除空格

去除空格

去除两端的空格： String trim();

比较

对两个字符串进行自然顺序的比较 int compareTo(Sting str) 大于返回正数，小于返回负数，相等返回0

以上所有功能的代码演示：

class StringDemo
{
public static void main(String[] args)
{
String s1 = "  abcabc frggh  ";
String s2 = new String("  abcabc frggh  ");
String s3 = "  abcabc frggh  ";
String s4 = "  ABCABC frggh  ";

char[] s5 = {'a','b','c','a','b','c'};

//获取

//获取字符串的长度
sop("字符串s1的长度是"+s1.length());
//获取字符串中指定位置上的字符
sop("在字符串s1中角标为2的元素是"+s1.charAt(2));
//获取一个字符在字符串中的位置，接收的该字符的ASCII码值
sop("在字符串s1中ASCII码为98的字符的位置是"+s1.indexOf(98));
//从制定位置开始获取字符串的位置。
sop("在字符串s1中ASCII码为98的字符从第二位开始的位置是"+s1.indexOf(98,2));
//获取一个字符串在字符串中的位置，接收的该字符的ASCII码值
sop("在字符串s1中字符串ab开始的角标是"+s1.indexOf("ab"));
//获取一个字符串从指定位置开始查找，在字符串s1中的位置，接收的该字符的ASCII码值
sop("在字符串s1中字符串ab从第1位开始的角标是"+s1.indexOf("aeb",1));
//反向查找
sop("反向索引"+s1.lastIndexOf('a'));

//判断
//判读字符串是否以指定字符串开始
sop("字符串s1是否是以字符串ab开始:"+s1.startsWith("ab"));
//字符串是否以指定字符串结束
sop("字符串s1是否以abc结束"+s1.endsWith("abc"));
//判断字符串是否为空
sop("判断字符串s1是否为空"+s1.isEmpty());
//判断字符串中是否包含指定字符串
sop("判断字符串s1是否包含ca:"+s1.contains("ca"));
//判断两个字符串的内容是否相同
sop("判断两个字符串的内容是否相同"+s1.equals(s2));
//忽略大小写比较两个字符串中的内容是否相同
sop("忽略大小写比较两个字符串中s1和s4的内容是否相同"+s1.equalsIgnoreCase(s4));

//转换
//通过构造方法将字符数组s5转换成字符串
sop("通过构造方法将字符数组s5转换成字符串"+new String(s5));
//从指定位置开始，指定长度，把选中的转成字符串
sop("通过构造方法,从指定位置开始，指定长度，把选中的转成字符串"+new String(s5,2,2));
//通过静态方法copyValueOf()将指定字符数组转换成字符串
sop("通过静态方法copyValueOf():"+String.copyValueOf(s5));
//将基本类型3转化成字符串
sop("将基本类型3转化成字符串:"+String.valueOf(3));
//"将字符串s1转化成字符数组:"
soparr(s1.toCharArray());

//替换
//将字符串s1中的a字符替换成h字符
sop("将字符串s1中的a字符替换成h字符"+s1.replace('a','h'));
//将字符串中的指定字符串替换成指定字符串
sop("将字符串s1中的“ca”字符串替换成hm: "+s1.replace("ca","hm"));

//切割

soparr(s1.split("c"));//将字符串在指定位置切割

//子串
sop(s1.substring(1));//获取从指定位置开始一直到结束的子串
sop(s1.substring(1,3));//获取从指定位置开始到指定位置的子串

//转化成大小写

sop("将s1的字符全部转化为大写"+s1.toUpperCase());
sop("将s1的字符全部转化为小写写"+s1.toLowerCase());

//去除空格
sop("去除字符串中的空格"+s1.trim());

//比较
sop(s1.compareTo(s2));//比较两个字符串的大小（ASCII码值）
}

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

public static void soparr(char[] arr)//打印字符数组
{
for (int i=0;i<arr.length ;++i )
{
if(i==0)
System.out.print("数组是：{"+arr[i]+",");
else if(i==arr.length-1)
System.out.println(arr[i]+"}");
else
System.out.print(arr[i]+",");
}
}

public static void soparr(String[] arr)//打印字符串数组
{
for (int i=0;i<arr.length ;++i )
{
if(i==0)
System.out.print("数组是：{"+arr[i]+",");
else if(i==arr.length-1)
System.out.println(arr[i]+"}");
else
System.out.print(arr[i]+",");
}
}
}

[align=left]StringBuffer[/align]
[align=left]StringBuffer是字符串缓冲区，是一个容器。而且长度是可变的。可以添加任意类型。最终通过toString()方法，变成字符串。在操作结束后不会返回新的字符串，只是在原有的容器内操作。[/align]

StringBuffer的特点：

长度可以变化。
可以操作多个数据类型。
最终会通过toString方法变成字符串。

基本操作

存贮

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

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

删除

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

StringBuffer deleteCharAt(index):删除指定位置的字符。

获取

char charAt(int index) 获取角标Index的字符。

int indexOf(String str)获取字符串str的角标位置。

int lastIndexOf(String str) 逆向查找。获取字符串str的角标位置。

int length() 获取StringBuffer的长度。

String substring(int start, int end) 获取一个字串，从start角标开始，从end角标结束。

修改

StringBuffer replace(start,end,string);将start角标开始一直到end角标结束，替换成String。

void setCharAt(int index, char ch) ;替换单个字符。没有返回值，仅仅是修改

反转：

St将缓冲区中指定数据存储到指定字符数组中ringBuffer reverse();将此字符序列用其反转形式取代。

将缓冲区中指定数据存储到指定字符数组中

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组

dst

以上基本功能的演示：

class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer("abcdefghijk");

//添加
//在StringBuffer后添加
sop(sb1.append("你好"));
//在指定位置，插入指定数据
sop(sb1.insert(0,"Zhang,Hongmei"));

//删除
//从指定位置开始，删除指定长度
sop(sb1.delete(0,6));
sop(sb2.deleteCharAt(2));

//获取
//获取指定字符串在该容器中的位置
sop(sb1.indexOf("Hongmei"));
//获取指定位置上字符
sop(sb1.charAt(2));

//修改（在原来的容器里面修改）
//把指定范围内的字符替换成指定字符
sop(sb2.replace(0,3,"Zhang,Hongmei"));
//将某个位置的字符替换成指定字符
sb2.setCharAt(1,'$');
sop(sb2);

//反转
//将容器里的元素反转
sop(sb2.reverse());

//将缓冲区里的数据，存到指定的字符数组里
char[] sb3 = new char[3];
sb2.getChars(1,4,sb3,0);
soparr(sb3);

}

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

public static void soparr(char[] arr)//打印字符数组
{
for (int i=0;i<arr.length ;++i )
{
if(i==0)
System.out.print("数组是：{"+arr[i]+",");
else if(i==arr.length-1)
System.out.println(arr[i]+"}");
else
System.out.print(arr[i]+",");
}
}
}

StringBuilder
在JDK1.5版本之后出现了StringBuilder,与StringBuffer兼容。但是

StringBuilder：是线程不同步的，但是提高了执行效率
StringBuffer：是线程同步的，但是执行效率不高。在开发时，如果是单线程使用StringBuilder

基本数据类型对象包装类
基本数据类型包装类是按照面向对象的思想讲基本数据类型封装成了对象。这样可以通过对象中的属性和行为操作基本数据类型。也可以实现基本数据类型和字符串之间的转换

基本数据类型与对应的包装类

基本数据类型		包装类
byte<--------------->Byte
short<-------------->Short
int<---------------->Integer
long<--------------->Long
boolean<------------>Boolean
double<------------->Double
char<--------------->Character

基本数据类型包装类的作用 （以int的封装类Integer为例）

用于基本数据类型和字符串类型之间的做转换
字符串转成字符串

基本数据类型转成字符串：

方式一：基本数据类型+""
方式二：基本数据类型.toString(基本数据类型值)；

示例：

class  IntegerDemo
{
public static void main(String[] args)
{
sop(Integer.toString(231));
}

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

}

字符串转化成基本数据类型：

格式：xxx a = XXX.parseXxx(String) 以下一Integer为例。（char的不能用此格式转化）

通过int parseInt()方法：

示例

class  IntegerDemo
{
public static void main(String[] args)
{
int num = Integer.parseInt("256");
sop(num+100);
}

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

}

通过int intValue()方法

class  IntegerDemo
{
public static void main(String[] args)
{
Integer a = new Integer("35");
sop(a.intValue());
}

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

1.5版本后的新特性：

自动装箱：Integer a = new Integer(4);可以简化的写成 Integer a = 4;
自动拆箱：Integer a = 4;之后，a可以直接用来运算x = x +2;.

此时先进行的是拆箱成int类型，在装箱成Integer类型。

当两个Integer的对象的值在byte的范围内时，对于新特性不会再开辟空间。即实际是一个对象。