Java String字符串处理

Java String字符串和整型int的相互转换

String转换为int

String 字符串转整型 int 有以下两种方式：

Integer.parseInt(str)
Integer.valueOf(str).intValue()

int转换为String

整型 int 转 String 字符串类型有以下 3 种方法：

String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" + i;

Java字符串拼接（连接）

String 字符串虽然是不可变字符串，但也可以进行拼接只是会产生一个新的对象。String 字符串拼接可以使用“+”运算符或 String 的 concat(String str) 方法。“+”运算符优势是可以连接任何类型数据拼接成为字符串，而 concat 方法只能拼接 String 类型字符串。

使用连接运算符“+”

与绝大多数的程序设计语言一样，Java 语言允许使用“+”号连接（拼接）两个字符串。“+”运算符是最简单、最快捷，也是使用最多的字符串连接方式。在使用“+”运算符连接字符串和 int 型（或 double 型）数据时，“+”将 int（或 double）型数据自动转换成 String 类型。

使用 concat() 方法

在 Java 中，String 类的 concat() 方法实现了将一个字符串连接到另一个字符串的后面。concat() 方法语法格式如下：

字符串 1.concat(字符串 2);

执行结果是字符串 2 被连接到字符串 1 后面，形成新的字符串。

连接其他类型数据

前面介绍的例子都是字符串与字符串进行连接，其实字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，此时会将这些数据直接转换成字符串。

注意：只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应该谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。

Java获取字符串长度（length()）

在 Java 中，要获取字符串的长度，可以使用 String 类的 length() 方法，其语法形式如下：

字符串名.length();

Java字符串大小写转换（toLowerCase()和toUpperCase()）

String 类的 toLowerCase() 方法可以将字符串中的所有字符全部转换成小写，而非字母的字符不受影响。语法格式如下：

字符串名.toLowerCase()    // 将字符串中的字母全部转换为小写，非字母不受影响

toUpperCase() 则将字符串中的所有字符全部转换成大写，而非字母的字符不受影响。语法格式如下：

字符串名.toUpperCase()    // 将字符串中的字母全部转换为大写，非字母不受影响

Java去除字符串中的空格（trim()）

字符串中存在的首尾空格一般情况下都没有任何意义，如字符串“ Hello ”，但是这些空格会影响到字符串的操作，如连接字符串或比较字符串等，所以应该去掉字符串中的首尾空格，这需要使用 String 类提供的 trim() 方法。

trim() 方法的语法形式如下：

字符串名.trim()

如果不确定要操作的字符串首尾是否有空格，最好在操作之前调用该字符串的 trim() 方法去除首尾空格，然后再对其进行操作。

注意：trim() 只能去掉字符串中前后的半角空格（英文空格），而无法去掉全角空格（中文空格）。可用以下代码将全角空格替换为半角空格再进行操作，其中替换是 String 类的 replace() 方法。

str = str.replace((char) 12288, ' ');    // 将中文空格替换为英文空格
str = str.trim();

Java截取（提取）子字符串（substring()）

在 String 中提供了两个截取字符串的方法，一个是从指定位置截取到字符串结尾，另一个是截取指定范围的内容。下面对这两种方法分别进行介绍。

java 1. substring(int beginIndex) 形式

此方式用于提取从索引位置开始至结尾处的字符串部分。调用时，括号中是需要提取字符串的开始位置，方法的返回值是提取的字符串。例如：

String str = "我爱 Java 编程";
String result = str.substring(3);
System.out.println(result);    // 输出：Java 编程

2. substring(int beginIndex，int endIndex) 形式

此方法中的 beginIndex 表示截取的起始索引，截取的字符串中包括起始索引对应的字符；endIndex 表示结束索引，截取的字符串中不包括结束索引对应的字符，如果不指定 endIndex，则表示截取到目标字符串末尾。该方法用于提取位置 beginIndex 和位置 endIndex 位置之间的字符串部分。

这里需要特别注意的是， 对于开始位置 beginIndex， Java 是基于字符串的首字符索引为 0 处理的，但是对于结束位置 endIndex，Java 是基于字符串的首字符索引为 1 来处理的，如图 1 所示。

注意：substring() 方法是按字符截取，而不是按字节截取

Java分割字符串（spilt()）

String 类的 split() 方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中。该方法主要有如下两种重载形式：

str.split(String sign)
str.split(String sign,int limit)

其中它们的含义如下：
str 为需要分割的目标字符串。
sign 为指定的分割符，可以是任意字符串。
limit 表示分割后生成的字符串的限制个数，如果不指定，则表示不限制，直到将整个目标字符串完全分割为止。

使用分隔符注意如下：

1）“.”和“|”都是转义字符，必须得加“\”。
如果用“.”作为分隔的话，必须写成String.split(“\.”)，这样才能正确的分隔开，不能用String.split(“.”)。
如果用“|”作为分隔的话，必须写成String.split(“\|”)，这样才能正确的分隔开，不能用String.split(“|”)。

2）如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“acount=? and uu =? or n=?”，把三个都分隔出来，可以用String.split(“and|or”)。

Java字符串的替换（replace()、replaceFirst()和replaceAll()）

在 Java 中，String 类提供了 3 种字符串替换方法，分别是 replace()、replaceFirst() 和 replaceAll()，本文将详细介绍它们的使用方法。

replace() 方法

replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：

字符串.replace(String oldChar, String newChar)

其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar。

replaceFirst() 方法

replaceFirst() 方法用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串，其语法形式如下：
字符串.replaceFirst(String regex, String replacement)
其中，regex 表示正则表达式；replacement 表示用于替换的字符串。例如：

String words = "hello java，hello php";
String newStr = words.replaceFirst("hello","你好 ");
System.out.println(newStr);    // 输出：你好 java,hello php

replaceAll() 方法

replaceAll() 方法用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串，其语法形式如下：
字符串.replaceAll(String regex, String replacement)
其中，regex 表示正则表达式，replacement 表示用于替换的字符串。例如：

String words = "hello java，hello php";
String newStr = words.replaceAll("hello","你好 ");
System.out.println(newStr);    // 输出：你好 java,你好 php

Java字符串比较（3种方法）

字符串比较是常见的操作，包括比较相等、比较大小、比较前缀和后缀串等。在 Java 中，比较字符串的常用方法有 3 个：equals() 方法、equalsIgnoreCase() 方法、 compareTo() 方法。下面详细介绍这 3 个方法的使用。

equals() 方法

equals() 方法将逐个地比较两个字符串的每个字符是否相同。如果两个字符串具有相同的字符和长度，它返回 true，否则返回 false。对于字符的大小写，也在检查的范围之内。equals() 方法的语法格式如下：

str1.equals(str2);

str1 和 str2 可以是字符串变量， 也可以是字符串字面量。

equalsIgnoreCase() 方法

equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。当比较两个字符串时，它会认为 A-Z 和 a-z 是一样的。

equals()与==的比较

equals() 方法比较字符串对象中的字符。而==运算符比较两个对象引用看它们是否引用相同的实例。
下面的程序说明了两个不同的字符串（String）对象是如何能够包含相同字符的，但同时这些对象引用是不相等的：

String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1.equals(s2)); // 输出true
System.out.println(s1 == s2); // 输出false

变量 s1 指向由“Hello”创建的字符串实例。s2 所指的的对象是以 s1 作为初始化而创建的。因此这两个字符串对象的内容是一样的。但它们是不同的对象，这就意味着 s1 和 s2 没有指向同一的对象，因此它们是不==的。

因此，千万不要使用==运算符测试字符串的相等性，以免在程序中出现糟糕的 bug。从表面上看，这种 bug 很像随机产生的间歇性错误。

对于习惯使用 C++ 的 String 类的人来说，在进行相等性检测的时候一定要特别小心。C++ 的 String 类重载了= = 运算符以便检测字符串内容的相等性。可惜 Java 没有采用这种方式，它的字符串“看起来、感觉起来”与数值一样，但进行相等性测试时，其操作方式又类似于指针。语言的设计者本应该像对 C++ 那样也进行特殊处理， 即重定义 ==运算符。

当然，每一种语言都会存在一些不太一致的地方。C 程序员从不使用==对字符串进行比较，而使用 strcmp 函数。Java 的 compareTo 方法与 strcmp 完全类似。所以下面我们来介绍 Java 的 compareTo 方法。

compareTo() 方法

通常，仅仅知道两个字符串是否相同是不够的。对于排序应用来说，必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串（String）的 compareTo() 方法实现了这种功能。

compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。compareTo() 方法的语法格式如下：

str.compareTo(String otherstr);

它会按字典顺序将 str 表示的字符序列与 otherstr 参数表示的字符序列进行比较。如果按字典顺序 str 位于 otherster 参数之前，比较结果为一个负整数；如果 str 位于 otherstr 之后，比较结果为一个正整数；如果两个字符串相等，则结果为 0。

Java中容易混淆的空字符串和null

“”是一个长度为 0 且占内存的空字符串，在内存中分配一个空间，可以使用 Object 对象中的方法。例如：
“”.toString()

null 是空引用，表示一个对象的值，没有分配内存，调用 null 的字符串的方法会抛出空指针异常。例如如下代码：

String str = null;
System.out.println(str.length());

new String() 创建一个字符串对象的默认值为 “”，String 类型成员变量的初始值为 null。

空字符串 “” 是长度为 0 的字符串。可以调用以下代码检查一个字符串是否为空：

if (str.length() == 0)

或

if (str.equals(""))

空字符串是一个 Java 对象，有自己的串长度（0）和内容（空）。不过，String 变量还可以存放一个特殊的值，名为 null，这表示目前没有任何对象与该变量关联。要检查一个字符串是否为 null，要使用以下条件：

if (str == null)

有时要检查一个字符串既不是 null 也不为空串，这种情况下就需要使用以下条件：

if (str != null && str.length() != 0)

注意：首先要检查 str 不为 null。如果在一个 null 值上调用方法，会出现错误。
示例如下：

public static void main(String[] args) {
    String str1 = new String();
    String str2 = null;
    String str3 = "";
    System.out.println(str3.length()); // 空字符串""的长度为0
    System.out.println(str2.length()); // 抛出空指针异常
    System.out.println(str1); // 输出""
    System.out.println(str1 == str2); // 内存地址的比较，返回false
    System.out.println(str1.equals(str2)); // 值的比较，返回false
    System.out.println(str2 == str3); // 内存地址的比较，返回false
    System.out.println(str3.equals(str2)); // 值的比较，返回false
    System.out.println(str1 == str3); // 内存地址的比较，返回false
    System.out.println(str1.equals(str3)); // 值的比较，返回true
}

Java字符串查找（3种方法）

在给定的字符串中查找字符或字符串是比较常见的操作。字符串查找分为两种形式：一种是在字符串中获取匹配字符（串）的索引值，另一种是在字符串中获取指定索引位置的字符。

根据字符查找

String 类的 indexOf() 方法和 lastlndexOf() 方法用于在字符串中获取匹配字符（串）的索引值。

1. indexOf() 方法

indexOf() 方法用于返回字符（串）在指定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。该方法主要有两种重载形式：

str.indexOf(value)
str.indexOf(value,int fromIndex)

其中，str 表示指定字符串；value 表示待查找的字符（串）；fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。

2. lastlndexOf() 方法

lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。该方法也有两种重载形式：

str.lastIndexOf(value)
str.lastlndexOf(value, int fromIndex)

注意：lastIndexOf() 方法的查找策略是从右往左查找，如果不指定起始索引，则默认从字符串的末尾开始查找。

根据索引查找

String 类的 charAt() 方法可以在字符串内根据指定的索引查找字符，该方法的语法形式如下：

字符串名.charAt(索引值)

提示：字符串本质上是字符数组，因此它也有索引，索引从零开始。

Java StringBuffer类详解

在 Java 中，除了通过 String 类创建和处理字符串之外，还可以使用 StringBuffer 类来处理字符串。StringBuffer 类可以比 String 类更高效地处理字符串。

因为 StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。

创建 StringBuffer 类

StringBuffer 类提供了 3 个构造方法来创建一个字符串，如下所示：

StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

追加字符串

StringBuffer 类的 append() 方法用于向原有 StringBuffer 对象中追加字符串。该方法的语法格式如下：

StringBuffer 对象.append(String str)

该方法的作用是追加内容到当前 StringBuffer 对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer 对象的内容也发生了改变，

替换字符

StringBuffer 类的 setCharAt() 方法用于在字符串的指定索引位置替换一个字符。该方法的语法格式如下：

StringBuffer 对象.setCharAt(int index, char ch);

该方法的作用是修改对象中索引值为 index 位置的字符为新的字符 ch。

反转字符串

StringBuffer 类中的 reverse() 方法用于将字符串序列用其反转的形式取代。该方法的语法格式如下：

StringBuffer 对象.reverse();

删除字符串

StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法，下面详细介绍。

1. deleteCharAt() 方法

deleteCharAt() 方法用于移除序列中指定位置的字符，该方法的语法格式如下：

StringBuffer 对象.deleteCharAt(int index);

deleteCharAt() 方法的作用是删除指定位置的字符，然后将剩余的内容形成一个新的字符串。

2. delete() 方法

delete() 方法用于移除序列中子字符串的字符，该方法的语法格式如下：

StringBuffer 对象.delete(int start,int end);

其中，start 表示要删除字符的起始索引值（包括索引值所对应的字符），end 表示要删除字符串的结束索引值（不包括索引值所对应的字符）。该方法的作用是删除指定区域以内的所有字符。

String、StringBuffer和StringBuilder类的区别

在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。String 类是不可变类，即一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。

Java 提供了两个可变字符串类 StringBuffer 和 StringBuilder，中文翻译为“字符串缓冲区”。

StringBuilder 类是 JDK 1.5 新增的类，它也代表可变字符串对象。实际上，StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。

StringBuffer、StringBuilder、String 中都实现了 CharSequence 接口。CharSequence 是一个定义字符串操作的接口，它只包括 length()、charAt(int index)、subSequence(int start, int end) 这几个 API。

StringBuffer、StringBuilder、String 对 CharSequence 接口的实现过程不一样，如下图 1 所示：
对CharSequence接口的实现

图 1 对CharSequence接口的实现

可见，String 直接实现了 CharSequence 接口，StringBuilder 和 StringBuffer 都是可变的字符序列，它们都继承于 AbstractStringBuilder，实现了 CharSequence 接口。
总结
String 是 Java 中基础且重要的类，被声明为 final class，是不可变字符串。因为它的不可变性，所以拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

StringBuffer 就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类。它提供了 append 和 add 方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列。

在很多情况下我们的字符串拼接操作不需要线程安全，所以 StringBuilder 登场了。StringBuilder 是 JDK1.5 发布的，它和 StringBuffer 本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。
线程安全：
StringBuffer：线程安全
StringBuilder：线程不安全
速度：
一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。
使用环境：
操作少量的数据使用 String。
单线程操作大量数据使用 StringBuilder。
多线程操作大量数据使用 StringBuffer。