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

得到结果为：

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

所得打印结果为：

这里需要注意的是索引从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.

posted @ 2018-07-04 21:42 Zero_Yi 阅读(334) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Zero_Yi