第4篇 Java中的String类

JAVA String类

字符串是常量；它们的值在创建之后不能改变。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享它们。例如：

String str = "abc";

等效于：

char data[] = {'a', 'b', 'c'}; 
String str = new String(data);

注意事项

 几种String类型定义判断相等的区别：

String str1 = "123";
String str2 = "123";
System.out.println("str1==str2:"+(str1==str2));
System.out.println("str1.equals(str2):"+(str1.equals(str2)));

String str3 = new String("123");;
String str4 = new String("123");        
System.out.println("str3==str4:"+(str3==str4));
System.out.println("str3.equals(str4):"+(str3.equals(str4)));

上面几种比较所得到的结果为：

str1==str2:true
str1.equals(str2):true
str3==str4:false
str3.equals(str4):true

这里对上面几种情况依次分析：

(1) 分别通过双引号进行赋值

String str1 = "123";
String str2 = "123";

在定义str1的时候，"123"这个字符串被建立起来，并被放在常量区当中。这时候再去定义str2时，jvm会首先在常量区中发现已经被建立好的"123"字符串，此时它让str2直接指向该字符串，所以说str1和str2会指向同一个地址

(2) 通过new关键字建立对象

String str3 = new String("123");
String str4 = new String("123");    

在java中对象被存放在堆里面，变量被存放在栈当中，每执行一次new操作，会在堆内存当中新开辟一块内存用来存放该对象的内容，同时通过栈内存中的变量来指向这片内存。

所以虽然str3和str4里面存放的值都相同，但由于new关键字的作用，使两个变量指向的是不同的内存区域。所以在这里使用 “==” 运算符时，得到的结果是false,但使用equals方法得到的却是true

常用方法

• equals()　　           判断值是否相等
• equalsIgnoreCase() 忽略大小写进行对比
• toLowerCase()　　转小写
• toUpperCase()       转大写
• toCharArray()        转字符数组
• indexOf(String str [, int fromIndex])               查找字符串位置
• lastIndexOf(String str [, int fromIndex])         查找字符串最后出现位置
• subString(int beginIndex, int endIndex)        切割子串
• trim()                                  去除空白
• split(String regex)            分割字符串
• startWith(String prefix)    以...开头
• endsWith(String suffix)    以...结尾
• charAt(int index)               获取指定位置字符
• replace(char oldChar, char newChar)    替换指定字符
• valueOf()　　                    指定数据类型变量转字符串

1、toUpperCase()、toLowerCase()

将String字符串中所有的字母都转换大小写，并且不影响原字符串

String str = "123abcABC啊哈";
//将字符串中所有字母转为小写
String lowerStr = str.toLowerCase();
//将字符串中所有字母转为大写
String upperStr = str.toUpperCase();
System.out.println("原字符串："+str);
System.out.println("转小写字符串："+lowerStr);
System.out.println("转大写字符串："+upperStr);

打印结果为：

原字符串：123abcABC啊哈
转小写字符串：123abcabc啊哈
转大写字符串：123ABCABC啊哈

2、toCharArray()与charAt()

toCharArray()方法将String类型的变量转换为一个字符数组，并返回。charAt()方法则类似与把String当成一个字符数组，通过传入下标而得到该位置所对应的字符

例如：判断一个字符串是否是英文字符

/**
 * 字符判断函数
 * @param c 要判断的字符
 * @return 字符是否为英文字符或数字 
 */
public static boolean isC(char c) {
    if(c>='a'&&c<'z'){
        return true;
    } else if (c>='A'&&c<='Z') {
        return true;
    } else if (c>='0'&&c<='9') {
        return true;
    } else {
        return false;
    }
}

/**
 * 主函数
 * @param args
 */
public static void main(String[] args) {        
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入要判断的字符串：");
    String str = scanner.nextLine();
    //通过toCharArry将字符串转成数组，再通过foreach遍历
    for (char c : str.toCharArray()) {        
        if(!isC(c)){
            System.out.println("这里面包含了不是英文的字符'"+c+"'，判断终止！");
            return;                
        }
    }    
    System.out.println("这是个英文字符串");

}

同样的遍历也可以使用charAt()来实现：

char c;
for (int i = 0; i < str.length(); i++) {
    c = str.charAt(i);
    if(!isC(c)){
        System.out.println("这里面包含了不是英文的字符'"+c+"'，判断终止！");
        return;                
    }
}
System.out.println("这是个英文字符串");

得到的都是相同的打印结果：

请输入要判断的字符串：
abcdef123.asd
这里面包含了不是英文的字符'.'，判断终止！

请输入要判断的字符串：
abcdef123asd
这是个英文字符串

3、indexOf、lastIndexOf

这两个方法都用来查找字符串在当前字符串中的位置，唯一区别在于indexOf方法是从第0个元素开始从前往后找而lastIndexOf方法则在第length()-1个元素开始从后往前找，都是找到第一个后就返回，找不到则返回负数。

String str = "abc123a...xyzabz";
//从第0个元素开始从前往后找
System.out.println(str.indexOf("a"));
//从第2个元素（c）开始从前往后找
System.out.println(str.indexOf("a",2));
//从第str.length()-1个元素开始从后往前找
System.out.println(str.lastIndexOf("a"));
//从第2个元素开始从后往前找
System.out.println(str.lastIndexOf("a",11));

得到结果为：

0
6
13
6

4、startsWith、endsWith

判断字符串是否以某个字符串开头或者结尾，类似于正则匹配中的“^” 和 “$”，可以用来判断文件后缀，以此判断文件类型。具体不作演示。

5、trim

用来去除字符串中的前面和尾部的空白，返回该去除空白后的副本，原字符串不受影响

6、split

条件分割。该方法传入一个正则表达式字符串，根据该正则表达式所匹配的字符串对所要操作的字符串进行分割，返回分割所得的字符串数组。原字符串同样不受影响

String str = "(1)abc(2)bcd(3)cde(4)def(5)efg";
//通过正则匹配"(\d)"来匹配所有带括号的序号
String spstr[] = str.split("\\(\\d\\)");
for (String string : spstr) {
    System.out.println(string);
}
//打印分割所得数组长度
System.out.println("数组长度:"+spstr.length);

打印结果为：

abc
bcd
cde
def
efg
数组长度:6

这里需要注意的是正则一共匹配了五次，所以所得的数组长度为6而不是5

7、substring

参数：

　　beginIndex：开始处的索引（包括）

　　endIndex：结束处的索引（不包括）

截取字符串，前闭后开原则，返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，一直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。 

 参数endIndex可以缺失，缺失时代表截取从beginIndex一直到length()-1的所有元素

String str = "abc123...xyz";
//截取从'1'到'.'中间的元素，前闭后开，索引从3到6
String substr = str.substring(3,6);
System.out.println(substr);

所得打印结果为：

123

这里需要注意的是索引从0开始计算

练习

将“Hello one，Dream one。”取出指定字符串中的单词，前后交换，标点符号不变。结果为 One hello，One dream

Scanner scanner = new Scanner(System.in);
System.out.println("请输入被交换的字符串：");
String str = scanner.nextLine();    
String spStr[] = str.split("\\,|\\.|。|，|、|\\?|\\!|？|！|\"|\'");
//交换后的字符串
String newStr = "";                                    
//字符所处在的位置，每次分割标点符号，值加一(标点符号的长度)
int len = 0;                                                                
for (String spl:spStr) {
    //子字符串长度的后一个位置为标点符号位置（位置从0开始计算，长度从1开始计数，所以不用加1）
    len += spl.length();    
    //取出每个单词
    String spWord[] = spl.split(" ");            
    for(int i=0;i<spWord.length;i++){                
        //每两个单词交换一次位置，如果单词个数为奇数，最后一个不作交换
        if(i%2==0&&(i+1<=spWord.length-1)){        
            String temp = spWord[i];
            spWord[i] = spWord[i+1];
            spWord[i+1] = temp;                                                
        }                
    }                        
    for (int i=0;i<spWord.length;i++) {
        newStr += spWord[i];
        if(i<spWord.length-1){
            newStr += " ";                        //单词后面的空格，最后一个单词不加
        }else {
            newStr += str.charAt(len);            //最后一个单词后面加对应标点符号
            len += 1;                            //加上标点符号长度
        }
    }            
}
System.out.println("交换后的字符串为："+newStr);

执行结果为：

请输入被交换的字符串：
Hello One Two Three,Dream One two.
交换后的字符串为：One Hello Three Two,One Dream two.