JAVA APIString类和StringBuffer类

Posted 2020-09-20 gouyadong

1.String类和StringBuffer类

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

1.1String类的初始化

在操作String类之前，需要先对String类进行初始化，在Java中通过以下方法对String类进行初始化：

1. 使用字符串常量直接初始化String对象。如　:

   String str1 = "abc";　　

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

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

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

Example01.java

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);
    }
}

运行结果如下：

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()	返回一个新字符串，它去除了原字符串首尾的空格

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

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("1、添加-----------------------");
        add();
        System.out.println("2、删除-----------------------");
        remove();
        System.out.println("3、修改-----------------------");
        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;
    }
}