Java基础-字符串

String

String构造方法

代码实现

public class StringDemo01 {
    public static void main(String[] args) {
        // 1. 使用直接赋值的方式获取一个字符串对象
        String s1 = "abc";
        System.out.println(s1); // abc

        // 2. 使用new的方式获取一个字符串对象
        // 空参构造: 可以获取一个空白的字符串对象
        String s2 = new String();
        System.out.println("@"+s2+"!"); // @!

        // 没啥用: 传递一个字符串, 根据传递的字符串内容再创建一个新的字符串对象
        String s3 = new String("abc");
        System.out.println(s3); // abc

        // 传递一个字符数组, 根据字符数组的内容再创建一个新的字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s4 = new String(chs);
        System.out.println(s4); // abc
        // 需求: 修改字符串内容, abc->Qbc
        // abc -> {'a', 'b', 'c'} -> {'Q', 'b', 'c'} -> "Qbc"

        // 传递一个字节数组, 根据字节数组的内容再创建一个新的字符串对象
        // 应用场景: 再网络当中传输的数据其实都是字节信息
        // 一般要把字节信息进行转换, 转成字符串, 此时就要用到这个构造了
        byte[] bytes = {97, 98, 99};
        String s5 = new String(bytes);
        System.out.println(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

内存分析

当使用双引号直接赋值时, 系统会检查该字符串在串池(StringTable, jdk7之后在堆内存中)中是否存在

• 不存在: 创建新的
• 存在: 复用

String的常用方法

比较

Demo02

public class StringDemo02 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = "abc";
        String s3 = "Abc";

        // 1. == 比较
        // 基本数据类型: 比的是数据值
        // 引用数据类型: 比的是地址值
        System.out.println(s1 == s2); // false

        // 2. 比较字符串对象的内容是否相等
        boolean res1 = s1.equals(s2);
        System.out.println(res1); // true

        // 3. 比较字符串对象的内容是否相等, 忽略大小写
        boolean res2 = s1.equalsIgnoreCase(s3);
        System.out.println(res2); // true

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Demo03

import java.util.Scanner;

public class StringDemo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str1 = sc.next(); // 本质是new String(...);
        String str2 = "abc";
        System.out.println(str1 == str2); // false
    }
}
1
2
3
4
5
6
7
8
9
10

练习 - 遍历字符串 ( charAt(), length() )

• char charAt(int index): 根据索引返回字符
• int length(): 返回字符串的长度

public class StringDemo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        for (int i = 0; i < s1.length(); i++) {
            System.out.println(s1.charAt(i));
        }
    }
}
1
2
3
4
5
6
7
8
9

练习 - 字符串拼接

package com.heima.string;

public class StringDemo05 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};

        System.out.println(arrToString(arr));
    }
    public static String arrToString(int[] nums)
    {
        if(nums == null){
            return "";
        }
        if(nums.length == 0){
            return "[]";
        }
        String ret = "[";
        for (int i = 0; i < nums.length; i++) {
            if(i == 0) {
                ret += nums[i];
            }else{
                ret += ", "+nums[i];
            }
        }
        ret += "]";
        return ret;
    }
}
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

练习 - 手机号屏蔽 ( substring() )

String substring(int beginIndex, int endIndex) 截取
注意点: 区间是左闭右开 [)
String substring(int beginIndex) 截取到末尾
1
2
3

public class StringDemo06 {
    public static void main(String[] args) {
        String phone = "13112349468";
        String newPhone = phone.substring(0, 3)+"****"+phone.substring(7);
        System.out.println(newPhone); // 131****9468
    }
}
1
2
3
4
5
6
7

练习 - 敏感词替换 ( replace() )

String replace(CharSequence oldValue, CharSequence newValue) 替换
1

public class StringDemo07 {
    public static void main(String[] args) {
        String str = "TMD, MTD";
        System.out.println(str.replace("TMD", "***"));
    }
}
1
2
3
4
5
6

StringBuilder

概述

• 介绍: StringBuilder可以看成是一个容器, 创建之后里面的内容是可变的
• 作用: 提高字符串的操作效率

基本操作

public class StringBuilderDemo1 {
    public static void main(String[] args) {
        // 1. 创建对象
        StringBuilder sb = new StringBuilder();

        // 2. 添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);
        // System.out.println(sb); // 12.3true

        // 3. 反转
        sb.reverse();
        // System.out.println(sb); // eurt3.21

        // 4. 获取长度
        int len = sb.length();
        // System.out.println(len); // 8

        // 5. StringBuilder -> String
        String s = sb.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

StringJoiner

概述

• 介绍: StringJoiner和StringBuilder一样, 也可以看成是一个容器, 内容是可变的
• 作用: 提高字符串的操作效率, 代码编写很简洁
• Jdk8之后出现

基本操作

import java.util.StringJoiner;

public class StringJoinerDemo01 {
    public static void main(String[] args) {

        int[] nums = {1, 2, 3};
        StringJoiner sj = new StringJoiner(", ", "[", "]");
        for (int i = 0; i < nums.length; i++) {
            sj.add(nums[i]+"");
        }
        System.out.println(sj);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

字符串原理

• 字符串存储的内存原理
  • 直接赋值会复用字符串常量池中的
  • new出来不会复用, 而是开辟一个新的空间
• ==号比较的是什么
  • 基本数据类型比较数据值
  • 引用数据类型比较地址值
• 字符串拼接的底层原理
  • 如果没有变量参与, 都是字符串直接相加, 编译之后就是拼接之后的结果, 会复用串池中的字符串
  • 如果有变量参与, 会创建新的字符串, 浪费内存
• StringBuilder提高效率原理
  • 所有要拼接的内容都会往StringBuilder中存放, 不会创建很多无用的空间, 节约内存
• StringBuilder源码分析
  • 默认创建一个长度为16的字节数组
  • 添加的内容长度小于16, 直接存
  • 添加的内容大于16会扩容(原来的容量*2+2)
  • 如果扩容之后还不够, 以实际长度为准

综合练习

阿拉伯数字转罗马数字

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 阿拉伯数字转为罗马数字
         * 1. 数字范围[1, 9]
         */
        String[] vis = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        StringBuilder ans = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            int num = s.charAt(i) - '0';
            ans.append(vis[num]+" ");
        }
        System.out.println(ans);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

调整字符串

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 调整字符串
         * 给定两个字符串A和B
         * A的旋转操作就是将A最左边的字符移动到最右边
         * 如果若干次调整后, A能变成B, 则返回true, 反之返回false
         */
        String a = "abcde";
        String b = "cdeae";

        boolean flag = false;
        for (int i = 1; i < a.length(); i++) {

            char[] chars = a.toCharArray();
            char ch = chars[0];
            for (int j = 1; j < chars.length; j++) {
                chars[j-1] = chars[j];
            }
            chars[chars.length-1] = ch;
            a = new String(chars);

            if(a.equals(b)){
                flag = true;
                System.out.println("Yeah!");
                break;
            }
        }

        if(!flag){
            System.out.println("Noo!");
        }
    }
}
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

来源

黑马程序员. 阿玮Java零基础

Gitee地址

https://gitee.com/yu-ba-ba-ba/awJava