黑马程序员——自学总结（二）：字符串

<a href="http://www.itheima.com"
target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！

一、字符串概述

       字符串String就是一个字符序列，它实现了接口CharSequence。String s1="abc",s2=new String("abc");s1与s2的区别在于，s1创建了一个对象"abc"，该字符串常量存储在字符串常量池里，当再有其他的字符串创建，值为“abc”时，其内容直接指向字符串常量池中的''abc"，常量池不再开辟新空间，但新字符串本身和s1存储在不同地址中。而s2创建了两个对象，一个是字符串常量"abc"，存储在字符串常量池里，另一个是s2对象本身。

二、字符串常见的操作

       1、获取

             (1)获取字符串中包含的字符数，也就是字符串的长度

                  int length();

            (2)根据指定位置获取字符串该位置上的字符

                 char charAt(int index)

                字符串角标从0开始，范围为0~length()-1，当访问到字符串中不存在的角标时，会发生StringIndexOutofBoundException

            (3)根据指定字符获取该字符在字符串中的位置

                 int  indexOf(int ch)返回的是ch在字符串中第一次出现的位置，ch可以是char类型，char类型转化成int类型

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

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

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

                如果没有找到，返回-1。类似的还有反向索引

                int  lastindexOf(int ch)， int lastindexOf(int ch，int fromIndex)， int lastindexOf(String
str)，  int  lastindexOf(String str，int fromIndex)，反向索引从字符串末端开始搜索，获取字符或字符串首次出现的位置。

    2、判断

          (1)判断字符串中是否包含某一个子串

               boolean contains(CharSequence str) CharSequence是一个接口，String，StringBuffer，StringBuilder都实现了此接口

               int  indexOf(String str)可以str第一次出现的位置，如果返回-1，表示该str不在字符串中存在，所以，也可以用于对判断字符串是否包含某一字串，该方法既可以判断存在与否，又可以获取首次出现的位置。

          (2)判断字符串中是否有内容

               boolean isEmpty() 该方法从JDK1.6版本开始，原理就是判断长度是否为零，底层调用length()

          (3)判断字符串是否是以指定内容开头

               boolean startsWith(String str)

          (4)判断字符串是否以指定内容结尾

               boolean endsWith(String str)

          (5)判断两个字符串的内容是否相同

               boolean equals(String str)

               此方法覆写了Object中的equals方法，返回两个字符串中的内容是否相同

          (6)判断内容是否相同，忽略大小写

               boolean equalsIgnoreCase(String str)

    3、转换
          (1)字符数组转成字符串

               构造函数

               String(char[] value)将指定字符数组转换为字符串

               String(char[] value,int offset,int count)将字符数组中的一部分转成字符串,offset为要转换的字符数组首位置，count为要转换的字符个数

              静态方法

              static String copyValueOf(char[] value)

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

              static String valueOf(char[] value)

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

         (2)字符串转换成字符数组

              char[]   toCharArray();

         (3)将字节数组转成字符串

             构造函数：

             String(byte[] value)

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

        (4)字符串转成字节数组

             byte[] getBytes();

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

        (5)基本数据类型转成字符串

            static String  valueOf(参数可以是任何基本数据类型变量，除了short和byte)

    4、转换
          String replace(old  char,new  char);如果要替换的字符不存在，返回原串

          String replace(CharSuquence targer，CharSequence replacement)

    5、切割

          String[] split(String regex);

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

         String substring(int begin);

         String substring(int begin,int end);取出角标0至角标end-1的子串

        如果角标不存在，抛出StringIndexOutofBoundException

    7、转换大小写

         String toUpperCase();

         String toLowerCase();  

    8、将字符串两端的多个空格去除

          String trim()

    9、对两个字符串进行自然顺序的比较

          int compareTo(String str)此方法依赖于equals方法

练习：1、自定义去除两端空格的函数

class MyTrim{
public static String mytrim(String s){
int start=0,end=s.length()-1;
//从字符串首位置开始找到第一个非空格
while(start<end && s.charAt(start)==' ')
start++;
//从字符串尾端开始找到第一个非空格
while(start<end && s.charAt(end)==' ')
end--;
//取字串，返回去除两端空格后的子串
return s.substring(start,end+1);
}
public static void main(String[] args){
String s1="   abc  ",s2="   a bc  ",s3=" ";
System.out.println("s1="+s1);
System.out.println("s1去除两端空格后"+mytrim(s1));
System.out.println("s2="+s2);
System.out.println("s2去除两端空格后"+mytrim(s2));
System.out.println("s3="+s3);

4000
System.out.println("s3去除两端空格后"+mytrim(s3));
}
}

2、将字符串反转

class MyReverse{
public static String myreverse(String s){
char[] c=s.toCharArray();//将字符串转换成字符数组
char temp;
int n=s.length();
//字符数组首尾依次交换
for(int i=0,j=n-1;i<n/2;i++,j--){
temp=c[i];
c[i]=c[j];
c[j]=temp;
}
//将反转后的字符数组转换成字符串返回
return new String(c);
}
public static void main(String[] args){
String s="abcdef";
System.out.println(s);
System.out.println("反转后："+myreverse(s));
}
}

3、获取一个字符串在另一个字符串中出现的次数

class MyCount{
public static int mycount(String s1, String s2){//统计s2在s1中出现的次数
int count=0,index;
while((index=s1.indexOf(s2))!=-1){
count++;
index+=s2.length();
if(index>s1.length()-1) break;//如果下一次搜索的起始位置超出当前s1长度，

//则跳出循环
s1=s1.substring(index);//从下一个位置起继续搜索
}
return count;

}
public static void main(String[] args){
String s1="abcdebcfbcbc",s2="bc";
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s2在s1中出现"+mycount(s1,s2)+"次");
}
}

4、获取两个字符串中最大相同子串

class MyMaxSame{
public static String mymaxsame(String s1, String s2){
String result;
//先让s1指向长串，s2指向短串
if(s1.length()<s2.length()){
result=s1;
s1=s2;
s2=result;
}
for(int i=s2.length();i>0;i--)//相同子串最大长度为s2.length()，从最大长度开

始搜索
for(int j=0;j<s2.length()-i+1;j++){//在S中长度为i的子串有s.length-i+1个
result=s2.substring(j,j+i);
if(s1.contains(result)) return result;
}
return null;
}
public static void main(String[] args){
String s1="abcdebcfbcbc",s2="bcdefgh";
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("最大相同子串="+mymaxsame(s2,s1));
}
}

三、StringBuffer

        StringBuffer字符串缓冲区，是一个容器，StringBuffer可变，而String不可改变，一旦String对象内容改变，它将会指向新的字符串，而原来的字符串仍在内存中。StringBuffer可以字节操作多种数据类型，可以通过toString变成字符串，与char[]比较类似，字符数组存取，访问比较方便，但存数数据数量受限，而StringBuffer可以扩充数据。

        StringBuffer的操作

        1、存储：StringBuffer append()，将指定参数加到字符串末尾，但参数不能是byte类型和short类型，这一点和String的valueOf()方法类似

                         
StringBuffer insert(int index, 数据)可以将数据插入到制定index位置处,同样不支持byte类型和short类型

        2、删除：StringBufferdelete(int  start, int  end）删除start至end-1角标的元素

                         
StringBuffer deletecharAt(int  index)删除指定位置的字符

                         清空缓冲区的方法：(1)指向一个空缓冲区，sb=new StringBuffer();(2)删除缓冲区中所有数据，sb.delete(0,sb.length());

        3、获取：char  charAt(index) 

                           int indexOf(String str)

                           int indexOf(String str, int fromIndex)

                           int lastIndexOf(String str)

                           int lastIndexOf(String str, int fromIndex)

                           比较发现，String类中对应的上面四个方法中参数可以是char或int，而StringBuffer只能是String

                           String substring(int start) 

                           String  substring(int start, int end)

          4、修改：

                         StringBuffer replace(int start, int end,String str) 
                         void setCharAt(int index, char ch)

          5、反转

                        StringBuffer reverse()

                        void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将缓冲区中的指定数据存储到指定数组中，从srcBegin位置起，到srcEnd-1位置处，复制到数组dst中dstBegin位置处

四、StringBuilder

        StringBuilder在JDK1.5版本出现，它是线程不同步的，而StringBuffer线程同步，故而在单线程中使用StringBuffer效率较低，因为要判断同步锁。JDK升级围绕着三点：提高效率，简化书写，提高安全性，StringBuilder的出现是为了提高效率。

五、基本数据类型与字符串间的转换

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

            基本数据类型byte 对应引用数据类型Byte类，short对应Short类，int对应Integer类，long对应Long类，float对应Float类，boolean对应Boolean类，double对应Double类，char对应Character类。基本数据类型对象包装类最常见的操作就是基本数据类型和字符串类型之间做转换，

       2、基本数据类型转成字符串的方法：

             (1)基本数据类型+""  比如int i=1;String s=i+"";  

             (2)基本数据类型对应的包装类.toString(值)，比如Integer中的静态方法static String toString(int i)

       3、字符串转成基本数据类型 ,以Integer为例static  int  parseInt(String s)s必须是数字格式，其他基本数据类型对应的包装类都有类似方法，除了Character类。

4、十进制数 转成其他进制用Integer类中的静态方法：static String toBinaryString(int i)转成二进制形式，static String toHexString(int i)转成十六进制形式，static String toOctalString(int i)转成八进制形式。其他进制数转成十进制数用parseInt(String,radix)，radix表示要转成的进制数。    5、基本数据类型和对应的包装类之间的转换          以int和Integer举例， Integer i=new Integer("123"); int num=i.intValue();intValue()是非静态方法          Integer.equals()方法比较数值，例如Integer i1=new Integer(4),i2=new Integer(4);那么i1.equals(i2)为true，类似于String类的equals()         JDK1.5版本以后出现了新特性，Integer x=4;自动装箱，等于Integer x=new Integer(4);简化了书写。x可直接运算x=x+2;自动拆箱, 等于x.intValue()+2，运行前需判断x是否为空         Integer i1=4,i2=4;在JDK1.5出现的新特征中，当数值在byte范围内，如果数值已经存在，则不会再开辟新空间。验证代码： class IntegerDemo{ public static void main(String[] args){ Integer i1=4,i2=4; System.out.println(i1==i2); } } 结果：true