Java--String类

鳄鱼去数羊

已于 2022-08-24 00:54:19 修改

阅读量162

点赞数

文章标签： java jvm 开发语言

于 2022-08-23 03:56:28 首次发布

本文链接：https://blog.csdn.net/m0_52822058/article/details/126445718

版权

String对象的创建

1.直接赋值字符串
2.无参构造Srting();
3.根据字节数组创建String对象
4.根据字符数组创建String对象
5.根据已有字符串，创建新的字符串，地址分配不一样
示例：

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class Demo10 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s1 = "lic";  //1.直接赋值字符串常量
        String s2 = new String(); //2.无参构造String（）
        System.out.println(s1);//lic
        System.out.println(s2==null);//false
        //new 运算符在堆中创建一个String对象，把该对象的地址保存到s2变量中
        //s2是一个空的，字符个数为0的字符串，相当于“” 不是null
        byte[] bytes = {65,66,67,97,98,99};//3.根据字节数组创建String对象
        String s3 = new String(bytes);
        System.out.println(s3);
        char[] chars = {'A','B','设','D'};//3.根据字符数组创建String对象
        System.out.println(new String(chars));//把字符数组的内容转化为字符串
        String s4 = new String(s1); //5.根据已有字符串，创建新的字符串，地址分配不一样
        System.out.println(s4);
        System.out.println(s4==s1);
    }
}

下面代码创建多少个String对象

        //2个对象 一个常量 一个new出来的
        String s3 = "abc";
        String s4 = new String("abc");
        //1个对象"heHe"
        String s5 = "heHe";
        String s6 = "he"+"He"; //优化位
        //2个对象 "haha" "hahaha"
        String s7 = "haha";
        String s8 = "ha"+"ha"+"ha";
        //2个对象 一个常量 一个new出来的
        String s9 = "helloLic";
        String s10 = new String("hello" + "Lic");
        //1个对象 "helloLic"
        String s11 = "helloLic";
        String s12 = ""+"hello"+"Lic";
        //4个对象 常量："aaa" "aa" "a" 连接后生成一个
        String s13 = "aaa";
        String s14 = s13 +"a"+"aa";
        //2个对象 常量："aaa"  连接后生成一个
        String s15 = "aaa";
        String s16 = "a"+"aa"+s14;

String的常用方法

实际开发中，对于String类的常用方法是非常重要的，掌握常用方法很重要。

import java.util.Arrays;
import java.util.Locale;
public class Demo02 {
    public static void main(String[] args) {
        char[] chars = {'a','b','c','c','a'};
        char[] chars1 = {'d','e','f'};
        char[] chars2 = {'A','B','c','c','a'};
        String s1 = new String(chars);
        String s2 = new String(chars1);
        String s3 = new String(chars2);
        //返回指定字符的位置
        System.out.println(s1.charAt(0));//a
        //比较两个字符串大小，结果为0表示s1,s2相等，小于0，代表s1小于s2
        System.out.println(s1.compareTo(s2));//-3 s1<s2
        //拼接字符串
        System.out.println(s1.concat(s2));
        //判断当前字符串中是否包含某个字符串
        System.out.println(s1.contains("ab"));//true
        //判断当前字符串是否以某个字符串结尾
        System.out.println(s1.endsWith("b"));//false
        //判断当前字符串是否以某个字符串开始
        System.out.println(s1.startsWith("a"));//true
        //判断两个字符串是否相等
        System.out.println(s1.equals(s2));//false
        //判断两个字符串是否相等，不区分大小写
        System.out.println(s1.equalsIgnoreCase(s3));//true
        //将字符串转换为byte数组
        System.out.println(Arrays.toString(s1.getBytes()));//[97,98,99]
        //获取某字符串在当前字符串中第一次出现的索引
        System.out.println(s1.indexOf("bc"));//1
        //从某下标开始，获取某字符串在当前字符串中第一次出现的索引
        System.out.println(s1.indexOf("b", 1)); //1
        //从常量池中返回该字符串
        System.out.println(s1.intern());//abcca
        //获取某字符串在当前字符串中最后一次出现的索引
        System.out.println(s1.lastIndexOf("c"));//3
        //获取当前字符串的长度
        System.out.println(s1.length());//5
        //将当前字符串对象的c替换成d
        System.out.println(s1.replaceAll("c", "d"));//abcca
        //将当前字符串对象以某个特定的符号进行拆分，返回String数组
        String[] strings = s1.split("\\d");
        System.out.println(Arrays.toString(strings));
        //从2下标开始截取字符串，并返回截取后的字符串
        System.out.println(s1.substring(2));//cca
        //从2下标开始截取字符串到下标4结束，(不包括下标4)并返回截取后的字符串
        System.out.println(s1.substring(2, 4));//cc
        //将字符串转换成char[]数组
        System.out.println(Arrays.toString(s1.toCharArray()));
        //转换小写
        System.out.println(s3.toLowerCase(Locale.ROOT));
        //转换大写
        System.out.println(s3.toUpperCase());
        //去除字符串前后空白
        System.out.println("-->"+" lic c ".trim()+"<--");
        System.out.println(s1.matches("abcca"));//true
        //将int类型(任意类型)数据转化成字符串
        int i = 10;
        String s = String.valueOf(i);
        System.out.println(s);
    }
}

把字符串的每个字符打印出来

        String s1 = "www.lic";
        //把字符串的每个字符打印出来
        for (int i = 0; i < s1.length(); i++) {
            System.out.print(s1.charAt(i));
        }

format,格式化数据

System.out.println(String.format("姓名：%s,年龄：%d,婚否：%b,工资：%f", "lic", 18, false, 10000.0));

分离字符串

        String s2 = "hello/little girl/lic";
        System.out.println(s2.substring(0, s2.indexOf("/")));
        System.out.println(s2.substring(s2.indexOf("/") + 1, s2.lastIndexOf("/")));
        System.out.println(s2.substring(s2.lastIndexOf("/")+1));

valueOf(),把其他类型转化成字符串

        int num = 123;
        System.out.println(""+num);//字符串与基本数据类型连接，先把基本数据类型转化为字符串
        System.out.println(String.valueOf(num));

将字符串转换为byte数组

System.out.println(Arrays.toString(s1.getBytes()));//[97,98,99]

将字符串转换成char数组

 System.out.println(Arrays.toString(s1.toCharArray()));

与正则表表达式相关的操作

正则表达式就是一个模式串，用于判断字符串是否匹配指定的模式



[ABC]	匹配ABC中的一个，要么是A，要么是B，要么是C
.	任意字符
\d	数字
\s	空白字符
\w	单词字符[a-zA-Z0-9]
\b	匹配单词的开始或结束
^	字符串的开始
$	字符串的结束
X?	0次或一次
X*	任意次
X+	至少一次
X{n}	正好n次
X{n,}	至少n次
X{n,m}	至少n次，最多m次
（X）	分组

replaceAll()将数字隐藏为*号

        String text = "输入密码123456";
        System.out.println(text.replaceAll("\\d", "*"));

split()字符串分隔

        s1 = "Good night!   HahaHaa";
        String[] strings = s1.split("[\\s,.!?]+");
        for (String string: strings
             ) {
            System.out.print(string+" ");
        }

判断字符串是否是邮箱的格式

        String email = "lic0123@aa23700.com";
        String pattern = "\\w{5,}@\\w{7,}\\.(com|cn|net)";
        System.out.println("邮箱格式是否匹配："+email.matches(pattern));

判断用户输入的密码中必须包含字母与数字，并且要求6位以上

public static void main(String[] args) {
        //判断用户输入的密码中必须包含字母与数字，并且要求6位以上

        System.out.println("请输入密码：");
        String s = new Scanner(System.in).next();
        //(?![0-9]+$)代表不能全为数字，(?![a-zA-Z]+$)代表不能全为英文
        String pattern = "^(?![0-9]+$)(?![a-zA-Z]+$)\\w{6,}$";//格式
        while (!s.matches(pattern)){
            System.out.println("密码格式不正确，必须包含字母与数字，并且要求6位以上");
            s = new Scanner(System.in).next();
        }
        System.out.println("密码："+s);
    }

把字符串拆分保存到数组中
创建Person类：确定属性，重写toString()方法

   class Person {
    private String name;
    private int age;
    private String gender;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

}

测试类：字符串信息拆分，返回String数组，创建Person类型数组和对象，遍历字符串信息数组给Person对象赋值，赋值完再保存到Person数组中，遍历Person数组。

import java.util.Arrays;
public  class text01{
        public static void main(String[] args) {
           String s ="lisa,18,女;jack,20,男;dav,21,男";
           //分割字符
            String[] words = s.split("[,;]");
           System.out.println(Arrays.toString(words));
            System.out.println();
           //创建数组
            Person[] person = new Person[3];
           //创建person对象
            Person p = new Person();
            //遍历数组，创建Person对象保存到Person数组中
            for (int i = 0; i < words.length; i+=3) {//3个一循环


                //把数组的姓名，年龄，性别给对象p赋值
                p.setName(words[i]);
                p.setAge(Integer.parseInt(words[i+1].trim()));
                p.setGender(words[i+2]);
                //把p对象保存在数组中
                person[i/3] = p;

            }
            for (Person pe:person
                 ) {
                System.out.println(pe);
            }
        }
    }

字符串的比较

String 类复写了 equals 方法，当使用 == 比较内存的存放地址不相等时，接下来会比较字符串的内容是否相等

        String str = "lic"+123;//字符串字面量与数字字面量连接时，javac编译器会进行优化
        int a = 123;
        String str1 = "lic"+a;//a是变量，javac编译器不会进行优化
        System.out.println(str==str1); //false
        System.out.println(str.equals(str1));//true

String对象的不可变性

        String s = "lic";
        s = "hh";
        /*
        "lic"与"hh"才是String对象，s是String类型的变量
        s变量是"lic"对象的引用，现存储的是"hh"对象的引用
        String对象不可变是指不能把"lic"变成"hh"
        当执行s="lic"时，在常量池又添加新的字符串对象"hh"，把该对象引用指向s
         */
        String string = "hello";
        string = string+s; //字符串连接会创建新的字符串对象
        /*
        使用+进行连接时
        根据string对象创建一个StringBuffer对象，假设是a
        调用a对象的append()方法把s连接起来
        调用a的toString()方法，在该方法创建一个新的String对象返回
         */

StringBuilder/StringBuffer类

可变的字符串，频繁进行字符串连接，使用StringBuilder/StringBuffer，常用方法是：append()
StringBuilder非线程安全，StringBuffer线程安全，(在多线程并发环境下)

public class Demo04 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        sb.append("World");
        System.out.println(sb);//会调用sb.toString()
        StringBuffer sb2 = new StringBuffer();
        sb2.append("hello");
        sb2.append("World");
        System.out.println(sb2);
    }
}