学点儿Java_Day9_String、包装类-CSDN博客

本文链接：https://blog.csdn.net/Mr_Tang4/article/details/136954080

文章详细讲解了Java中String,Stringliteral,equals与==的区别，以及StringBuilder和StringBuffer的异同，包括自动装箱和拆箱的概念，以及包装类的作用和使用。

摘要由CSDN通过智能技术生成

1 String

@Test
    public void test1() {
        //"abc"双引号括起来的字符串：字符串常量，它也是一个对象
        // 1.8之后常量池放到堆，在常量池里面找有没有这个"abc"对象，
        // 如果常量池里面没有这个字符串对象，java就帮你在常量池里面new一个"abc"字符串对象。
        // 如果常量池里面有这个字符串，就把这个字符串的地址赋给这个变量。
        String str1 = "abc";
        String str2 = new String("abc");
        String str3 = "abc";
        //------------   == 与 equals -----------------------//
        // ==: 比较的是变量指向的对象的地址值
        System.out.println(str1 == str2);//false
        System.out.println(str1 == str3);//true
        System.out.println(str2 == str3);//false

        // equals: 比较字符串的内容是不是相等
        // 比较字符串的内容是不是相等使用equals()
        // 表str1这个字符串和str2这个字符串的内容是不是相等
        System.out.println(str1.equals(str2));//true
        System.out.println(str1.equals(str3));//true
        System.out.println(str2.equals(str3));//true
    }

在这里插入图片描述

@Test
    public void test2() {
        String str = "Java AndroidA";
        System.out.println(str.length());//13
        char[] chars = str.toCharArray();
        char ch = str.charAt(5);
        System.out.println(ch);//'A'
        System.out.println(str.indexOf('A'));//5 char -> int小的自动转大的
        System.out.println(str.indexOf('X'));
        System.out.println(str.indexOf('A', 6));//12
        System.out.println(str.indexOf("And"));
        System.out.println(str.lastIndexOf('A'));//12
    }

    @Test
    public void test3() {
        String str1 = "java";
        String str2 = "Java";
        System.out.println(str1.equals(str2));//false
        System.out.println(str1.equalsIgnoreCase(str2));//true

        String str = "java AndroidA";
        System.out.println(str.contains("And"));//true
        System.out.println(str.startsWith("java"));//true
        //offset:偏移
        System.out.println(str.startsWith("And", 5));//true
        System.out.println(str.endsWith("oidA"));//true
        System.out.println(str.isEmpty());//false
        // ""空字符串，也是一个对象
        System.out.println("".isEmpty());//true
    }

    @Test
    public void test4() {
        char[] chars1 = {'j', 'a', 'v', 'a', ' ', 'A', 'n', 'd'};
        String str1 = new String(chars1);
        System.out.println(str1);
        char[] chars2 = str1.toCharArray();
        System.out.println(chars2);
        //Arrays: 操作数组的工具类
        System.out.println(Arrays.toString(chars1));//[j, a, v, a,  , A, n, d]
    }

    @Test
    public void test5() {
        String str = "java AndroidA";
        String newStr = str.replace('A', 'B');
        System.out.println(newStr);
    }

    @Test
    public void test6() {
        String str = "java android python";
        String[] array = str.split(" ");
        System.out.println(array);
        System.out.println(Arrays.toString(array));
    }

    @Test
    public void test7() {
        // subtree: 子树
        // substring:子字符串
        String str = "java AndroidA";
        System.out.println(str.substring(5));//AndroidA

        //beginIndex – the beginning index, inclusive.
        //endIndex – the ending index, exclusive.
        System.out.println(str.substring(5, 8));//Andr
    }

2 String、StringBuffer、StringBuilder异同点

相同点： 都是final类，都不能被继承。
不同点：
① String长度是不可改变的，StringBuffer、StringBuilder长度是可变的。
② StringBuffer是线程安全（需要加锁，效率低)、StringBuilder是线程不安全（没有加锁，效率高）。

银行取款业务，如果对这段代码加锁，就可以实现每次只有一个用户能进入这段代码，当执行完了之后，释放这个锁，另一个用户才能进来。

synchronized: 同步   加锁
if (money>=1000) {
     money = money - 1000;
}

String str = str1 + str2 + str3 + str4;
String str1 = "java";
str1 + "android";

常量字符串的拼接，编译器会做优化，使用String就可以：

String str = "Java" + "PHP" + "Python" + "C";

    @Test
    public void test8() {
        String str1 = "Java";
        String str2 = "PHP";
        String str3 = "Python";
        String str4 = "OpenHarmony";
        String str = str1 + str2 + str3 + str4;
        System.out.println(str);
        //执行效率非常低 String长度不可变，相加过程会new新的str，中间的还要回收

        StringBuffer buffer = new StringBuffer("C");//线程安全 效率低
//        buffer.append(str1);
//        buffer.append(str2);
//        buffer.append(str3);
//        buffer.append(str4);
        //链式编程
        buffer.append(str1).append(str2).append(str3).append(str4);
        System.out.println(buffer);

        StringBuilder builder = new StringBuilder("C");//线程安全 效率低
        builder.append(str1);
        builder.append(str2);
        builder.append(str3);
        builder.append(str4);
        //也可以链式编程
        System.out.println(builder);

        String str5 = "Java" + "PHP" + "Python" + "C";
        //字符串常量的拼接无所谓 编译器会做优化
    }

3 包装类(参考https://blog.csdn.net/weixin_37766087/article/details/93405801)

3.1 什么是包装类

包装类（Wrapper Class）： Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。
为什么不是面向对象的就会出现不足，是哪里不足？？
java中的数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型，反射等过程。为了弥补这个缺陷，java提供了包装类。因为8大基本数据类型不是类，所以它们也没有对应的方法和变量，也就没有各种各样的功能。更主要的一点，在一些场景当中，我们是不能使用基本数据类型只能使用对象的。比如一些容器，像是ArrayList、HashMap只能接受一个对象，再比如我们提供了一个方法，但是调用方有可能传入一个空值。如果我们使用基本数据类型，null会引发报错。
所以包装类正是为了解决这个问题而产生的。

虽然基本数据类型和包装数据类型互相转换有装箱和拆箱的过程，但是我们平时使用的时候
就把包装数据类型当成基本数据类型来使用就可以。

3.2 自动装箱与自动拆箱

Talk is cheap, show me the code.

@Test
    public void test9() {
        //public static final int   MAX_VALUE = 0x7fffffff;//16进制 全1
        System.out.println(Integer.MAX_VALUE);//常量命名规则 全大写下划线连接

        //自动装箱和自动拆箱
        //'Integer(int)' is deprecated and marked for removal
        // JDK9之后deprecate 不赞成
        Integer integer1 = new Integer(3);//手动装箱
        System.out.println(integer1);
        Integer integer2 = 4;//基本数据类型--->引用数据类型   自动装箱(Java帮做new)
        System.out.println(integer2);
        //int i = integer2.intValue();//手动拆箱
        int i = integer2;//引用数据类型--->基本数据类型  自动拆箱
        Integer integer3 = Integer.valueOf(5);//手动装箱
        System.out.println(integer3);

        Integer integer4 = 3;
        int num2 = integer4 + 2;
        integer4 = integer4 + 4;
        System.out.println(integer4);
    }

Java 5 增加了自动装箱、拆箱机制，提供基本数据类型和包装类型的相互转换操作。
自动装箱：Integer i1=8; //int 8 自动转为Integer型
自动拆箱：int i2= i1; //将Integer型转为基本数据类型 int
这些过程由JDK 编译器自动装箱完成的，即会自动调用 Integer.valueOf() 方法

包装数据类型最主要使用： 包装数据类型和字符串之间的转换
1、把基本数据类型转换成字符串
(1) 基本数据类型+“” : String str = 12 + “”; // “12”
(2) 基本数据类型的包装类.toString()
String str1 = Integer.toString(3);
String str2 = Double.toString(3.14);
2、把字符串转换成基本数据类型（从网页的输入框中得到的都是字符串）
(1) Integer.parseInt(String str); // "23 " 类名.方法 ----> 静态方法
Double.parseDouble(String str); // “3.14”
Boolean.parseBoolean(String str);//“true”
XXXX.parseXXXX(String str);
(2) new对象： Integer integer = new Integer(String str);
Integer interger = new Integer(“4”);
int i = integer.intValue();

    @Test
    public void test10() {
        //把字符串转换成基本数据类型（从网页的输入框中得到的都是字符串）
        String str1 = "123";
        int i = Integer.parseInt(str1);
        i = i + 1;
        System.out.println(i);
        System.out.println(Double.parseDouble("6.9999"));

        //下面的不常用
        String str = "123";
        //Integer integer1 = new Integer(str);//deprecated 不赞成
        //Integer integer2 = new Integer("4");//deprecated 不赞成
        Integer integer1 = Integer.valueOf(str);
        Integer integer2 = Integer.valueOf("1");
        int j = integer1.intValue();
        int k = integer2.intValue();
        System.out.println(j);
        System.out.println(k);
    }

    @Test
    public void test11() {
        //把基本数据类型转换成字符串
        String str1 = 12 + "";
        System.out.println(str1);

        String str2 = Integer.toString(3);
        String str3 = Double.toString(3.15);
        System.out.println(str2);
        System.out.println(str3);
    }