JAVA基础——常用类（一）

 首先认识到——String是不可以变性（final）

String:字符串，使用一对“”引起来表示。
     * 1.String声明为final的，不可被继承
     * 2.String实现了Serializable接口：表示字符串是支持序列化的。
     *         实现了Comparable接口：表示String可以比较大小
     * 3.String内部定义了final char[] value用于存储字符串数据
     * 4.String:代表不可变的字符序列。简称：不可变性。

理解不可变性

import org.junit.Test;

/**
 * String的使用
 */
public class StringTest {

    /**
     * String:字符串，使用一对""引起来表示。
     * 1.String声明为final的，不可被继承
     * 2.String实现了Serializable接口：表示字符串是支持序列化的。
     *         实现了Comparable接口：表示String可以比较大小
     * 3.String内部定义了final char[] value用于存储字符串数据
     * 4.String:代表不可变的字符序列。简称：不可变性。
     *      体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
     *           2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
     *           3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
     * 5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
     * 6.字符串常量池中是不会存储相同内容的字符串的。
     *
     */
    @Test
    public void Test1(){
        String s1 = "abc";  //字面量的定义方式
        String s2 = "abc";
        s1 = "hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("*********************");

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef

        System.out.println("**********************");

        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }
}

String不同实例化方式的对比

String str = "hello";

//本质上this.value = new char[0];
String  s1 = new String(); 

//this.value = original.value;
String  s2 = new String(String original); 

//this.value = Arrays.copyOf(value, value.length);
String  s3 = new String(char[] a);

String  s4 = new String(char[] a,int startIndex,int count);

String str1 = “abc”;与String str2 = new String(“abc”);的区别？

• 字符串常量存储在字符串常量池，目的是共享
• 字符串非常量对象存储在堆中

import org.junit.Test;

/**
 * String的使用
 */
public class StringTest {

    /**
     * String的实例化方式
     * 方式一：通过字面量定义的方式
     * 方式二：通过new + 构造器的方式
     *
     * 面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
     *      两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"
     *
     */
    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

        System.out.println("***********************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
    }
}

/**
 * @author subei
 * @create 2020-05-09 11:20
 */
public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {

    }
}

import org.junit.Test;

/**
 * String的使用
 */
public class StringTest {

    /**
     * 结论
     *     1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
     *     2.只要其中有一个是变量，结果就在堆中
     *     3.如果拼接的结果调用intern()方法，返回值就在常量池中
     *
     */
    @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s5.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true
    }
}

重点：其中"JAVAEE"和"hadoop"是自变量，s1和s2都是变量名
          有变量名参与，就相当于在堆中创建了,相当于new，如s5,s6,s7

1、String s1 = “a”;

说明：在字符串常量池中创建了一个字面量为"a"的字符串。

2、s1 = s1 + “b”;

说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+“b”（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

3、String s2 = “ab”;

说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。

4、String s3 = “a” + “b”;

说明：s3指向字符串常量池中已经创建的"ab"的字符串。

5、String s4 = s1.intern();

说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

/**
 * 一道面试题
 */
public class StringTest {
    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good//A
        System.out.println(ex.ch);//best//B
    }
}

在这里解释：

1.为什么//A输出来的是good——因为基本数据类型传输得是存储值，而引用数据类型传输得是地址值，而String类型是个引用数据类型，所以在chenge方法中，参数String str的地址值实际上跟String str = new String("good")地址值一样，且是不能改变的，且good在常量池当中，而当A输出的则是地址值，所以出来的是good而不是test ok!

2.为什么B输出来的却是best——因为char是个基本数据类型，在堆中显示test，是可以改变地址值的，所以输出来的是best!

JVM中涉及字符串的内存结构

String的常用方法1

package doy1;

import org.junit.Test;

/**
 * @author shkstart
 * @create 2021-10-25 22:23
 */
public class zuoye1 {
        /**
         * int length()：返回字符串的长度：return value.length
         * char charAt(int index)：返回某索引处的字符return value[index]
         * boolean isEmpty()：判断是否是空字符串：return value.length==0
         * String toLowerCase()：使用默认语言环境，将String中的所有字符转换为小写
         * String toUpperCase()：使用默认语言环境，将String中的所有字符转换为大写
         * String trim()：返回字符串的副本，忽略前导空白和尾部空白
         * boolean equals(Object obj)：比较字符串的内容是否相同
         * boolean equals IgnoreCase(String anotherString)：与equals方法类似，忽略大小写
         * String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
         * int compareTo(String anotherString)：比较两个字符串的大小
         * String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
         * String substring(int beginIndex,int endIndex)：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
         */
        //实则StringMethodTest
        @Test
        public void test2(){
            String s1 = "HelloWorld";
                       //0123456789
            String s2 = "helloworld";
            System.out.println(s1.length());//10
            System.out.println(s1.equals(s2));//false
            System.out.println(s1.equalsIgnoreCase(s2));//true
           /*
              boolean equals(Object obj)：比较字符串的内容是否相同
               boolean equals IgnoreCase(String anotherString)：与equals方法类似，忽略大小写
               */
            System.out.println("***************");
            String s3 = "abc";
            String s4 = s3.concat("def");
            System.out.println(s4);//abcdef
            /*
            String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
             */
            System.out.println("***************");
            String s5 = "abc";
            String s6 = new String("abe");
            System.out.println(s5.compareTo(s6));//-2   //涉及到字符串的排序,比如a==97，c==99,e==101
            /*
             int compareTo(String anotherString)：比较两个字符串的大小
             */
            System.out.println("***************");
            String s7 = "周围好吵啊";
                       //0 1 2 3 4
            String s8 = s7.substring(2);
            System.out.println(s7);//因为String的不可变性，所以依然为周围好吵啊
            System.out.println(s8);//好吵啊
 /*
            String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
            String substring(int beginIndex,int endIndex)：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串
  */
            String s9 = s7.substring(0, 2);
            System.out.println(s9);//周围，
        /*String substring(int beginIndex,int endIndex)：
        返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
        关于这里为什么输出的是周围——可以s7.substring(0, 2);是一个左闭右开区间，[2，0),
         */
        }
/**
 * int length()：返回字符串的长度：return value.length
 * char charAt(int index)：返回某索引处的字符return value[index]
 * boolean isEmpty()：判断是否是空字符串：return value.length==0
 * String toLowerCase()：使用默认语言环境，将String中的所有字符转换为小写
 * String toUpperCase()：使用默认语言环境，将String中的所有字符转换为大写
 * String trim()：返回字符串的副本，忽略前导空白和尾部空白*/
        @Test
        public void Test1(){
            String s1 = "Helloworld";
                       //0123456789
            System.out.println(s1.length());
            System.out.println(s1.length());
            System.out.println(s1.charAt(0));
            System.out.println(s1.charAt(9));
//        System.out.println(s1.charAt(10));超过的话，那么就会出现报错
//        s1 = "";
            System.out.println(s1.isEmpty());//false---->不是空字符串

            String s2 = s1.toLowerCase();
            System.out.println(s1);//s1不可变的，仍然为原来的字符串
            System.out.println(s2);//改成小写以后的字符串

            String s3 = "   he  llo   world   ";
            String s4 = s3.trim();
            System.out.println("-----" + s3 + "-----");
            System.out.println("-----" + s4 + "-----");

    }

}

String的常用方法2

package doy1;

/**
 * @author shkstart
 * @create 2021-10-24 13:07
 */
import org.junit.Test;

public class StringMethodTest1 {

    /**
     * boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
     * boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
     * boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
     *
     * boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
     * int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
     * int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
     * int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引(但是数索引的位置时候，依然从前往后数)
     * int lastIndexOf(String str, int fromIndex)：
     * 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索(从后向前找，数索引的位置时候，依然从前往后数)
     *
     * 注：indexOf和lastIndexOf方法如果未找到都是返回-1
     */
    @Test
    public void test3(){
        String str1 = "helloworld";
                    // 0123456789
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1);//true

        boolean b2 = str1.startsWith("He");
        System.out.println(b2);//false

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);//true
/*
* boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
 * int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
 * int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
 * int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引(但是数索引的位置时候，依然从前往后数)
 * int lastIndexOf(String str, int fromIndex)：
 * 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索(从后向前找，数索引的位置时候，依然从前往后数)
 *
 * 注：indexOf和lastIndexOf方法如果未找到都是返回-1
* */
        //String str1 = "helloworld";
                      // 0123456789
        String str2 = "wor";
                    // 0123456789
        System.out.println(str1.contains(str2));//true

        System.out.println(str1.indexOf("lo"));//3

        System.out.println(str1.indexOf("lo",5));//-1
        //注：indexOf和lastIndexOf方法如果未找到都是返回-1
          //为什么会出现-1？——因为指定的索引是5，所以从5开始往后面找，但是找不到lo,所以就得返回值是——  -1
        String str3 = "hellorworld";
                    // 0123456789
        System.out.println(str3.lastIndexOf("or"));//7--->返回指定子字符串在此字符串中最右边出现处的索引
        System.out.println(str3.lastIndexOf("or",6));//4
        //为什么出现的是4？——因为指定的索引为6，所以就得从6开始从后往前找，所以就是4
        //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str
    }
}

String的常用方法3

package doy1;

/**
 * @author shkstart
 * @create 2021-10-24 20:53
 */
import org.junit.Test;

public class StringMethodTest2 {

    /**
     * 替换：
     * String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
     * String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
     * String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
     * String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
     *
     * 匹配:
     * boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
     *
     * 切片：
     * String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
     * String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
     *
     */
    @Test
    public void test4(){
        String str1 = "北京欢迎您";
        String str2 = str1.replace('北','东');

        System.out.println(str1);
        System.out.println(str2);

        String str3 = str1.replace("北京", "南京");
        System.out.println(str3);

        System.out.println("*************************");
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);

        System.out.println("*************************");
        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);

        System.out.println("*************************");
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
        System.out.println();
        str3 = "hello.world.java.java.aff.cfafa";
        String[] strs3 = str3.split("\\.",3);
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs3[i]);
        }
    }
}