String类的使用(学习笔记)

String类

ApI使用

String类的构造方法
String() 创建一个空的字符串对象
String(String original) 通过参数传递的字符串常量,创建一个新的字符串对象
String(char[] value)通过参数传递的字符数组,创建一个新的字符串对象
String(byte[] bytes)通过参数传递的字节数组,查询编码表,创建一个新的字符串对象

/*
    String类的构造方法
    构造方法的作用:用于创建String字符串对象,有了对象,才能调用String类的成员方法
    String() 创建一个空的字符串对象
    String(String original) 通过参数传递的字符串常量,创建一个新的字符串对象
    String(char[] value)通过参数传递的字符数组,创建一个新的字符串对象
    String(byte[] bytes)通过参数传递的字节数组,查询编码表,创建一个新的字符串对象
 */
public class Demo01String {
    public static void main(String[] args) {
        //String() 创建一个空的字符串对象
        String s1 = new String();
        System.out.println("s1:"+s1);//s1:""

        //String(String original) 通过参数传递的字符串常量,创建一个新的字符串对象
        String s2 = new String("abc");
        System.out.println("s2:"+s2);//s2:"abc"

        //String(char[] value)通过参数传递的字符数组,创建一个新的字符串对象
        //字符串:一串字符
        char[] chars = {'a','b','c','@','$','中'};
        String s3 = new String(chars);
        System.out.println("s3:"+s3);//s3:"abc@$中"

        /*
            String(byte[] bytes)通过参数传递的字节数组,查询编码表,把字节转换为字符,创建一个新的字符串对象
            ASCII表:生活中的文字和计算机中文字的对应关系
            'a'==>97==>01100001==>存储到计算机中
            'A'==65
            '0'==48
         */
        //System.out.println('0'+0);//48
        //System.out.println('A'+0);//65
        //System.out.println('a'+0);//97
        byte[] bytes = {65,66,67,68,69};
        String s4 = new String(bytes);
        System.out.println("s4:"+s4);//s4:"ABCDE"

        //创建一个字符串对象,最简单的方式,就是定义一个字符串类型的变量
        String s5 = "abc";//隐含一个创建对象的过程 new String(new char[]{'a','b','c'});
        System.out.println("s5:"+s5);//s5:"abc"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

String判断功能方法
使用 == 做比较
​ 基本类型：比较的是数据值是否相同
​ 引用类型：比较的是地址值是否相同

• public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
• public boolean equalsIgnoreCase (String anotherString) ` ：将此字符串与指定对象进行比较，忽略大小写。

/*
    判断功能的方法
	使用 == 做比较
    基本类型：比较的是数据值是否相同
    引用类型：比较的是地址值是否相同
    - public boolean equals (String anObject) ：比较两个字符串的内容是否相同,区分大小写(登录案例)
        相同:返回true
        不相同:返回false
    - public boolean equalsIgnoreCase (String anotherString) ：比较两个字符串的内容是否相同，忽略大小写。(验证码案例)
        相同:返回true
        不相同:返回false
 */
public class Demo03StringMethod {
    public static void main(String[] args) {
        String s1 = "abc";//aabb
        String s2 = "abc";//aabb
        String s3 = new String("abc");//12aa
        String s4 = new String("Abc");//23fs
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1==s4);//false
        System.out.println("------------------------------------------------");
        //面向对象:找对象,调用对象的功能(方法)
        boolean b1 = s1.equals(s2);
        System.out.println("b1:"+b1);//b1:true
        boolean b2 = s1.equals(s3);
        System.out.println("b2:"+ b2);//b2:true
        boolean b3 = s1.equals(s4);
        System.out.println("b3:"+b3);//b3:false
        System.out.println("------------------------------------------------");
        System.out.println(s1.equalsIgnoreCase(s2));//true
        System.out.println(s1.equalsIgnoreCase(s3));//true
        System.out.println(s1.equalsIgnoreCase(s4));//true
        System.out.println(s3.equalsIgnoreCase(s4));//true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

==:
比较的是字符串地址值

equals:
比较的是字符串内容

String的遍历

public char charAt(int index)：返回指定索引处的char值(字符串的索引也是从0开始的)
public int length()                  ： 返回此字符串的长度
1
2

/*
    String的遍历
    可以使用遍历来访问字符串的每一个字符
    字符串变量需要用到以下两个方法:
        public char charAt(int index)：返回指定索引处的char值(字符串的索引也是从0开始的)
        public int length()                  ： 返回此字符串的长度
 */
public class Demo05String {
    public static void main(String[] args) {
        //索引      0 1 2 3 4  5 6
        String s = "我是一个中国人";
        System.out.println(s.charAt(0));//'我'
        System.out.println(s.charAt(1));//'是'
        System.out.println(s.charAt(2));//'一'
        System.out.println(s.charAt(3));//'个'
        System.out.println(s.charAt(4));//'中'
        System.out.println(s.charAt(5));//'国'
        System.out.println(s.charAt(6));//'人'
        //System.out.println(s.charAt(7));//'人'//StringIndexOutOfBoundsException: String index out of range: 7
        System.out.println(s.length());//7
        System.out.println("----------------------------------------");
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            System.out.println(c);
        }
        System.out.println("----------------------------------------");
        //char[] toCharArray() 将此字符串转换为一个新的字符数组。
        char[] arr = s.toCharArray();//{'我','是','一','个','中','国','人'}
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

String的其他常用方法

String substring(int beginIndex)                  
	: 从beginIndex开始截取字符串到字符串结尾，得到新的字符串并返回
	String s = "abcHELLOabc";
	String s2 = s.substring(3);//"HELLOabc"
String substring(int beginIndex, int endIndex) 
	:从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新字符串并返回（包含头，不包含尾） 
    String s = "abcHELLOabc";
	String s2 = s.substring(3,8);//"HELLO"
String substring(int beginIndex, int endIndex) 
String replace(String target, String replacement)   	
	: 将当前字符串中的target (旧值 )内容，使用replacement (新值) 进行替换,返回新的字符串
	String s = "abcHELLOabc";
	//需求:想把字符串中"HELLO",替换为"你好"
	String s3 = s.replace("HELLO","你好");//"abc你好abc"
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/*
    String的其他常用方法
    String substring(int beginIndex)
        : 从beginIndex开始截取字符串到字符串结尾，得到新的字符串并返回
        String s = "abcHELLOabc";
        String s2 = s.substring(3);//"HELLOabc"
    String substring(int beginIndex, int endIndex)
        :从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新字符串并返回（包含头，不包含尾）
        String s = "abcHELLOabc";
        String s2 = s.substring(3,8);//"HELLO"
    String substring(int beginIndex, int endIndex)
    String replace(String target, String replacement)
        : 将当前字符串中的target (旧值 )内容，使用replacement (新值) 进行替换,返回新的字符串
        String s = "abcHELLOabc";
        //需求:想把字符串中"HELLO",替换为"你好"
        String s3 = s.replace("HELLO","你好");//"abc你好abc"
 */
public class Demo07String {
    public static void main(String[] args) {
        //定义一个字符串变量
        String s = "键盘敲烂,月薪过万,迎娶白富美,走向人生巅峰!";
        //需求:把字符串s中"走向人生巅峰!"截取出来
        String s2 = s.substring(16);
        System.out.println("s2:"+s2);//s2:走向人生巅峰!
        //需求:把是字符串s中"月薪过万"截取出来
        String s3 = s.substring(5, 9);
        System.out.println("s3:"+s3);//s3:月薪过万
        //需求:把字符串s中"白富美",替换为"富婆"
        String s4 = s.replace("白富美", "富婆");
        System.out.println("s4:"+s4);//s4:键盘敲烂,月薪过万,迎娶富婆,走向人生巅峰!
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

String类的扩展方法

boolean contains(String s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
	"abcabc"==>"abc" true   "abcabc"==>"aaa" false
int indexOf(String str) 从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
String[] split(String regex)  根据指定的字符串把字符串切割为多个字符串存储到一个字符串数组中
1
2
3
4

/*
    contains:包含
    boolean contains(String s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
	    "abcabc"==>"abc" true   "abcabc"==>"aaa" false
    int indexOf(String str) 从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
        "abc呵呵abc".indexOf("呵呵")==>3
        "abc呵呵abc".indexOf("哈哈")==>-1
        "abc呵呵abc呵呵".indexOf("呵呵")==>3
    String[] split(String regex)  根据指定的字符串把字符串切割为多个字符串存储到一个字符串数组中
        "aa-bb-cc-dd".split("-")==>String[] arr = {"aa","bb","cc","dd"}
        "aa,bb,cc,dd".split(",")==>String[] arr = {"aa","bb","cc","dd"}
        "aa好bb好cc好dd".split("好")==>String[] arr = {"aa","bb","cc","dd"}
 */
public class Demo11String {
    public static void main(String[] args) {
        //boolean contains(String s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
        String s = "abcabc";
        //boolean b1 = s.contains("abc");
        boolean b1 = "abcabc".contains("abc");
        System.out.println("b1:"+b1);//b1:true
        boolean b2 = "abcabc".contains("呵呵");
        System.out.println("b2:"+b2);//b2:false

        //int indexOf(String str) 从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
        int a = "abc呵呵abc".indexOf("呵呵");
        System.out.println("a:"+a);//a:3
        int b = "abc呵呵abc".indexOf("哈哈");
        System.out.println("b:"+b);//b:-1
        int c = "abc呵呵abc呵呵".indexOf("呵呵");
        System.out.println("c:"+c);//c:3

        //String[] split(String regex)  根据指定的字符串把字符串切割为多个字符串存储到一个字符串数组中
        String[] arr1 = "aa-bb-cc-dd".split("-");
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        System.out.println("-----------------------------------");
        String[] arr2 = "aa好bb好cc好dd".split("好");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("-----------------------------------");
        String[] arr3 = "aa,bb,cc,dd".split(",");
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48