JAVA API(一)String类和StringBuffer类

时间 2019-12-08

标签 java api string stringbuffer 栏目 Java 繁體版

原文原文链接

1.String类和StringBuffer类

在程序中常常会用到字符串，所谓的字符串就是指一连串的字符，它是由多个单个字符链接而成的。字符串中能够包含任意字符，这些字符必须包含在一对双引号""以内，如"abc"。在Java中定义了String和StringBuffer类来封装字符串，并提供了一系列操做字符串的方法，它们都位于java.lang包中，所以不须要导包就能够直接使用。下面将对String类和StringBuffer类详细讲解。java

1.1String类的初始化

在操做String类以前，须要先对String类进行初始化，在Java中经过如下方法对String类进行初始化：数组

使用字符串常量直接初始化String对象。如　:
```
String str1 = "abc";　　
```

使用String的构造方法初始化字符串对象，String类的构造方法以下表：

方法声明	功能描述
String()	建立一个内容为空的字符串
String(String value)	根据指定的字符串内容建立对象
String(char[] value)	根据指定的字符数组建立对象app

下面经过一个例子来学习String类的使用：学习

Example01.javaui

public class  Example01{
    public static void main(String[] args) {
        //建立一个空的字符串
        String str1 = new String();
        //建立一个内容为abcd的字符串
        String str2 = new String("abcd");
        //建立一个内容为字符串数组的字符串
        char[] charArray = new char[]{'A','B','C','D'};
        String str3 = new String(charArray);
        System.out.println("a" + str1 + "b");
        System.out.println(str2);
        System.out.println(str3);
    }
}

运行结果以下：spa

1.2String类的常见操做

方法声明	功能描述
int indexOf(int ch)	返回指定字符在此字符串中第一次出现处的索引
int lastIndexOf(int ch)	返回指定字符在此字符串中最后一次出现处的索引
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引
int lastIndexOf(String str)	返回指定子字符串在此字符串中最后一次出现处的索引
char charAt(int index)	返回字符串中index位置上的字符，其中，index的取值范围是0-(字符串长度-1)
boolean endsWith(String suffix)	判断此字符串是否以指定的字符串结尾
int length()	返回此字符串的长度
boolean equals(Object anObject)	将此字符串与指定的字符串比较
boolean isEmpty()	当且仅当字符串长度为0时返回true
boolean startsWith(String prefix)	判断此字符串是否以指定的字符串开始
boolean contains(CharSequence cs)	判断此字符串中是否包含指定的字符序列
String toLowerCase()	使用默认语言环境的规则将String中的全部字符都转换为小写
String toUpperCase()	使用默认语言环境的规则将String中的全部字符都转换为大写
static String valueOf(int i)	返回int参数的字符串表示形式
char[] toCharArray()	将此字符串转换为一个字符数组
String replace(CharSequence oldstr,CharSequence newstr)	返回一个新的字符串，它是经过用newstr替换此字符串中出现的全部oldstr获得的
String[] split(String regex)	根据参数regex将原来的字符串分割为若干子字符串
String substring(int beginIndex)	返回一个新字符串，它包含从指定的beginIndex出开始直到此字符串末尾的全部字符
String substring(int beginIndex,int endIndex)	返回一个新字符串，它包含从指定的beginIndex出开始直到索引endIndex-1处的全部字符
String trim()code	返回一个新字符串，它去除了原字符串首尾的空格对象

下面经过一些例子来具体的学习一下这些方法。blog

Example02.java　　索引

public class Example02 {
    public static void main(String[] args) {
        String s = "ababcdedcba";//声明字符串
        System.out.println("字符串的长度为：" + s.length());//获取字符串长度，即字符个数
        System.out.println("字符串中第一个字符：" + s.charAt(0));
        System.out.println("字符c第一次出现的位置：" + s.indexOf('c'));
        System.out.println("字符c最后一次出现的位置：" + s.lastIndexOf('c'));
        System.out.println("子字符串第一次出现的位置：" + s.indexOf("ab"));
        System.out.println("子字符串最后一次出现的位置：" + s.lastIndexOf("ab"));
    }
}

运行结果以下：

从上面的运行结果能够看出，String类提供的方法能够很方便的获取字符串的长度，获取指定位置的字符以及指定字符和字符串的位置。

Example03.java　　　

public class Example03 {
    public static void main(String[] args) {
        String str = "abcd";
        System.out.println("将字符串转换为字符数组后的结果：");
        char[] charArray = str.toCharArray();//字符串转换为字符数组
        for (int i= 0;  i< charArray.length; i++) {
            if (i != charArray.length-1) {
                //若是不是数组的最后一个元素，在元素后面加逗号
                System.out.print(charArray[i] + ",");
            }else {
                //数组的最后一个元素后面不加逗号
                System.out.println(charArray[i]);
            }
        }
        System.out.println("将int值转换为String类型以后的结果：" + String.valueOf(12));
        System.out.println("将字符串转换成大写以后的结果：" + str.toUpperCase());
    }
}

运行结果以下：

使用String类的toCharArray()方法将一个字符串转为一个字符数组，静态方法valueOf()将一个int类型的整数转为字符串，toUpperCase()方法将字符串中的字符都转为大写。其中，valueOf()方法有不少重载的形式，float,double,char等其余基本类型的数据均可以经过该方法转换为String类型字符串。　

Example04.java　　　

public class Example04 {
    public static void main(String[] args) {
        String s = "baidu";
        //字符串替换操做
        System.out.println("将du替换成du.com的结果：" + s.replace("du", "du.com"));
        //字符串去除空格操做
        String s1 = "   b a i d d u ";
        System.out.println("去除字符串两端空格后的结果：" + s1.trim());
        System.out.println("去除字符串中全部空格后的结果:" + s1.replace(" ", ""));
    }
}

运行结果以下：

replace()方法用于将字符串中全部与指定字符串匹配的子串替换成另外一个字符串，trim()方法用于去除字符串中的空格。须要注意的是，该方法只能去除两端的空格，不能去除在中间的空格。若想要去除字符串中间的空格，则能够调用String类的replace()方法。

Example05

public class Example05 {
    public static void main(String[] args) {
        String s1 = "String";//声明一个字符串
        String s2 = "Str"; 
        System.out.println("判断是否以字符串Str开头:" + s1.startsWith(s2));
        System.out.println("判断是否以字符串ng结尾：" + s1.endsWith("ng"));
        System.out.println("判断是否包含字符串tri:" + s1.contains("tri"));
        System.out.println("判断字符串是否为空：" + s1.isEmpty());
        System.out.println("判断两个字符串是否相等：" + s1.equals(s2));
    }
}

运行结果以下：

上面例子中涉及到的方法都是用于判断字符串的，而且返回值都是boolean类型。其中，equals()方法比较重要，该方法将弗雷Object中的equals()方法进行了重写。

在程序中能够经过"==" 和equals()两种方式对字符串进行比较，可是这两种方式有明显的区别。equals()方法用于比较两个字符串中的字符是是否相等，==方法用于比较两个字符串对象的地址是否相等。对于两个字符串对象，当它们的字符内容彻底相同时，使用equals()判断结果会为true，可是用==判断时，结果必定为false。以下面的代码：

String str1 = new String("abc");
String str2 = new String("abc");
//结果为false，由于str1和str2是两个对象
System.out.println(str1 == str2);
//结果为true，由于str1和str2字符内容相同
System.out.println(str1.equals(str2));

Example06.java

public class Example06 {
    public static void main(String[] args) {
        String str = "羽毛球-篮球-乒乓球";
        //下面是字符串截取操做
        System.out.println("从第5个字符截取到末尾的结果：" + str.substring(4));
        System.out.println("从第5个字符截取到第6个字符的结果：" + str.substring(4, 6));
        //下面是字符串分割操做
        System.out.print("分割后的字符串数组中的元素依次为：");
        String[] strArray = str.split("-");//将字符串转换为字符串数组
        for (int i = 0; i < strArray.length; i++) {
            if (i!=strArray.length-1) {
                //若是不是数组的最后一个元素，在元素后面加逗号
                System.out.print(strArray[i] + ",");
            }else {
                //数组的最后一个元素后面不加逗号
                System.out.println(strArray[i]);
            }
        }
    }
}

注意：String字符串在获取某个字符时，会用到字符的索引。当访问字符串中的字符时，若是字符的索引不存在，则会发生StringIndexOutOfBoundsException(字符串角标越界异常)。

1.3StringBuffer类

因为字符串是常量(用final修饰符修饰的)，所以一旦建立后，其内容和长度是不可更改的。若是须要对字符串进行修改，则只能建立一个新的字符串对象，这样会由于内存的消耗和操做的不便。为了方便对字符串进行修改，Java提供了一个StringBuffer类(字符串缓冲区)。StringBuffer类和String类最大的区别就是它的内容和长度是可变的。StringBuffer类至关于一个容器，在对其中的内容进行修改(添加和删除)时，不会产生新的StringBuffer对象。

下面是StringBuffer类的一系列经常使用方法：

方法声明	功能描述
StringBuffer(char c)	添加参数到StringBuffer对象中
StringBuffer insert(int offset,String str)	将字符串中的offset位置插入字符串str
StringBuffer deleteCharAt(int index)	移除此序列指定位置的字符
StringBuffer delete(int start,int end)	删除StringBuffer对象中指定范围的字符或字符串序列
StringBuffer replace(int start,int end,String s)	在StringBuffer对象中替换指定的字符或字符串序列
void setCharAt(int index,char ch)	修改指定位置index处的字符序列
String toString()	返回StringBuffer缓冲区中的字符串
StringBuffer reverse()	将此字符串列用其反转形式取代

下面经过一些例子来学习StringBuffer类的经常使用方法。

Example07.java

public class Example07 {
    public static void main(String[] args) {
        System.out.println("一、添加-----------------------");
        add();
        System.out.println("二、删除-----------------------");
        remove();
        System.out.println("三、修改-----------------------");
        alter();
    }
    
    private static void add() {
        StringBuffer sb = new StringBuffer();//定义一个字符串缓冲区
        sb.append("abcdefg");//在末尾添加字符
        System.out.println("append添加结果：" + sb);
        sb.insert(2, "123");//在指定位置插入字符串
        System.out.println("insert添加结果：" + sb);
    }

    private static void remove() {
        StringBuffer sb = new StringBuffer("abcdefg");
        sb.delete(1, 5);//指定范围删除
        System.out.println("删除指定位置结果：" + sb);
        sb.deleteCharAt(2);
        System.out.println("删除指定位置结果：" + sb);
        sb.delete(0, sb.length());//清空缓冲区
        System.out.println("清空缓冲区结果：" + sb);
    }

    private static void alter() {
        StringBuffer sb = new StringBuffer("abcdef");
        sb.setCharAt(1, 'p');//修改指定位置字符
        System.out.println("修改指定位置富足结果：" + sb);
        sb.replace(1, 3, "qq");//替换指定位置字符串或字符
        System.out.println("替换指定位置字符(串)结果 :" + sb);
        System.out.println("字符串反转结果：" + sb.reverse());
    }
}

运行结果以下：

在上面的例子中，append()和insert()方法是最经常使用的，而且这两个方法有不少重载形式，它们都用于添加字符。不一样的是，append()方法始终将这个字符添加到缓冲区的末尾，而insert()方法则能够在指定的位置添加字符。另外，delete()方法用于删除指定位置的字符，setCharAt()和replace()方法用于替换指定位置的字符。

StringBuffer类和String类有不少类似之处。下面简单概括一下两种的不一样点：

String类表示的字符串是常量，一旦建立后，内容和长度都是没法更改的。而StringBuffer表示字符容器，其内容和长度能够随时修改。在操做字符串时，若是该字符串仅用于表示数据类型，则使用String类便可。可是若是须要对字符串中的字符进行修改操做(增删)，则使用StringBuffer类。String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法，以下代码：

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1.equals(str2));//打印结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(str2));//打印结果为false

String类对象能够用操做符"+"进行链接，而StringBuffer类对象之间不能。

下面经过一个综合的例子来复习上面学习的知识点：

记录一个子串在整串中出现的次数。

package main;

public class StringTest {
    public static void main(String[] args) {
        String str = "nbaernbatnbaynbauinbaopnba";//整串
        String key = "nba";//子串
        int count = getKeyStringCount(str,key);
        System.out.println("count=" + count);
    }

    /**
     * 获取子串在整串中出现的次数
     * @param str
     * @param key
     * @return
     */
    private static int getKeyStringCount(String str, String key) {
        //定义计数器，记录出现的次数
        int count = 0;
        //若是整串中不包含子串，则直接返回count
        if (!str.contains(key)) {
            return count;
        }
        //定义变量记录key出现的位置
        int index = 0;
        while ((index = str.indexOf(key)) != -1) {
            str = str.substring(index + key.length());
            count ++ ;
        }
        return count;
    }
}