Java常用类-string

package com.changyonglei;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * string内容
 * @author Dixon
 * @create 2022-05-20 18:49
 *
 */

class Person{
    String name;
    int age;

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

    public Person() {
    }
}

public class StringTest {

    /**
     * string:字符串，使用一对""引起来表示。 test1()
     * 1.String声明为final的，不可被继承
     * 2.String实现了Serializable接口:表示字符串是支持序列化的。
     *  实现了Comparable接口:表示String可以比较大小
     * 3.String内部定义了final char[ ] value用于存储字符串数据
     * 4.String:代表不可变的字符序列。简称:不可变性。
     *  体现:
     *      1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
     *      2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的的value进行赋值。
     *      3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值。
     * 5.通过字面量的方式（区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。
     * 6.字符串常量池中是不会存储相同内容的字符串的。
     *
     * String的实例化方式：test2()
     *          方式一：通过字面量定义的方式
     *          方式二：通过new + 构造器的方式
     *   面试题：String s = new String("abc");方式创建对象，在内存中创建几个对象？
     *          回答：两个： 一个是堆空间创建的new结构，另外一个是char[]对应的常量池的数据"abc"
     *
     * test3()
     * 结论:
     *      1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
     *      2.只要其中有一个是变量，结果就在堆中。
     *      3.如果拼接的结果调用intern()方法，返回值就在常量池中。
     *
     * String类的常用方法1： test4()
     * 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 equalsIgnoreCase(String anotherString): 与equals方法类似，忽略大小写
     * String concat(String str):将指定字符串连接到此字符串的结尾。等价于用“+”
     * int compareTo(String anotherString):比较两个字符串的大小
     * String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
     * String substring(int beginIndex, int endIndex):返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
     *
     *
     * String类的常用方法2： test5()
     * 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
     *
     *
     * String类的常用方法3： test6()
     * 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个，如果超过了，剩下的全部都放到最后一个元素中。
     *
     *涉及到String类与其他结构之间的转换： test7()
     * 字符串→基本数据类型、包装类
     * >Integer包装类的public static int parseInt(String s):可以将由“数字”字符组成的字符串转换为整型。
     * >类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。基本数据类型、包装类→字符串
     * >调用String类的public String valueOf(int n)可将int型转换为字符串
     * >相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换
     *
     */

    @Test
    public void test1(){
        String s1 ="abc"; //字面量的定义方式
        String s2 ="abc";

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

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

        System.out.println("------------------");
        String s3 = "abc";
        s3+="def";
        System.out.println(s2); //abc
        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
    }

    @Test //String对象的创建
    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 ="Jack";
        System.out.println(p2.name); //Tom
    }

    @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(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
    }

    @Test
    public void test4(){
        String s1 = "HelloWorld";
        System.out.println(s1.length()); //数字的长度 10
        System.out.println(s1.charAt(2)); // 第二位的l
        System.out.println(s1.isEmpty()); // false
        String s2 ="";
        System.out.println(s2.isEmpty()); //true

        String s3 = s1.toLowerCase(); //HelloWorld  s1不可变
        System.out.println(s1);
        System.out.println(s3); //helloworld
        String s4 =s1.toUpperCase(); //HelloWorld  s1不可变
        System.out.println(s1);  //HelloWorld
        System.out.println(s4);  //HELLOWORLD

        String s5  = "   he   llo  w o r l     d";
        String s6 = s5.trim();  //去除首尾的空格
        System.out.println(s5);
        System.out.println(s6);

        System.out.println(s1.equals(s4)); //false
        System.out.println(s1.equalsIgnoreCase(s4)); //true

        String s7 = "protect";
        String s8 = s7.concat(" me");
        System.out.println(s8);  //protect me

        String s9 ="abc";
        String s10 = new String("adb");
        System.out.println(s9.compareTo(s10)); // -2 负数就当前s9小于s10 涉及到字符串排序

        String s11 = "北京科技有限公司";
        String s12 = s11.substring(1);
        System.out.println(s12); //科技有限公司
        String s13 = s11.substring(4,6);
        System.out.println(s13);//有限  [4,6)左闭右开

    }

    @Test
    public void test5(){
        String s1 = "helloworld";
        boolean b1 = s1.endsWith("ld");
        System.out.println(b1); //true

        boolean b2 = s1.startsWith("He");
        boolean b3 = s1.startsWith("he");
        System.out.println(b2); //false
        System.out.println(b3); //true

        boolean b4 =s1.startsWith("ll" ,2);
        System.out.println(b4); //true

        String s2 = "wo";
        System.out.println(s1.contains(s2)); //true

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

        System.out.println(s1.indexOf("lo",5)); //-1

        String s3 = "hellorworld";
        System.out.println(s3.lastIndexOf("or")); //7
        System.out.println(s3.lastIndexOf("or",6)); //4
         //什么情况下，indexOf( str)和机LastIndexOf(str)返回值相同?
         //情况一:存在唯一的一个str。情况二:不存在str
    }

    @Test
    public void test6(){
        String s1 = "东京食尸鬼东京";
        String s2 = s1.replace("东","南");
        System.out.println(s1); //东京食尸鬼东京 String的不可变性
        System.out.println(s2); //南京食尸鬼南京

        String s3 = "12hello34wor1d5java7891mysq1456";
        String s4 = s3.replaceAll("\\d+",",");
        System.out.println(s4); //,hello,wor,d,java,mysq,

        String s5 ="12345";
        boolean matches = s5.matches("\\d+");
        System.out.println(matches); //true
        String s6 = "0571-4534289";
        boolean result = s6.matches("0571-\\d{7,8}");
        System.out.println(result); //true

        String s7 = "hello|world|java";
        String [] s8 =s7.split("\\|");
        for (int i = 0; i < s8.length; i++) {
            System.out.println(s8[i]); // hello  world world
        }
    }

    @Test
    public void test7() throws UnsupportedEncodingException {
        /**复习:
        * string与基本数据类型、包装类之间的转换。
        * string -->基本数据类型、包装类:调用包装类的静态方法: parsexxx(str)基本数据类型
        * 包装类--> string:调用string重载的vaLueof(xxx)
         */
        String s1 ="12345";
        int i1 = 123;
        int num = Integer.parseInt(s1);
        System.out.println(num);  //12345

        String s2 = String.valueOf(i1);
        System.out.println(s2); //"123"

        String s3 = num + "";
        System.out.println(s1 ==s3); //false

        System.out.println("*****************新内容1********************");

        /**
         * 新内容1：String 与 char[]之间的转换
         * String ---> char[]: 调用String的toCharArray()
         * char[] ---> String: 调用String的构造器
         *
         */
        String s4 ="abc123";
        char[] charArray = s4.toCharArray(); //  String ---> char[]: 调用String的toCharArray()
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] chars = {'h', 'e', 'l', 'l', 'o'};
        String s5 = new String(chars);
        System.out.println(s5);

        System.out.println("********新内容2**************");

        /**
         * 新内容2：String 与 byte[]之间的转换
         *String ---> byte[]: 调用String的getBytes()
         *
         * 编码：字符串--->字节 （看得懂---》看不懂的二进制数据）
         * 解码：字节---> 字符串 （看不懂的二进制数据---》看得懂）
         *
         * 说明： 解码时，要求解码使用的字符集必须要与编码时使用的字符集一致，否则出现乱码。
         *
         */

        String s6 ="abc123中国";
        byte[] bytes = s6.getBytes(); // 使用默认的字符集，进行转换
//        for (int i = 0; i < bytes.length; i++) {
//            System.out.println(bytes[i]); // 97 98 99 49 50 51
//        }
        System.out.println(Arrays.toString(bytes)); //[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]

        byte[] gbks = s6.getBytes("gbk"); // 使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks)); //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]

        System.out.println("----------");
        String s7 = new String(bytes);
        System.out.println(s7); // "abc123中国"

        String s8 = new String(gbks);
        System.out.println(s8); //abc123�й� 乱码了 原因：编码集和解码集不一致！

        System.out.println(new String(gbks,"gbk")); //abc123中国


    }


    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.print(ex.str + " and ");
        System.out.println(ex.ch);  // good and best
    }
}