Java中的String类

最新推荐文章于 2024-06-20 13:43:21 发布

天下闻

最新推荐文章于 2024-06-20 13:43:21 发布

阅读量266

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/jiangbw415/article/details/82456652

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、String 的声明和创建

双引号括起来的字符序列就是 String 的直接量。实例:”Joy” 或”666”

字符串赋值，可以在声明时赋值

String color = “red”;

color 是 String 类型的引用。

“red” 是 String 直接量。

String 直接量是存放在栈内存里，所以一旦定义值就不能改变了，只能是让变量指向新的内存空间。比如：

color = "blue";

如果采用 new 的方法定义 String，那么是需要分配堆内存空间的，如下：

String str = new String("Hello");

一共有两个对象，在栈和堆内存中各有一个对象，内容都是”Hello”。

String 的还有两个常用的构造方法：

String(byte[] arr) 使用一个字节数组 arr 创建一个字符串对象。
String(char[] arr) 使用一个字符数组 arr 创建一个字符串对象。

char[] arr={'H','e','l','l','o'};
String str = new String(arr);
//相当于
String str = new String("Hello")

String(char[] arr,int startIndex,int count) 提取字符数组 a 中的一部分字符创建一个字符串对象，参数 startIndex 和 count 分别指定在 a 中提取字符的起始位置和从该位置开始截取的字符个数，例如：

char[] arr={'H','e','l','l','o'};
String str = new String(arr,1,3);
//相当于
String str = new String("ell");

二、String 的常用方法

得到字符串的长度

public int length()

返回 String 的长度，是按照 char 返回的长度

与数组不同之处: String 类不含有 length 成员域（属性）

String str = "Java与Android笔记";
System.out.println(str.length());//14

比较字符串

对于字符串，使用“\==”比较的是内存地址，一般不使用“\==”比较字符串。

public boolean equals(Object s)

比较两个 String 对象的实体是否相等，这个是区分大小写的。实际上就是依次比较其所包含的字符的数值大小。

String s1= new String("Java与Android笔记");
String s2= new String("Java与Android笔记");
System.out.println(s1.equals(s2));//true

public int compareTo(String s)：

比较两个字符串的大小。返回 0 表示相等，返回大于 0 的数表示前面的字符串大于后面的字符串，返回小于 0 表示前面的字符串小于后面的字符串，区分大小写的。如下：

public class Test {
    public static void main(String[] args) {
        String str = "JAVA与ANDROID笔记";
        String str2 = "java与android笔记";
        if (str.compareTo(str2) == 0) {
            System.out.println("the str 等于 str2");
        } else if (str.compareTo(str2) > 0) {
            System.out.println("the str 大于 str2");
        } else if (str.compareTo(str2) < 0) {
            System.out.println("the str 小于 str2");
        }
    }
}

运行结果：

the str 小于 str2

public int compareToIgnoreCase(String s)：

忽略大小写，比较两个字符串的大小。返回 0 表示相等，返回大于 0 的数表示前面的字符串大于后面的字符串，返回小于 0 表示前面的字符串小于后面的字符串。如下：

public class Main {
    public static void main(String[] args) {
        String str = "JAVA与ANDROID笔记";
        String str2 = "java与android笔记";
        if (str.compareToIgnoreCase(str2) == 0) {
            System.out.println("the str 等于 str2");
        } else if (str.compareToIgnoreCase(str2) > 0) {
            System.out.println("the str 大于 str2");
        } else if (str.compareToIgnoreCase(str2) < 0) {
            System.out.println("the str 小于 str2");
        }
    }
}

运行结果：

the str 等于 str2

public boolean equalsIgnoreCase(String s)

比较两个 String 对象的值是否相等，忽略大小写。

String s1= new String("Java与Android笔记");
String s2= new String("java与android笔记");
System.out.println(s1.equalsIgnoreCase(s2));//true

public boolean startsWith(Stirng prefix)

测试此字符串是否以指定的前缀开始，如下：

public class Main {
    public static void main(String[] args) {
        String str = "Java与Android笔记";
        String str2 = "Android";
        String str3 = "Java";
        System.out.println(str.startsWith(str2));
        //false
        System.out.println(str.startsWith(str3));
        //true
    }
}

public boolean startsWith(String prefix,int toffset)

测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

public class Main {
    public static void main(String[] args) {
        String str = "Java与Android笔记";
        String str2 = "Android";
        System.out.println(str.startsWith(str2, 3));
        //false
        System.out.println(str.startsWith(str2, 5));
        //true
    }
}

public boolean endsWith(String suffix)

测试此字符串是否以指定的后缀结束。

public class Main {
    public static void main(String[] args) {
        String str = "Java与Android笔记";
        String str2 = "笔记";
        String str3 = "Android";
        System.out.println(str.endsWith(str2));
        //true
        System.out.println(str.endsWith(str3));
        //false
    }
}

public boolean regionMatches(int firstStart,String other,int otherStart,int length)

测试两个字符串区域是否相等。从当前字符串参数 firstStart 指定的位置开始，取长度为length 的一个子字符串，并将这个子字符串和参数 other 指定的一个子字符串进行比较，其中，other 指定的子字符串是从参数 otherStart 指定的位置开始，从 other 中取长度为 length 的一个子字符串，如果两个子字符串相同该方法就返回 true，否则返回 false。

下面的例子是判断一个字符串中共出现几个“co”：

public class Main {
    public static void main(String[] args) {
        int num=0;
        String s= "collection,conn,second,cool";
        for(int i=0;i<s.length();i++){
            if(s.regionMatches(i, "cool", 0, 2)){
                num++;
            }
        }
        System.out.println(num);//4
    }
}

public boolean regionMatches(boolean b,int firstStart,String other, int otherStart,int length)

regionMatches 方法的重载方法，可以通过参数 b 决定是否忽略大小写，当 b 取 true 时，忽略大小写。

字符串检索

public char charAt(int index)

获得字符串指定位置的字符。

public int indexOf(int ch)

返回指定字符 ch 在此字符串中第一次出现处的索引。

String name="JavaAndAndroid";
System.out.println(name.indexOf('A'));//4

public int indexOf(String str)

返回第一次找到字符串 str 时的索引，如果没有找到，则返回-1。实例:

String name="JavaAndAndroid";
System.out.println(name.indexOf("ro"));//10
System.out.println(name.indexOf("cd"));//-1

public int indexOf(int ch,int fromIndex)

从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引，如果没有找到，则返回-1。

String name="JavaAndAndroid";
System.out.println(name.indexOf('r',5));//10

public int indexOf(String str,int fromIndex)

从指定的索引开始搜索，返回在此字符串中第一次出现指定字符串处的索引，如果没有找到则返回-1。

String name="JavaAndAndroid";
System.out.println(name.indexOf("oi",3));//11

public int lastIndexOf(String str)

返回指定子字符串在此字符串中最右边出现处的索引。laseIndexOf 有四中重载方法，用法和 indexOf 相似。

截取字符串

public String substring(int beginIndex)

返回新的字符串，它是当前字符串的子串。该子串从指定的位置开始，并一直到当前字符串结束为止。

public String substring(int beginIndex,int endIndex)

返回新的字符串，它是当前字符串的子串。该子串从指定的位置(beginIndex )开始，到指定的位置(endIndex - 1)结束。例如：

System.out.println("unhappy".substring(2));
//返回 "happy"
System.out.println("Harbison".substring(3)); 
//返回 "bison"
System.out.println("emptiness".substring(9));
//返回 ""(空串)
System.out.println("emptiness".substring(10)); 
//返回 java.lang.StringIndexOutOfBoundsException: String index out of range: -1
System.out.println("hamburger".substring(4,8)); 
//返回 "urge"
System.out.println("smiles".substring(1,5));
//返回 "mile

替换

public String trim()

返回新字符串，截去了源字符串最前面和最后面的的空白符

如果字符串没有被改变，则返回源字符串的引用

public String replace(char oldChar,char newChar)
public String replace(CharSequence target, CharSequence replacement)

返回一个新的字符串，它是将字符串中的所有 oldChar 替换成 newChar

源字符串没有发生变化

如果该字符串不含 oldChar, 则返回源字符串的引用。

示例：

"Java And Android".replace('d','o');//返回"Java Ano Anoroio"
"Android".replace('q','x'); //结果返回"Android" (没有发生变化)

public String replaceAll(String regex, String replacement)

使用给定的 replacement 替换此字符串中所有匹配给定的正则表达式的子字符串。

源字符串没有发生变化

如果该字符串不含 regex, 则返回源字符串的引用。

String s= "collection,cool,connection";
System.out.print(s.replaceAll("tion", "all"));
//collecall,cool,connecall

public String toUpperCase( )

返回对应的新字符串，所有小写字母都变为大写的，其它的不变。

如果没有字符被修改，则返回字符串的引用

public String toLowerCase（）

返回对应的新字符串，所有大写字母都变为小写的，其它的不变。
如果没有字符被修改，则返回字符串的引用

字符串分解成数组

public byte[] getBytes()

使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

public byte[] getBytes(Charset charset)

使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。对于字符串中的汉字，是按照 char 来计算的，一个中文汉字占两个字节，也就是说，通过length()得到的是字符串 char 的长度，而不是字节数，利用这个特点，就可以进行中文判断了。

例如：如何判断一个字符串里面有没有中文呢？如果字符串对应的 byte[]和 char[]的长度是不一样的，那就说明包含中文，还可以顺带计算出有几个汉字。

public class Main {
    public static void main(String[] args) {
        String str = "欢迎关注Java与Android笔记";
        int charLen = str.length();
        int byteLen = str.getBytes().length;
        if (byteLen > charLen) {
            int chineseNum = (byteLen - charLen)/2;//一个汉字占2个字符
            System.out.println("str包含汉字，汉字共" + chineseNum + "个");
        } else {
            System.out.println("str没有包含汉字");
        }
    }
}

运行结果：

str包含汉字，汉字共6个

public void getChars(int srcBegin,intsrcEnd, char[] dst,int dstBegin)

拷贝字符串的部分字符序列到指定的字符数组的指定位置;

要复制的第一个字符位于索引 srcBegin 处；要复制的最后一个字符位于索引 srcEnd-1 处（因此要复制的字符总数是 srcEnd-srcBegin）。要复制到 dst 子数组的字符从索引 dstBegin 处开始，并结束于索引。

char[] arr={'1','2','3','4','5','6'};
String s= "collection";
s.getChars(4, 7, arr, 2);
for(char c:arr){
    System.out.print(c+",");
}

执行结果：1,2,e,c,t,6,

public char[] toCharArray()

将此字符串转换为一个新的字符数组。

public String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串，得到拆分好的字符串数组，示例如下：

public class Main {
    public static void main(String[] args) {
        String str = "Java与Android笔记";
        String tempS[] = str.split("与");// 按照"与"对字符串进行拆分
        for (int i = 0; i < tempS.length; i++) {
            System.out.println("tempS[" + i + "]===" + tempS[i]);
        }
    }
}

运行结果

tempS[0]===Java

tempS[1]===Android笔记

注意：

如果用“.”作为分隔的话，必须是如下写法：String.split(“\.”),这样才能正确的分隔开，不能用 String.split(“.”);
如果用“|”作为分隔的话，必须是如下写法：String.split(“\|”),这样才能正确的分隔开，不能用 tring.split(“|”);

因为“.”和“|”都是转义字符，必须得加“\\”;

展示字符串

public String concat（String str）

拼接两个字符串，并返回一个新字符串。

源字符串不会被修改。

s1.concat( s2 ) 返回字符串 s1 和 s2 拼接的结果。

示例：

String s1 = "Java";
String s2 = "Android";
s1 = s1.concat(s2); // 等同于 s1 = s1 + s2;

public static String valueOf（参数列表）

将参数的值转化成相应的字符串。

valueOf(char[] data) 返回 new String(data);

valueOf(char[] data, int offset,int count)返回 new String(data,offset,count);

其它 valueOf 方法的参数的类型: boolean、char、int、long、float、double 和Object 对象还可以通过方法 toString 转化成字符串。

public String toString( )

由于源对象就是字符串了，所以返回字符串本身。

其它引用类型也可以通过重写方法 toString，生成相应的字符串。
这里写图片描述

天下闻

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的String类

一、String 的声明和创建双引号括起来的字符序列就是 String 的直接量。实例:”Joy” 或”666”字符串赋值，可以在声明时赋值 String color = “red”; color 是 String 类型的引用。 “red” 是 String 直接量。String 直接量是存放在栈内存里，所以一旦定义值就不能改变了，只能是让变量指向新的内存空间。...
复制链接

扫一扫

专栏目录