Java字符串的处理

目录

1. String类和StringBuffer类的比较

2.字符串处理的类库种类

  2.1字符串处理类——String

 2.2字符串处理的方法

 2.3缓冲字符串StringBuffer类的构造器

 2.4缓冲字符串的处理

3.常见疑难解答

3.1equals和"=="区别

3.2String类为何被定义成final约束

3.3char类型如何转换成int类型，int类型如何转换成字符串

---

Java提供了两种字符串操作——String类和StringBuffer类，对字符串的操作是通过定义好的一系列方法实现的。

1. String类和StringBuffer类的比较

（1）String类

该类一旦产生一个字符串，其对象就不可变。String类的内容和长度是固定的。系统为String类对象分配内存，是按照对象所包含的实际字符数分配的。

（2）StringBuffer类

该类具有缓冲功能。StringBuffer类处理可变字符串。如果要修改一个StringBuffer类的字符串，不需要再创建新的字符串对象，而是直接操作原来的字符串。系统为StringBuffer类对象分配内存时，除去当前字符所占空间外，还提供另外16个字符大小的缓冲区。

注意：使用StringBuffer类对象时，使用length()方法获得实际包含字符串的长度，capacity()方法返回当前数据容量和缓冲区的容量之和。

2.字符串处理的类库种类

  2.1字符串处理类——String

（1）字符串类的默认构造器

“String()”这个构造器时最简单的构造器，也是系统默认的构造器，是不带参数的。

public class Str1 {                            //定义一个Str1类
    public static void main(String[] args) {   //主方法
        String str = new String();             //创建一个空字符串str
        System.out.println(str);               //输出空字符串
    }
}

（2) 字节参数的构造器

"String(byte[] byte)"将字节数组中的元素作为字符串对象。

public class Str2 {
    public static void main(String[] args) {
        byte b[] = {97, 98, 99};                    //初始化一个字节数组b
        //通过构造器，将字节数组中的元素连接成一个字符串
        String str = new String(b);
        System.out.println(str);                    //将此字符串输出
    }
}

代码说明：这个构造器的作用是将字节数组中的元素以字符串对象的形式输出。

运行结果：abc

（3）获取指定字节数的构造器

“String(byte[] bytes,int offset, int length)"这个构造器的含义是：将字节数组中从"offset”指定的位置开始到“length”长度结束，其中间的字符构成串对象。

public class Str3 {
    public static void main(String[] args) {
        //初始化一个字节数组b
        byte b[] = {97, 98, 99, 100, 101, 102};
        //通过构造器，将字节数组中的元素连接成一个字符串，并且从第4个位置开始，
        //总共有2个元素
        String str = new String(b, 2, 3);
        System.out.println(str);
    }
}

 代码说明：在String对象中，第一个参数 b，就是指开始初始化的字符数组。第二个参数是3，就是指定从第4个位置开始，因为数字是从0开始的，所以3是指第4个位置即“4”。第三个参数是2，指定从这个位置开始后几个字符，因为是2，所以是从“4”开始的两个字符。

运行结果：de

 （4）将字节型数据转换为字符集输出的构造器

       “String(byte[] bytes, int offset, int length, String charsetName)"这个构造器的含义就是：将一个字节数组中从第“offset”个位置的字符开始到“length”长度结束，其中间的字符形成字符串对象，然后将这个字符串按照某种字符集输出。

        字符集一般有"us-ascii" "iso-8859-1" "utf-16be" "utf-16le" "utf-16" 等样式。

import java.io.UnsupportedEncodingException;
public class Str4 {
    public static void main(String[] args) {
        //初始化一个字节数组b
        byte b[] = {97, 98, 99, 100, 101, 102};
        try {
            //通过构造器，将字节数组中的元素连接成一个字符串，并且从第4个位置开始，总共有2个元素
            String str = new String(b, 3, 2, "utf=8");
            //将此字符串以UTF-8的形式输出
            System.out.println(str);
        } catch (UnsupportedEncodingException ex) {//catch语句块用来获取异常信息
        }
    }
}

代码说明："String(byte[] bytes, String charsetName)"与上一个构造器是同类构造器，此构造器是将整个字节数组作为字符串对象，并以某个字符集形式输出。

运行效果：de

（5）字符数组的构造器

        "String(char[] value)"构造一个字符数组，其实这个构造器与第二个构造器很相似，它是将字符数组内的字符连在一起，形成一个字符串。

public class Str5 {
    public static void main(String[] args) {
        //初始化一个字符数组c
        char c[] = {'w', 'e', 'l', 'c', 'o', 'm', 'e'};
        //通过构造器，将字符数组中的元素连接成一个字符串
        String str = new String(c);
        System.out.println(str);
    }
}

 代码说明：上述代码主要实现将字符数组中的所有元素连起来形成一个字符串，并且在第7行输出字符串对象str。

运行结果：welcome

（6）截取部分字符串数组内容的构造器

        "String(char[] value, int offset, int count)" 这个构造器的含义是：将字符数组从"offset"指定的位置开始，"count"指定的数目结束，中间的字符连成字符串。

public class Str6 {
    public static void main(String[] args) {
        //初始化一个字符数组c
        char c[] = {'w', 'e', 'l', 'c', 'o', 'm', 'e'};
        //通过构造器，将字符数组中的元素连接成一个字符串，并且从第4个位置开始，总共有4个元素
        String str = new String(c);
        System.out.println(str);
    }
}

 代码说明：第7行实现截取字符串功能，其从第3个位置开始，因为数组位置从0开始，所以这里的3，其实就是从第4个字符c开始，截取4位。

运行结果：come

 2.2字符串处理的方法

（1）串连接

在Java语言中，有两种串连接的方法：一种是使用"+"，另一种是使用方法函数concat(String str)。

//通过加号将两个字符串str1和str2连在一起
public class Str7 {
    public static void main(String[] args) {
        String str1 = "you";
        String str2 = "welcome";
        System.out.println(str1+" "+str2);
    }
}

代码说明：第6行通过"+"符号将str1和str2两个字符串连接在一起。

运行结果：you welcome

上面使用了"+"号运算符连接两个字符串，形成新的字符串。下面通过concat方法将两个字符串连接起来。

public class Str8 {
    public static void main(String[] args) {
        String str1 = "you";
        String str2 = " welcome";
        System.out.println(str1.concat(str2));
    }
}

代码说明：第5行使用了concat()方法，str1先输出，然后是str2。

运行结果：you welcome

（2）提取子字符串

"substring(int beginIndex, int endIndex)"或"substring(int index)"。下面将详细讲述这两个方法的意义和使用方法。

1）"substring(int index)"是指提取从index指定位置开始，一直到字符串的最后。

2）"substring(int beginIndex, int endIndex)"是指提取由"beginIndex"位置开始，到以"endIndex"为结束位置的字符串。

public class str9 {
    public static void main(String[] args) {
        //初始化一个字符串str
        String str = "we are students and he is worker";
        //提取从字符串的第3个元素开始到第10个冤死位置的字符串，并且将其输出
        System.out.println(str.substring(2,10));
    }
}

 代码说明：第4行定义了一个字符串对象str。第7行使用substring(2,10)截取字符串的一部分。

运行结果：are stu

 (3)从字符串中分解字符

从字符串中分解字符的方法是"charAt(int index)",这个方法返回的是一个字符，而不是字符串，这是跟前面方法的区别。参数"index"是指字符串序列中字符的位置。

public class Str10 {
    public static void main(String[] args) {
        String str = "we are students and he is a worker"
        System.out.println(str.charAt(1));
    }
}

代码说明：这个程序输出的是字符串中的第2个字符，因为字符串位置从0开始计算，所以输出的字符是"e"。

运行结果：e

（4）获取字符串的长度

字符串长度使用方法length()获取。

注意 ：数组的长度是“length”属性，而字符串的长度是“length()”方法。数组的长度后面没有括号，得到的数组长度是一个属性值，而得到字符串长度是一个方法。

public class Str11 {
    public static void main(String[] args) {
        String str = "we are students and he is a worker"
        System.out.println(str.length());
    }
}

代码说明：第4行使用了length()方法直接输出str对象的长度。

运行结果：34

（5）测试字符串是否相等

测试字符串是否相等的方法是equals(String str),这个方法区分大小写。

public class Str12 {
    public static void main(String[] args) {
        String str = "administrator";
        String str1 = "administrator";
        if (srt.equals(str1)) {
            System.out.println("密码正确，请登陆系统");
        } else {
            System.out.println("密码不正确，请重新输入密码");
        }
    }
}

 代码说明：第4-5行定义了两个字符串。第6行是判断语句，通过equals()方法判断两个指定的字符串是否相等。

运行结果：密码正确，请登录系统

在现实程序开发中，有的登陆系统对于输入密码的大小写忽略。此时在Java语言中也有一个方法就是equalsIgnoreCase(String str)，这个方法忽略字符串大小写。

（6）查找特定字串

查找字符串字串有3个方法。

1）"indexOf(子串内容）"方法是帮助查找子串，日过返回的是负数，就表示在当前字符串中没有找到所查找的子串。

2）"startsWith(子串内容)"方法测试当前字符串是否以一个子串开始。

3）"endsWith(子串内容）"方法测试当前字符串是否以子串内容为结尾。

public class Str13 {
    public static void main(String[] args) {
        String str = "是一个很优秀的程序员";
        System.out.println(str.indexOf("个");
        System.out,println(str.endsWith("员");
        System.out.println(str.startsWith("明"));
    }
}

 代码说明：str.indexOf("个")是测试字符串中“个”这个子串的位置。str.endWith("员“）是测试字符串"员"是否是这个字符串的结尾。str.startsWith("明”）是测试字符串"明"是否是这个字符串的开始。后面两个方法返回的是布尔型数据。

运行结果：2

                  true

                  false

 （7）从基本类型转换成字符串

使用valueOf()将基本类型的数据转换成相应的字符串。

（8）toString()方法

public class str14 {
    public static void main(String[] args) {
        String str = "小铭是一个很优秀的程序猿";
        System.out.println(str.toString());
    }
}

代码说明：System.out.println(str)输出语句是把对象作为参数，将其内容输出。而上面的程序段则是直接运用toString()方法，将对象中的字符串提取出来，然后再进行输出。

运行结果：小铭是一个很优秀的程序猿

 2.3缓冲字符串StringBuffer类的构造器

（1）默认的构造器

StringBuffer sb = new StringBuffer();

默认构造器是由系统自动分配容量，而系统容量的默认值是16个字符。

public class Str15 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1.capacity);  //输出字符串的容量capacity
        System.out.println(sb1.length());  //输出字符串的长度length
    }
}

运行结果：16

                   0

（2）设定容量大小的构造器

StringBuffer sb = new StringBuffer(int x)

“x”是设置容量的大小值。

public class Str16 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer(40);
        System.out.println(sb1.capacity());
        System.out.println(sb1.length());
        sb1.ensureCapacity(100);
        System.out.println(sb1.capacity());
    }
}

 代码说明：这里通过构造器设定了缓冲字符串对象的容量，虽然容量变了，但长度仍然是0，因为它的内存空间中没有值。capacity()方法代表了字符串对象在内存中，可以容纳字符串的个数。如果想要扩充内存容量，可以使用方法ensureCapacity()。方法length()表示内存中已经存在的字符串的个数，如果想要改变字符串长度，可以使用setLength()方法。

运行结果：40

                  0

                  100

 2.4缓冲字符串的处理

（1）初始化字符串

public class Str17 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer{"小铭是一个优秀")
        //通过append()方法，在这个对象后面添加一个新字符串
        sb.append("的程序猿");
        System.out.println(sb);
    }
}

代码说明：第5行使用append()方法将两个字符串连接在一起，有点像String类的concat()方法。

运行结果：小铭是一个优秀的程序猿

（2）取字符串的单个字符

 charAt()方法返回字符串中的单个字符。

public class Str18 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("小铭是一个优秀");
        System.out.println(sb.charAt(3));
    }
}

代码说明：第3行定义了字符串sb，第4行指定输出sb的第4个元素，因为索引是从0开始的，所以代码是charAt(3)。

运行结果：一

（3）单个字符串赋值

setCharAt()方法对字符串中的单个字符赋值或进行替换。

public class Str19 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("小铭是一个优秀的程序猿");
        sb.setCharAt(0, '大');
        System.out.println(sb);
    }
}
        

 代码说明：setCharAt()这个方法使用的格式是"setCharAt(int index, char ch)"。上面将字符串中的“小”替换成“大”。

运行结果：大铭是一个优秀的程序猿

（4）指定位置插入字符串

insert()方法在字符串指定位置插入值。

public class Str20 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我是一个优秀");
        //使用insert()方法将新字符串插入到指定的位置
        sb.insert(6, "的程序猿");
        System.out.println(sb);
    }
}

代码说明：第5行的结构就是"insert(int index, string str)"。

运行结果：我是一个优秀的程序猿

（5）返回字符串的子串

substring()方法返回字符串的一个子串。

public class Str21 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我是一个程序猿");
        System.out.println(sb.substring(2));
    }
}

代码说明：这个程序返回的是从字符串的第3个位置开始，到最后位置之间的子字符串。

运行结果：一个程序猿

（6）倒置字符串的内容

reverse()方法用来倒置"StringBuffer"的内容

public class Str22 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我是一个程序猿");
        System.out.println(sb.reverse());
    }
}

 代码说明：第四行直接调用reverse()方法，不需要任何参数。

运行结果：猿序程个一是我

3.常见疑难解答

3.1equals和"=="区别

        equals比较的是两个对象的内容，如果不重载equals方法，自动调用object的equals方法，则和"=="一样。在JDK中像String，Integer，默认重载了equals方法，则比较的是对象的内容。在实际编程中，建议使用equals方法。

3.2String类为何被定义成final约束

        主要是考虑"效率"和"安全性"的缘故，若String允许被继承，则其频繁地被使用，可能会降低程序的性能，所以String被定义成final。

3.3char类型如何转换成int类型，int类型如何转换成字符串

char类型转换成int类型

char c = 'A';
int i = c;
//反过来只要做强制转换就ok
c = (char)i;

将整数int转换成字符串String有两种方法：

1）String s = String.valueOf(i);

2）String s = Integer.toString(i);