黑马程序员_字符串数据的操作概述

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

一、 String类的特点

字符串是一个特殊的对象，因为 它一旦初始化就不可以被改变。也就是说字符串是一个常量，它在内存中所处的位置是方法区中的字符串常量池。

根据一个例子来说明字符串的特点：

String s1="abc";

String s2=new String("abc");

上面两句话的区别：

第一句代码在内存中创建了一个字符串对象"abc"，并定义了一个String类类型的变量s1指向它在内存中的地址。

第二句代码在内存中创建了两个字符串对象"abc"。因为这句代码用到了关键字new，就会在内存中新创建一个字符串对象。由于把"abc"对象当做参数传递给了构造函数，所以，s2指向新创建的"abc"对象的内存地址。还有一个对象就是参数中的"abc"对象，它一初始化就已经在内存中存在了。

二、String类的常见操作

首先定义一个String类的对象并初始化：String s="abcdef";

1、获取操作

1）int length()：获取字符串中的包含的字符数，也就是字符串的长度。

System.out.println(s.length());  //返回结果：6

2）char charAt(int index)：根据指定的位置获取该位置上的某个字符。

System.out.println(s.charAt(2));  //返回结果：c（因为字符串的索引是从0开始的）

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

System.out.println(s.indexOf(98));  //返回结果：1

根据ASCII码找字符的位置，b字符的ASCII码值为98，而b字符的索引是1，那么就返回第一个符合条件的字符的位置1。如果找不到返回-1。

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

System.out.println(s.indexOf(98,2));  //返回结果：-1

因为从第2个索引的位置找字符b，没有找到就返回-1。

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

System.out.println(s.indexOf("b"));  //返回结果：1

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

System.out.println(s.indexOf("b",2));  //返回结果：-1

int lastIndexOf(int ch)：跟indexOf(int ch)方法有一点不同，它是从最后一个字符开始查找的。

System.out.println(s.lastIndexOf(98));  //返回结果：1

还有几个lastIndexOf(***)方法，跟indexOf(***)方法是差不多的，只是都是从最后一个字符开始查找的。

2、判断

1）boolean contains(str)：判断字符串是否包含某一个子串。

System.out.println(s.contains("cde"));   //返回结果：true

2）boolean isEmpty()：判断字符串中是否有内容。（原理就是判断长度是否为0）

System.out.println(s.isEmpty());   //返回结果：false

3）boolean startsWith(str)：判断字符串是否以指定内容开头。

System.out.println(s.startsWith("abcd"));   //返回结果：true

4）boolean endsWith(str)：判断字符串是否以指定内容结尾。

System.out.println(s.endsWith("ef"));   //返回结果：true

5）boolean equals(str)：判断字符串内容是否相同。

复写了Object类中的equals()方法，只要内容相同，那么返回true。而Object类中的此方法判断的则是对象的内存地址值是否相同 ，千万不可混淆！

System.out.println(s.equals("abcdef"));  //返回结果：true

6）boolean equalsIgnoreCase()：判断内容是否相同，并忽略大小写。

System.out.println(s.equalsIgnoreCase("ABCDEF"));  //返回结果：true

3、转换

1）将字符数组转成字符串有三种方法：

先定义好一个字符数组： char[] arr={'a','b','c','d','e','f'};

①构造函数：String(char[])：
String s=new String(arr);
System.out.println("s="+s);    //打印结果：s=abcdef

String(char[],offset,count)：将字符数组的一部分转成字符串。（从offset位置开始，往后取count个字符转成字符串）

String s=new String(arr,1,2);
System.out.println("s="+s);    //打印结果：s=bc

②静态方法：static String copyValueOf(char[])：返回指定数组中表示该字符序列的 String。
System.out.println(String.copyValueOf(arr));    //打印结果：abcdef

static String copyValueOf(char[] data,int offset,int count)：返回指定数组中表示该字符序列的 String。

System.out.println(String.copyValueOf(arr,1,2));    //打印结果：bc

③静态方法：static String valueOf(char[])：返回char 数组参数的字符串表示形式。

System.out.println(String.valueOf(arr));    //打印结果：abcdef

static String valueOf(char[],offset,count)：返回char 数组参数的特定子数组的字符串表示形式。

System.out.println(String.valueOf(arr,1,4));    //打印结果：bcde

2）char[] toCharArray()：将字符串转成字符数组。

String str="zhangsan";

char[] ch=str.toCharArray();
for (int i=0;i<ch.length ;i++ )
{
     System.out.print(ch[i]+"*");  //打印结果：z*h*a*n*g*s*a*n*
}

3）String(byte[])：将字节数组转成字符串。

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

首先定义一个字节数组：byte[] by={'1','2','3','4','5','6','7','8'};
String ss=new String(by);
System.out.println("ss="+ss);  //打印结果：ss=12345678

String(byte[],offset,count)：将字节数组中的一部分转成字符串

String ss2=new String(by,1,5);
System.out.println("ss2="+ss2);  //打印结果：ss2=23456

4）byte[] getBytes()：将字符串转成字节数组。

String str2="zhoujielun";
byte[] b=str2.getBytes();
for (int i=0;i<b.length ;i++ )
{
     System.out.print(b[i]+"*");   //打印结果：122*104*111*117*106*105*101*108*117*110*
}

返回的是该字节对应的ASCII码值。

5）将基本数据类型转成字符串。

①static String valueOf(int)：返回int 参数的字符串表示形式。

也可以这样转换：3+“”。因为任何类型的数据用连接符与字符串连接都会变成字符串类型。

②static String valueOf(double)：返回 double 参数的字符串表示形式。

……boolean,char,int,long,float,double,Object都可以。

4、替换

String replace(oldchar,newchar)：替换字符，如果替换的字符不存在，那么返回原串。

String s="zhangsan";
String s2=s.replace('a','n');
System.out.println("s2="+s2);  //打印结果：s2=zhnngsnn

String replace(CharSequence target, CharSequence replacement) ：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

String ss="hello world!";
String ss2=ss.replace("world","java");
System.out.println("ss2="+ss2);    //打印结果：ss2=hello java!

5、切割

String[] split(regex)：根据给定正则表达式的匹配拆分此字符串。

String s="zhangsan,lisi,wangwu";
String[] s2=s.split(",");
for (int i=0;i<s2.length ;i++ )
{
      System.out.print(s2[i]+“*”);   //打印结果：zhangsan*lisi*wangwu*
}

6、获取字符串中的一部分

首先定义一个字符串对象：String s="abcdefg";

String substring(begin)：从指定角标开始（包括）到末尾。

System.out.println(s.substring(2));    //打印结果：cdefg

String substring(begin,end)：从指定角标1开始（包括）到指定角标2结尾（不包括）。

System.out.println(s.substring(2,4));    //打印结果：cd

7、大小写转换

首先定义一个字符串对象：String s="heLLo WOrld!";

String toUpperCase()：将字符串转成大写。

System.out.println(s.toUpperCase());    //打印结果：HELLO WORLD!

String toLowerCase()：将字符串转成小写。

System.out.println(s.toLowerCase());    //打印结果：hello world!

8、去除空格

String trim()：将字符串两端的多个空格取出。

String s="  hello java  !   ";

System.out.println("*"+s.trim()+"*");   //打印结果：*hello java  !*

9、比较

int compareTo(String)：

对两个字符串进行自然顺序的比较。 其实比较的是ASCII码值！

首先定义4个字符串对象：

String s2="acc";
String s3="abb";
String s4="a1c";
String s5="abb";

System.out.println(s2.compareTo(s3));    //打印结果：1

让s2和s3比较，角标为0的位置上的元素相同，所以接着往下比较，c的ASCII值比b的ASCII值大1，所以结果为：1。

System.out.println(s4.compareTo(s3));    //打印结果：-49

1的ASCII码值比c的ASCII码值小49，所以结果为：-49。

System.out.println(s5.compareTo(s3));    //打印结果：0

s5和s3中的元素相同，所以结果为：0。

三、StringBuffer类的特点

字符串的组成原理就是通过该类实现的。

StringBuffer可以对字符串内容进行增删。

很多方法与String相同。

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

1、StingBuffer是可变长度的。

2、可以直接操作多个数据类型。

3、最终会通过toString()方法变成子串。

四、StringBuffer类的常用方法

1、存储

首先定义一个StringBuffer对象：StringBuffer sb=new StringBuffer();

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

StringBuffer sb2=sb.append("abc");

System.out.println("sb="+sb.toString());          //打印结果：sb=abc
System.out.println("sb2="+sb2.toString());     //打印结果：sb2=abc

sb.append('d').append(1234).append(true);
System.out.println("sb="+sb.toString());         //打印结果：sb=abcd1234true

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

sb.insert(1,"qq");
System.out.println("sb="+sb.toString());     //打印结果：sb=aqqbcd1234true
sb.insert(1,88);
System.out.println("sb="+sb.toString());     //打印结果：sb=a88qqbcd1234true

2、删除

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

StringBuffer sb=new StringBuffer("abcdefg");
System.out.println("sb="+sb.toString());      //打印结果：s=abcdefg
sb.delete(1,4);
System.out.println("sb="+sb.toString());      //打印结果：sb=aefg
sb.delete(0,sb.length());     //清空缓冲区
System.out.println("sb="+sb.toString());      //打印结果：sb=

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

StringBuffer sb2=new StringBuffer("abcdefg");
//把sb2中的c字符删除
sb2.deleteCharAt(2);//sb2.delete(2,3);两种方式结果一样
System.out.println("sb2="+sb2.toString());    //打印结果：sb2=abdefg

3、获取

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end)

以上方法同String类对应的方法的使用是一样的。

4、修改

StringBuffer replace(start,end,str)：把一个指定角标（包含）到另一个指定角标（不包含）的字符串替换成指定的字符串。

StringBuffer sb=new StringBuffer("abcdefg");
System.out.println("sb="+sb.toString());     //打印结果：sb=abcdefg
sb.replace(1,2,"haha");
System.out.println("sb="+sb.toString());     //打印结果：sb=ahahacdefg

void setCharAt(int index,char ch)：将指定的字符ch替换到指定位置index上。

StringBuffer sb2=new StringBuffer("abcdefg");
System.out.println("sb2="+sb2.toString());    //打印结果：sb2=abcdefg
sb2.setCharAt(1,'a');
System.out.println("sb2="+sb2.toString());    //打印结果：sb2=aacdefg

5、反转

StringBuffer reverse()：将字符串中的数据反转。

StringBuffer sb=new StringBuffer("12345");
sb.append("abcdefg");
System.out.println(sb.reverse());      //打印结果：gfedcba54321

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

void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：将缓冲区中指定的数据存储到指定的字符数组中。

StringBuffer sb=new StringBuffer("abcdefg");
char[] arr=new char[7];
  /*
  一定要小心数组下标越界异常！
  从角标1位置（包含）开始截取到角标5位置（不包含），存入char类型的数组：arr中，从char类型数组的指定角标：1开始存。
  */
sb.getChars(1,5,arr,1);
for (int i=0;i<arr.length ;i++ )
{
     System.out.println("arr["+i+"]="+arr[i]);
}

上述代码的执行结果：

arr[0]=

arr[1]=b

arr[2]=c

arr[3]=d

arr[4]=e

arr[5]=

arr[6]=

五、StringBuffer类与StringBuilder类的区别

StringBuilder类是JDK升级到1.5版本之后出现的。以后开发，建议使用StringBuilder。

区别：

1、StringBuilder类中的方法和StringBuffer类中的方法一模一样，但是StringBuilder类中的方法效率高。

2、StringBuffer类是线程同步的，StringBuilder类是线程不同步的。

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

注：JDK升级的三个因素：

1）提高效率。

2）简化书写。

3）提高安全性。

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>