String的方法

最新推荐文章于 2024-03-17 23:38:58 发布
最新推荐文章于 2024-03-17 23:38:58 发布
阅读量140 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59378215/article/details/119830088
版权

1、系列一：

（1）boolean isEmpty()：字符串是否为空
     str != null && str.isEmpty()

（2）int length()：返回字符串的长度
    面试题：数组的length和String的length有什么区别？
        数组名.length   属性，没有（）
        字符串对象.length()  方法，有()
    面试题：length()是什么长度？
        字符串的长度，它是内部char[] value的长度。即字符的个数。

（3）String concat(xx)：拼接，等价于+

（4）boolean equals(Object obj)：比较字符串是否相等，区分大小写
（5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
（6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
（7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写

（8）String toLowerCase()：将字符串中大写字母转为小写
（9）String toUpperCase()：将字符串中小写字母转为大写

Character包装类中也有 toLowerCase() 和 toUpperCase()方法，
只不过它是针对一个字符转大小写，而String类中是针对一串字符串转大小写。

（10）String trim()：去掉字符串前后空白符，即不会去掉中间的空白符

public class TestStringMethod1 {
    @Test
    public void test06() {
        String str1 = "hello";
        String str2 = str1.trim(); //这句代码，并没有修改str1，那么没有产生新对象
        System.out.println(str1 == str2);//true
        System.out.println(str1.equals(str2));//true
    }

    @Test
    public void test05() {
        String str1 = "  hello  ";
        String str2 = str1.trim();//"hello"  产生新对象
        System.out.println(str1 == str2);//false
        System.out.println(str1.equals(str2));//false   空格也是字符串内容
    }
    @Test
    public void test04() {
        String str = "  hello  ";
        str.trim();  //如果字符串修改了，会返回新对象，如果没有重新接收新对象，str不变
        System.out.println(str.length());//9
        System.out.println("[" + str + "]");

        str = str.trim();
        System.out.println(str.length());//5
        System.out.println("[" + str + "]");
    }


    @Test
    public void test03(){
        String str = "       ";
        //问？str去掉前后空白符之后是否是空字符串
        if(str != null && str.trim().isEmpty()){
            System.out.println("是");
        }else{
            System.out.println("不是");
        }
    }


    @Test
    public void test02(){
        String str = "   hello   world    ";
        System.out.println("[" + str.trim() +"]"); //[hello   world]
    }

    @Test
    public void test01(){
        String str = "hello";
        System.out.println(str.length());
    }
}

2、系列二：查找
（1）是否包含某个字符/子串
boolean contains("查找目标")

（2）返回某个字符/子串在当前字符串中的位置
int indexOf(查找目标)：如果目标存在，就返回它第一次出现的下标，不存在就返回-1
int lastIndexOf(查找目标)：如果目标存在，就返回它最后一次出现的下标，不存在就返回-1

public class TestStringMethod2 {
    @Test
    public void test02(){
        String str = "hellojavaworldjavaatguigujava";
        System.out.println(str.indexOf('s'));//-1
        System.out.println(str.indexOf("java"));//5
        System.out.println(str.lastIndexOf("java"));//25
    }

    @Test
    public void test01(){
        String str = "hellojavaworldatguigu";
        System.out.println(str.contains("s"));//false
        System.out.println(str.contains("java"));//true
    }
}

3、系列三：截取
（1）String substring(int beginIndex) ：从当前字符串（即调用substring的字符串)中截取子串，从[beginIndex]开始截取，一直到最后
（2）String substring(int beginIndex, int endIndex)：从当前字符串中截取子串，从[beginIndex]开始截取到[endIndex]，并且endIndex不包含。

public class TestStringMethod3 {
    @Test
    public void test02(){
        String str = "hellojavaworldjavaatguigujava";

        //想要把str中的hello,world,atguigu截取出来，怎么做？
        int index;
        while((index = str.indexOf("java")) != -1){
            String temp = str.substring(0,index);
            System.out.println("temp = " + temp);

            str = str.substring(index + "java".length());
            /*
            第一次循环   str = worldjavaatguigujava
             */
            System.out.println("str = " + str);
        }
    }

    @Test
    public void test01(){
        String fileName = "HelloWorld.java";
        //截取文件名“HelloWorld”，不要后缀名
        //(1)找到.的位置
        int index = fileName.indexOf(".");
        //(2)从fileName中截取[0 ,.的位置)
        String name = fileName.substring(0, index);
        System.out.println("name = " + name);
        
        //截取后缀名
        //找到.的位置之后，从.的位置，截取到最后
        String ext = fileName.substring(index);
        System.out.println("ext = " + ext);
    }
}

4、系列四：和char有关的
（1）char charAt(int index)
（2）char[] toCharArray()
（3）new String(char[] arr)
（3）new String(char[] arr,int offset, int length)
  (4)String.valueOf(char[] arr)
  (4)String.valueOf(char[] arr,int offset, int length)
 (5)String.copyValueOf(char[] arr)
 (5)String.copyValueOf(char[] arr,int offset, int length)

public class TestStringMethod4 {
    @Test
    public void test4(){
        char[] arr = {'h','j','f','a','d'};
        String s = new String(arr);
        System.out.println("s = " + s);

        String s1 = new String(arr, 1, 3);
        System.out.println("s1 = " + s1);
    }
    @Test
    public void test3(){
        String str = "hello";
        char[] array = str.toCharArray();
        for(int i=0; i<array.length; i++){
            System.out.println(array[i]);
        }
    }


    @Test
    public void test2(){
        String str = "hello";
        for(int i=0; i<str.length(); i++){
            System.out.println(str.charAt(i));
        }

    }
    @Test
    public void test(){
        Scanner input = new Scanner(System.in);
        System.out.print("性别：");
        char gender = input.next().charAt(0);
        System.out.println("gender = " + gender);
        /*
        （1）
        input是一个变量，它是Scanner类型，
        =右边是调用Scanner的有参构造创建了Scanner对象，实参是System.in的常量对象。
        调用的是public Scanner(InputStream source) 构造器，因为System.in是InputStream类型。

        （3）input.next()是调用input对象的next()，这个方法是Scanner类中声明的。
        它是一个非静态的方法。public String next()
        返回值类型是一个String类型字符串对象

        xx.charAt(0)，就行把input.next()返回的字符串对象，再次调用方法，这个方法是String类的。
        其中的(0)的(0)表示取String的第一个字符，也就是String对象中char[] value数组的[0]元素。
         */
    }
}

5、系列五：编码与解码
编码：把字符数据转为字节数据
解码：把字节数据转为字符数据，因为人只能看懂字符，所以把这个过程称为解码。

编码的方法：
byte[] getBytes()：默认按照平台的字符编码方式进行编码的，
        例如：当前项目的编码方式是UTF-8，那么"尚硅谷".getBytes()就是按照UTF-8进行的编码
byte[] getBytes(Charset charset)
byte[] getBytes(String charsetName)

结论：(1)同样的字符，特别是中文等非ASCII码范围内的，不同的编码方式，得到的编码值是不同的，
     换句话说，编码方式不同，那么互相是无法正确解码的，就会导致乱码。
    （2）如果中间缺字节，也会导致乱码。


 解码的方法：
 new String(byte[] data)：默认按照平台的字符编码方式进行解码
 new String(byte[] data, Charset charset)：按照指定的字符编码方式进行解码
 new String(byte[] data, String charsetName) ：按照指定的字符编码方式进行解码

 总结：不乱码的话要保证编码和解码的编码方式一致，中间不能多和少字节数据。

public class TestStringMethod5 {
    @Test
    public void test07(){
        //如何得到一个汉字等字符的Unicode编码
        int num = '尚';
        System.out.println("num = " + num);//23578
    }

    @Test
    public void test06()throws UnsupportedEncodingException{
        //这个自己数组是按照“GBK”编码的
        byte[] data = {-55, -48, -71, -24, -71, -56, 97, 98, 99};//这个字节数组可能是从文件读取的，也可能是从网络接收的，
        //下面解码看一下具体的内容
        String str = new String(data);//默认按照平台的字符编码方式进行解码，而当前运行环境是UTF-8
        System.out.println(str);//��abc

        String str2 = new String(data, "GBK");
        System.out.println(str2);//尚硅谷abc
    }

    @Test
    public void test05(){
        try {
            System.out.println(Arrays.toString("尚硅谷abc".getBytes()));//[-27, -80, -102, -25, -95, -123, -24, -80, -73, 97, 98, 99]
            System.out.println(Arrays.toString("尚硅谷abc".getBytes("GBK")));//[-55, -48, -71, -24, -71, -56, 97, 98, 99]
            System.out.println(Arrays.toString("尚硅谷abc".getBytes("ISO8859-1")));//[63, 63, 63, 97, 98, 99]
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test04(){
        try {
            System.out.println(Arrays.toString("hello".getBytes()));//[104, 101, 108, 108, 111]
            System.out.println(Arrays.toString("hello".getBytes("GBK")));//[104, 101, 108, 108, 111]
            System.out.println(Arrays.toString("hello".getBytes("ISO8859-1")));//[104, 101, 108, 108, 111]
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test03(){
        try {
            String str1 = "尚硅谷";
            byte[] data = str1.getBytes("GBK");
            System.out.println(Arrays.toString(data));
            //[-55, -48, -71, -24, -71, -56]
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test02(){
        String str1 = "尚硅谷";
        byte[] data = str1.getBytes(); //在我们当前运行环境下  等价于byte[] data = str1.getBytes("UTF-8");
        System.out.println(Arrays.toString(data));
        //[-27, -80, -102, -25, -95, -123, -24, -80, -73]
    }

    @Test
    public void test01(){
        String str1 = "hello";
        byte[] data = str1.getBytes();
        System.out.println(Arrays.toString(data));
        //[104, 101, 108, 108, 111]
    }
}
public class TestStringMethod7 {

    @Test
    public void test05(){
        //密码要求：必须有大写字母，小写字母，数字组成，6位
        System.out.println("Cly892".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("1A2c45".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("Clyyyy".matches("^(?=.*[A-Z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//false

        //下面这个写法只是说，6位字符都在 [A-Za-z0-9]范围内，并没有要求必须有大写、小写、数字都出现
        System.out.println("123456".matches("[A-Za-z0-9]{6}"));
    }

    @Test
    public void test04(){
        String str1 = "12hela3h3salgH2";

        //判断str1字符串是否有字母和数字和下划线等组成，长度任意
        System.out.println(str1.matches("\\w+"));//true
    }

    @Test
    public void test03(){
        String str1 = "12hela3h3salgH2";

        //判断str1字符串是否有字母和数字组成，长度任意
        System.out.println(str1.matches("[a-zA-Z0-9]+"));//true

        String str2 = "12hela_3h3salgH2";
        //判断str2字符串是否有字母和数字组成，长度任意
        System.out.println(str2.matches("[a-zA-Z0-9]+"));//false
    }

    @Test
    public void test02(){
        String str = "123456";

        //判断是否由6个数字组成
        System.out.println(str.matches("\\d{6}"));//true
    }
    @Test
    public void test01(){
        //判断下面的str1和str2字符串，是否里面全部由数字组成，至少有一个数字  \d+ 或 \d{1,}
        String str1 = "123a56";
        System.out.println(str1.matches("\\d+"));//false
        /*
        在正则中\是转义，在Java中\也是转义
        Java中转义有：\t,\n,\r,\b,\',\",\\。
        此处想要表示是正则中的\d，而不是Java中\d，就要写 \\d
         */

        String str2 = "123456";
        System.out.println(str2.matches("\\d+"));//true
    }
}


（1）判断当前字符串是否以xx开头
boolean startsWith(“目标");
（2）判断当前字符串是否以xx结尾
boolean endsWith("目标")

public class TestStringMethod6 {
    @Test
    public void test03(){
        String fileName = "HelloWorld.java";

        //判断这个文件是否是一个“Java的源文件”
        //“Java的源文件” 以 ".java"结尾
        System.out.println(fileName.endsWith(".java"));
    }

    @Test
    public void test02(){
        String str = "hellojava";

        //判断str是否以"hello"开头
        if(str.startsWith("hello")){
            System.out.println("str是以hello开头");
        }else{
            System.out.println("str不是以hello开头");
        }
    }

    @Test
    public void test01(){
        String str = "hellojava";

        //判断str是否以"hello"开头
        if(str.indexOf("hello") == 0){
            System.out.println("str是以hello开头");
        }else{
            System.out.println("str不是以hello开头");
        }
    }
}

7、系列七：正则匹配
（1）什么是正则？
所谓的正则，就是某个规则，某个文本/字符串的规则。
例如：银行卡密码，要求是6位数字组成，不能是别的字符
     尚硅谷后台学生信息管理系统，用户名要求必须是26个英文字母大小写或数字和标点符号组成，
                            并且要求必须至少有一个大写、一个小写、一个数字、一个特殊标点符号组成，长度不能超过32位。
（2）Java语言也是支持正则的一种编程语言。
  除了Java以外，很多语言都支持，比如JavaScript等。

  正则不是Java里面的一个语法点。

（3）String类中有很多方法支持正则表达式，
其中一个方法是用于判断 某个字符串是否“匹配”某个正则，boolean matches(String regex)

. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

一个\d等这些模式只是代表/匹配一个字符

正则数量词
X? ：表示X，一次或一次也没有
X*  ：表示 X，零次或多次
X+  ：表示X，一次或多次
X{n}  ：表示X，恰好 n 次
X{n,}  ：表示X，至少 n 次
X{n,m}  ：表示X，至少 n 次，但是不超过 m 次
这里的X是一个匹配模式，例如：\d等

[abc] ：a、b 或 c（简单类）
[^abc] ：任何字符，除了 a、b 或 c（否定）
[a-zA-Z] ：a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] ：a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]： d、e 或 f（交集）
[a-z&&[^bc]] ：a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] ：a 到 z，而非 m 到 p：[a-lq-z]（减去）

边界匹配器
^ 行的开头
$ 行的结尾


找的一些正则的表达式：
1.验证用户名和密码，要求第一个字符必须为字母，一共6~16位字母数字下划线组成：（^[a-zA-Z]\w{5,15}$）
2.验证电话号码：xxx/xxxx-xxxxxxx/xxxxxxxx：（^(\d{3,4}-)\d{7,8}$）
3.验证手机号码：( ^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$ )
4.验证身份证号： (^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)
5.验证Email地址：(^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$)
6.只能输入由数字和26个英文字母组成的字符串：(^[A-Za-z0-9]+$)
7.整数或者小数：(^[0-9]+(\.\[0-9\]+){0,1}$)
8.中文字符的正则表达式：([\u4e00-\u9fa5])
9.金额校验(非零开头的最多带两位小数的数字)：(^(\[1-9\][0-9]*)+(.[0-9]{1,2})?$)
10.IPV4地址：(((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))\\.){3}((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))

public class TestStringMethod7 {

    @Test
    public void test05(){
        //密码要求：必须有大写字母，小写字母，数字组成，6位
        System.out.println("Cly892".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("1A2c45".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("Clyyyy".matches("^(?=.*[A-Z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//false

        //下面这个写法只是说，6位字符都在 [A-Za-z0-9]范围内，并没有要求必须有大写、小写、数字都出现
        System.out.println("123456".matches("[A-Za-z0-9]{6}"));
    }

    @Test
    public void test04(){
        String str1 = "12hela3h3salgH2";

        //判断str1字符串是否有字母和数字和下划线等组成，长度任意
        System.out.println(str1.matches("\\w+"));//true
    }

    @Test
    public void test03(){
        String str1 = "12hela3h3salgH2";

        //判断str1字符串是否有字母和数字组成，长度任意
        System.out.println(str1.matches("[a-zA-Z0-9]+"));//true

        String str2 = "12hela_3h3salgH2";
        //判断str2字符串是否有字母和数字组成，长度任意
        System.out.println(str2.matches("[a-zA-Z0-9]+"));//false
    }

    @Test
    public void test02(){
        String str = "123456";

        //判断是否由6个数字组成
        System.out.println(str.matches("\\d{6}"));//true
    }
    @Test
    public void test01(){
        //判断下面的str1和str2字符串，是否里面全部由数字组成，至少有一个数字  \d+ 或 \d{1,}
        String str1 = "123a56";
        System.out.println(str1.matches("\\d+"));//false
        /*
        在正则中\是转义，在Java中\也是转义
        Java中转义有：\t,\n,\r,\b,\',\",\\。
        此处想要表示是正则中的\d，而不是Java中\d，就要写 \\d
         */

        String str2 = "123456";
        System.out.println(str2.matches("\\d+"));//true
    }
}

8、系列八：替换
public String replace(CharSequence target, CharSequence replacement)：把当前字符串中的目标target替换为replacement代替字符，不支持正则
public String replaceFirst(String regex, String replacement)：替换第一个匹配目标，并且匹配时支持正则
public String replaceAll(String regex, String replacement)：替换所有匹配目标，并且支持正则

public class TestStringMethod8 {
    @Test
    public void test04(){
        String str = "hel22lo1jav3aatg4ui88gu";

        //把str中的数字去掉
        str = str.replaceAll("\\d","");
        System.out.println(str); //hellojavaatguigu
    }

    @Test
    public void test03(){
        String str = "hellojavaatguigu";

        //替换str中第一个出现的“a“为"A"
        str = str.replaceFirst("a","A");
        System.out.println(str); //hellojAvaatguigu
    }

    @Test
    public void test02(){
        String str = "hellojavaatguigu";

        //替换str中的“a“字母去掉
        str = str.replace("a","");
        System.out.println(str); //hellojvtguigu
    }

    @Test
    public void test01(){
        String str = "hellojavaatguigu";

        //替换str中的“a“字母为"A"
        str = str.replace("a","A");
        System.out.println(str); //hellojAvAAtguigu
    }
}

9、系列九：拆分
String[] split(正则)：按照某种规则进行拆分

public class TestStringMethod9 {

    @Test
    public void test2() {
        String info = "1.张三.23|2.李四.24|3.王五.25";

        //我们要在咱们的系统中，拆分并解读它的信息。
        //这些是学生信息，有学号、姓名、成绩
        //(1)第一步按照，拆分，分为3个同学的信息
        String[] strings = info.split("\\|"); //|在正则中代表或

        Student[] arr = new Student[strings.length];
        //(2)每一个同学的信息按照:拆分，分为3个属性值
        for (int i=0; i<strings.length; i++){
            String[] studentString = strings[i].split("\\.");// .在正则中代表任意字符，所以都有特殊意义，需要转义
            arr[i] = new Student(Integer.parseInt(studentString[0]), studentString[1], Integer.parseInt(studentString[2]));
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
    @Test
    public void test01(){
        String info = "1:张三:89,2:李四:100,3:王五:56";//这是从别的系统获得的数据

        //我们要在咱们的系统中，拆分并解读它的信息。
        //这些是学生信息，有学号、姓名、成绩
        //(1)第一步按照，拆分，分为3个同学的信息
        String[] strings = info.split(",");
        /*
        {"1:张三:89","2:李四:100","3:王五:56"}
         */

        Student[] arr = new Student[strings.length];
        //(2)每一个同学的信息按照:拆分，分为3个属性值
        for (int i=0; i<strings.length; i++){
            String[] studentString = strings[i].split(":");
//            每循环一次studentString数组就代表一个学生信息：
//            例如：第1次，["1","张三","89"]
//            例如：第2次，["2","李四","100"]
//            例如：第3次，["3","王五","56"]

            arr[i] = new Student(Integer.parseInt(studentString[0]), studentString[1], Integer.parseInt(studentString[2]));
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}
class Student{
    private int id;
    private String name;
    private int score;

    public Student(int id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

サUBLL� 尔~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
实例解析Array和String方法
08-31
本文主要对Array和String方法进行总结，每一部分总结后有实例代码，代码中黄色框方法不改变原数组。PS:所有实例结果均一一运行所得。具有很好的参考价值，需要的朋友一起来看下吧
String方法
07-31
总结了String的常用方法，能让你更好的熟练应用String
Java基础——String类
Gray_Wolfs的博客
08-05 201
一、String的基本概念 1、String是一组字符序列，由于其内部是用字符数组实现的，所以他是一个不可变的串。即改变它的值地址也会随之改变。 2、创建String对象的方式 String s = new String(); String s = new String(“11”); String s = “111”; String s = new String(byte[] bytes)//通...
Java的编码方式、单个char类型存储大部分中文字符、getBytes()、new String()的转换流程
weixin_37607613的博客
09-19 4449
char存储中文，getBytes()、UTF-8、UTF-16、UTF-32、GBK、ASCII、ISO8859-1、Unicode
string和stringbuilder
最新发布
weixin_43735634的博客
03-17 394
stringbuilder是长度可变的字符序列，创建的时候如果不带参数的话，那么默认的长度就是16，如果带参数的话，那么长度就是16+参数。string是一个长度不可变的字符序列，底层是一个被final修饰的char[]数组，所以说，任何对 String 类型进行改变的操作实际上都是重新生成了一个新的String对象，然后将指针指向新的 String 对象，这样不仅效率低下，而且大量浪费有限的内存空间，所以经常改变内容的字符串最好不要用 String。
Java String编码转换
okman1214的专栏
07-31 6838
String newStr = new String(oldStr.getBytes(), "UTF-8");  java中的String类是按照unicode进行编码的，当使用String(byte[] bytes, String encoding)构造字符串时，encoding所指的是bytes中的数据是按照那种方式编码的，而不是最后产生的String是什么编码方式，换句话说，是让系统把byt
String 类设定字符集
dalie9的专栏
06-13 2315
根据String 类的构造方法里设定字符集的内容如下：public String(byte[] bytes,String charsetName) throws UnsrpportedEncodingExceptionbytes -- 指定的字节数组；charsetName -- 指定的字符集。具体用法如下:  String string = "中国";  byte bytes
Java面试必知:String类
weixin_41774732的博客
07-16 162
String String类是 final 不能被继承 String类值不能被修改,不支持原地操作 private final char value[]; 改变字符串内容,实际上是新开辟了一段内存空间 String对象赋值 String a1=new String("abc"); char[] chars={'a','b','c'}; String a2=new String(chars); String a3="abc"; String a4=a1; String a5=a1.intern();
c++ int转string方法
09-05
int 转string的方法，用到了特分享一下方便需要的朋友
String方法总结
11-01
适合初学者，很简单的 1. Length():int 获取字符串长度
Javascript拓展String方法小结
10-27
拓展了几个常用的方法,需要的朋友可以参考下
java string类的常用方法详细介绍
09-05
在开发过程中经常会使用到java string类的方法,本文将以此问题进行详细介绍
扩展String功能方法
10-09
扩展String功能方法：一直好忙，没有时间写属于自己的东西，但是看着一天天不更新心情也不是个滋味，只有从网上收罗一些比较好的东东贴上。
String方法使用例子
01-17
String方法使用例子
String方法与IO流小结
12-22
1.基础方法 int length(); 获取字符串长度 “” 1.char charAt(int index); 获取指定下标位置的元素 2.int indexOf(char ch); 找出指定元素的下标 3.int indexOf(String str); 找出指定字符串的下标 4.int indexOf...
String split方法实现过程图解
08-25
主要介绍了String split方法实现过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
字符串相关的类：String
weixin_44210932的博客
01-24 121
1.String的特性 String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。 String是一个final类，代表不可变的字符序列。 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。 String对象的字符内容是存储在一个字符数组value[]中的。 public final class String implements java.io.Serializable, Comparable<String>, CharSequen
JAVA字符集
FutureInHands的专栏
09-18 1041
 JAVA字符集日期：2006-08-30  点击：317  作者：键者天行  来源：CSDN1. 概述 本文主要包括以下几个方面：编码基本知识，java，系统软件，url，工具软件等。 在下面的描述中，将以"中文"两个字为例，经查表可以知道其GB2312编码是"d6d0 cec4"，Unicode编码为"4e2d 6587"，UTF编码就是"e4b8ad e69687"。注意，这两个字没
Java常用类String
weixin_44570988的博客
05-17 146
String构造器： 1、 String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。 例子：数据为空 String str=new String(); System.out.println(str); 2、 String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新 的 String。 例子：输出的是指定数组 byte[] b...
继承string方法
05-30
可以通过在类定义时使用关键字 "public" 继承 string 类的方法，例如： ``` class MyString : public string { // 在此添加您自己的类定义 }; ``` 这将使 MyString 类从 string 类继承所有的公共方法和属性。您可以根据需要在 MyString 类中添加自己的方法和属性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值