Day11:字符串

一：API

        通过API使用别人开发好的类，提高开发效率。

        API(Application Programming Interface)：应用程序接口

        Java API：指的就是JDK中提供的各种功能的Java类，这些类的底层实现被封装了，因此只需要学习如何使用即可。

        API帮助文档：帮助开发人员更好的使用和查询API的工具

        如何使用帮助文档

 二：字符串概述

        String概述：java.lang.String类代表字符串,Java程序中的所有字符串文字都是此类的对象

        String注意点：字符串的内容是不会改变的，他的对象在创建之后就不能修改了

                                两个字符串的拼接会产生一个新的字符串

                                用另一个字符串对新字符串赋值，会使得两个字符串存的是相同的地址

三：String构造代码和内存分析

        分为：直接赋值        和             new方法

package com.it.stringdemo;

public class stringdemo {
    public static void main(String[] args) {
        //直接赋值的方法创建字符串对象
        String s1 = "abc";
        System.out.println(s1);     //abc

        //使用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

        //传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
        //应用场景：网络中传输的数据都是字节信息
        //一般要把字节信息进行转换，转换成字符串，根据ASCII码
        byte [] bytes = {97,98,99,100};
        String s5 = new String(bytes);
        System.out.println(s5);     //abcd

    }
}

        两种赋值方法的内存区别：

        1) 当使用双引号赋值时，系统会检查该字符串是否再串池中存在，如果存在则复用，不存在就创建新的。因此，连续直接创建的相同字符串，存放的地址是一样的

        

         2）当使用new方式赋值时，会直接再堆空间中创建新空间，不会复用

四：字符串比较方法

        ==号比较：基本数据类型比较数据值，引用数据类型比较地址值

        str.equals比较：比较字符串内容，区分大小写

        str.equalsIgnoreCase比较：比较字符串内容，不区分大小写

package com.it.stringdemo;

public class stringDemo1 {
    public static void main(String[] args) {
        //字符串的比较

        //1.创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "abc";
        String s3 = "Abc";

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

        //3.equal比较字符串内容是否相等
        boolean result1 = s1.equals(s2);
        System.out.println(result1);    //true

        //4.equalsIgnoreCase比较字符串内容是否相等，忽略大小写
        boolean result2 = s1.equals(s3);
        boolean result3 = s1.equalsIgnoreCase(s3);

        System.out.println(result2);    //false
        System.out.println(result3);    //true
    }
}

五：练习-用户登录

ps1：ctrl + b 打开封装后对象的源码

ps2：ctrl +alt + t ：使用循环包装代码

六：遍历字符串

        s.length()：返回字符串的长度

        s.charAt(int index)：根据索引返回字符

package com.it.stringdemo;

import java.util.Scanner;

public class stringDemo2 {
    public static void main(String[] args) {
        //统计字符次数：键盘输入一个字符串，统计串中大写字母，小写字母和数字个数

        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("输入字符串");
        String s = sc.next();

        //2.统计个数

        //定义字母和数字计数器
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //字符串的遍历:s.length.fori
        for (int i = 0; i < s.length(); i++) {
            //根据索引取字符
            char c = s.charAt(i);
            if(c >= 'A' && c <= 'Z'){
                bigCount ++;
            } else if (c >='a' && c <= 'z') {
                smallCount ++;
            } else if (c >= '0' && c <= '9') {
                numberCount ++;
            }
        }

        //输出字符和数字的个数
        System.out.println(bigCount + " " + smallCount + " " +numberCount);
    }
}

七：字符串的拼接和反转

        字符串的拼接：

        字符串的遍历：str.length.fori

        字符串的反向遍历：str.length.forr

package com.it.stringdemo;

public class stringDemo3 {
    public static void main(String[] args) {
        //写一个方法，输入是字符数组，返回的是拼接后的字符串

        char []  arr = {'1','2','3'};
        String str = arrToString(arr);

        System.out.println(str);
    }

    public static String arrToString(char [] arr){
        //先判断送入的是否是可使用的字符
        if (arr == null){
            return "";
        }

        if (arr.length == 0){
            return "";
        }

        //开始拼接
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            str  = str + arr[i];

            //拼接逗号
            if (i < arr.length-1) {
                str = str + ", ";
            }
        }

        str = str +"]";
        //返回字符串
        return str;
    }
}

八：金额转换

九：手机号屏蔽和身份证信息查看和敏感词屏蔽

       字符串的截取：两种方式

        String.substring(int beginindex, int endindex)

        注意点：包头不包尾，包左不包右。        返回值才是截取的小串

        String.substring (int beginIndex)        从beginIndex开始截取到末尾

        手机号屏蔽：

package com.it.stringdemo;

public class stringDemo5 {
    public static void main(String[] args) {
        //需求：屏蔽手机号的中间位数
        //1.获得手机号
        String phoneNumber = "12345678901";

        //2.截取前三位
        String s1 = phoneNumber.substring(0,3);

        //3.截取后四位
        String s2 = phoneNumber.substring(7);

        //4.拼接字符串
        String result = s1 + "****" +s2 ;

        System.out.println(result);
    }
}

       字符串的替换

        String.replace(Target , Replacement)

{
    public static void main(String[] args) {
        //需求：屏蔽敏感词

        //1.获取说的话
        String talk = "你他妈的，我真的TMD,CNMSB";

        //2.屏蔽关键词
        String [] arr = {"TMD","CNM","SB"};

        //3.循环遍历每一个敏感词，并替换
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i] , "***");
        }

        System.out.println(talk);
    }
}

十：StringBuilder的操作

        StringBuilder可以看作一个容器，创建之后里面的内容是可变的。

        作用：提高字符串的操作效率。之前的字符串的拼接是一个一个的拼的，每拼接一次就要新建一个字符串，非常慢

         StringBuilder的构造方法：

                public StringBuilder()        空参构造：创建一个空白的可变字符串对象，不含内容

                public StringBuilder(String str)        有参构造：根据字符串的内容，创建可变字符串对象

        StringBuilder常用方法：

                StringBuilder sb = new StringBuilder();

                添加元素：sb.append(元素)        可以添加任意类型的元素

                反转字符串：sb.reverse()        

                获取长度：sb.length()

                StringBuilder变回字符串：String str = sb.toString();

        链式编程：当我们调用一个方法的时候，不需要定义变量接受结果，而是继续调用其他的方法。

                int len = getString().subString(1).replace("a","b").length();

        判断对称字符串：

package com.it.stringBuilderDemo;

public class stringBuilderDemo0 {
    public static void main(String[] args) {
        //需求：判断对称字符串

        //1.定义一个字符串
        String str = "abc123321cba";

        //2.反转输入的字符串
        String result = new StringBuilder().append(str).reverse().toString();

        //3.比较反转前后字符串
        if (result.equals(str)){
            System.out.println("是的");
        } else {
            System.out.println("不是");
        }


    }
}

        使用StringBuilder的场景：字符串的拼接和反转

        使用StringBuilder拼接数组中的数字并返回：

package com.it.stringBuilderDemo;

public class stringBuilderDemo1 {
    public static void main(String[] args) {
        //需求：定义一个方法，把int数组中的数据拼接成一个字符串返回，调用该方法，输出结果
        int [] arr = {1,2,3,4};
        String str = arrToString(arr);
        System.out.println(str);
    }

    public static String arrToString(int [] arr) {
        //1.定义一个StringBuilder接受数组中的数据
        StringBuilder str = new StringBuilder("[");

        for (int i = 0; i < arr.length; i++) {
            str.append(arr[i]);

            if(i<arr.length-1){
                str.append(",");
            }
        }
        str.append("]");
        return str.toString();
    }
}

十一：StringJoiner

        StringJoiner概述：StringJoiner和StringBuilder一样，也可以看作是一个容器，创建之后里面内容是可变的。

        StringJoiner作用：提高字符串的操作效率，且代码的编写特别简单

        StringBuilder的构造方法：两种

                StringJoiner sj = new StringJoiner("---")';       指定拼接时的间隔符号        1---2---3

                StringJoiner sj = new StringJoiner("," , "[" , "]");        指定拼接时的间隔符号，开始符号和结束符号。        [1,2,3,4]

        StringBuilder的成员方法：三种

                StringJoiner sj = new StringJoiner ("---");

                添加元素：sj.add("aaa").add("bbb")

                获取长度：sj.length()

                变回字符串：sj.toString();

        StringJoiner优势：可以高效方便的拼接字符串

十二：字符串的底层原理

        1.字符串存储的内存原理

                1）直接赋值会复用字符串常量池中的字符串

                2）new出来的字符串不会复用，而是开辟一个新的空间

        2.==号比较的是什么

                1）基本数据类型比数据值

                2）引用数据类型比地址值

        3.字符串拼接的底层原理

                1）没有变量参与的拼接过程：此时的拼接会触发字符串的优化机制，编译时候就是最终结果。即编译器会把字符串先拼接好，再去执行别的代码。这是会复用串池中的字符串

                

                 2）有变量参与的字符串拼接过程：当新建了字符串在堆内存中后，系统在底层创建了一个StringBuilder容器，通过StringBuilder来拼接两个字符串，在将拼接后的StringBuilder   toString成字符串返回。这里返回的字符串是toString新创建出来的

        

                每使用一个加号，堆内存中就新建两个对象

                 结论：如果很多字符串变量拼接，不要直接+，会在底层创建很多对象，浪费时间

        4.StringBuilder提高效率原理

                所有的要拼接的内容都会存放在StringBuilder里面，不会创建多余的空间

        5.StringBuilder源码分析

                sb.capacity()        容量

                sb.lenth()        长度

十二：调整字符串

        字符串转成数组：Char [] arr = str.toCharArray();

ps3：ctrl + N，在IDEA中搜索关键字

ps4:ctrl + F12，在java的class文件中展示所有的方法