API&字符串（String概述，Java的常用方法比较，截取方法，替换方法，String Builder，StringJoiner，扩展字符串原理，相关的综合练习）

提取码：6w85http://链接：https://pan.baidu.com/s/13iAJC4t5lFPsZxIVL_nRFQ 提取码：6w85

String 概述 ： 

•  java.lang.String 类代表字符串,Java 程序中的所有字符串文字 (例如“abc”)都为此类的对象
• 字符串的内容是不会发生改变的，它的对象在创建后不能被更改 

 代码演示

public class Stringdeomoq {
    public static void main(String[] args) {
        //使用直接赋值方式获取一个字符串对象
        String s1 = "abx";
        System.out.println(s1);
        //2.使用new的方式来获取一个字符串对象
        // 空参构造:可以获取一个空白的字符串对象
        String s2 = new String();//打印出来什么都没有
        System.out.println(s2);
//传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
        //需要修改字符串的内容是能用到这种
        char[] s3 = {'d', 's', 'v'};
        String s4 = new String(s3);
        System.out.println(s4);
        //传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
        // 应用场景: 以后在网络当中传输的数据其实都是字节信息
        // 我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了。
        byte[] bytes ={97,98,99,100};
        String s5 = new String(bytes);
        System.out.println (s5);//abcd
    }
}

Java的内存模型

java的常用方法比较

 

 代码演示

public class Stringdemo2 {
    public static void main(String[] args) {
        String s1="abc";
        String s2=new String("abc");
        System.out.println(s1==s2);
        //==基本数据类型：比的是实际值
        //    引用数据类型：比的是地址值


        // 比较字符串里面的内容是否相等
       //equals 比较的时候必须完全相同
        boolean result=s1.equals(s2);//s1跟s2进行比较
        System.out.println(result);


        // 比较字符串里面的内容是否相等，忽略大小写
        boolean result2=s1.equalsIgnoreCase(s2);
        System.out.println(result2);
    }
}

练习：用户登录

import java.util.Scanner;

public class demo3 {
    public static void main(String[] args) {
       /* 需求:已知正确的用户名和密码，
       请用程序实现模拟用户登录总共给三次机会，登录之后，给出相应的提示*/
        int count = 3;
        //给三次机会，判断三次
        for (int i = 0; i < 3; i++) {
            //账号
            String str0 = "3122004635";
            System.out.println("请输入账号");
            Scanner sc = new Scanner(System.in);
            String strID = sc.next();

            //密码
            String str3 = "abdukayyum";
            System.out.println("请输入密码");
            String str4 = sc.next();
            //判断
            if (str0.equals(strID) && str3.equals(str4)) {

                System.out.println("登录成功");
                break;
            } else {
                count--;
                if (count==0){
                    System.out.println("你的账号已被锁定，请联系管理员");
                }else{

                    System.out.println("账号或密码错误"+"还有"+count+"次机会");
                }

            }
        }
    }
}

遍历字符串

import java.util.Scanner;

public class demo4 {
    public static void main(String[] args) {
        //需求：键盘录入一个字符串，并进行遍历
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str1= sc.next();
        //遍历
        for (int i = 0; i < str1.length(); i++) {
            //i 一次表示字符串里面的每一个索引
            char c = str1.charAt(i);
            System.out.println(c);

        }

    }
}

练习统计字符串

import java.util.Scanner;

public class demo5 {
    public static void main(String[] args) {
        //键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //定义计数
        int bigcount = 0;
        int smallcount = 0;
        int numbercount = 0;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c >= 'a' && c <= 'z') {
                smallcount++;
            } else if (c >= 'A' && c <= 'Z') {
                bigcount++;
            } else if (c <= '9' && c >= '0') {
                numbercount++;
            }

        }
        System.out.println("大学字符有" + bigcount);
        System.out.println("小写字符有" + smallcount);
        System.out.println("数字有" + numbercount);

    }
}

字符串的拼接

public class demo6 {
    public static void main(String[] args) {
        /*定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回6调用该方法，并在控制台输出结果例如:
数组为int arr={1,2,3);
执行方法后的输出结果为:[1,2,3]*/
        int[]arr={1,3,4};
String str=arrToString(arr);
System.out.println(str);
    }
    public static String arrToString(int  arr[]){
        if (arr==null){
            return "";}
            if (arr.length==0){
                return "[]";
            }
            String result="[";
            for (int i = 0; i < arr.length-1; i++) {
                result=result+arr[i]+",";
                result+=arr[i+1];
            }

            result+="]";
            return result;

        }




    }

字符串的反转

import java.util.Scanner;

public class demo7 {
    public static void main(String[] args) {
        /*定义一个方法，实现字符串反转键盘录入一个字符串，
        调用该方法后，在控制台输出结果例如，键盘录入 abc，输出结果 cba*/
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        String result = strTo(str);
        System.out.print(result);

    }
    public static String strTo(String str) {
        String result="";
        for (int i = str.length() - 1; i >= 0; i--) {
            char c = str.charAt(i);
            result = result + c;
        }
        return result;
    }

}

金额转换

import java.util.Scanner;

public class demo8 {
    public static void main(String[] args) {
        //键盘录入
        int money;
        while (true) {
            Scanner sc = new Scanner(System.in);
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {
                break;
            } else {
                System.out.println("金额无效,请重新输入");
            }
        }
//得到每一位数字的中文大写
        String moneyStr = "";
        while (true) {

            int ge = money % 10;
            String capital = getCapitalNumber(ge);
            moneyStr = capital + moneyStr;

            money = money / 10;
            if (money == 0) {

                break;
            }
        }
        //前面补零
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        //插入单位
        //定义一个数组表示单位
        String[] arr = {"佰", "拾", "万", "千", "佰", "拾", "元"};
        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            result = result + c + arr[i];

        }
        System.out.print(result);

    }

    //定义一个方法，把数字写成大写的
    public static String getCapitalNumber(int number) {
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "琉", "柒", "捌", "玖"};
        return arr[number];
    }
}

截取方法

代码演示 手机号屏蔽

public class demo10 {
    public static void main(String[] args) {
        String phne = "15209030645";
        String start = phne.substring(0, 3);
        String end = phne.substring(7);
        String result = start + "****" + end;
        System.out.println(result);
    }
}

身份证信息查

import java.util.Scanner;

public class demo11 {
    public static void main(String[] args) {
        String number;
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你的身份证号");
            number = sc.next();
            if (number.length() == 18) {
                break;
            } else {
                System.out.println("账号输入有错，请重新输入");
            }
        }
        //截取 年月日
        String year = number.substring(6, 10);
        String mounth = number.substring(10, 12);
        String day = number.substring(12, 14);
        String gender = number.substring(16, 17);
        int num = Integer.parseInt(gender);
if (num %2==0){
gender="女";
}else {
    gender="男";
}

//打印
        System.out.println("任务信息为：");
System.out.println("出生年月日："+year+"年"+mounth+"月"+day+"日");
System.out.println("性别为"+gender);
    }
}

替换方法

敏感词替换

public class demo12 {
    public static void main(String[] args) {
        //敏感词替换
        String talk = "TMD,好好打游戏，不然滚回去刷厕所SB";
        //建一个敏感词库
        String[] arr = {"TMD", "CNM", "SB", "MLGB"};
        //循环进行判断并替换，有没有敏感词库里面的词
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i], "***");
        }
        /*  //替换
        String newTalk=talk.replace("TMD","***");*/
        System.out.println(talk);
    }
}

String Builder

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

作用：提高字符串的操作效率

String Builder构造方法

StringBuilder常用方法

 代码演示

public class demo13 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abc");
       /* sc.append(520);
        sc.append("s");
        sc.append(true);
        System.out.println(sc);
        abc520strue*/
        //反转
        sb.reverse(); //cba
//获取长度
        int len = sb.length();//3

        System.out.println(len);


    }
}

  

public class demo14 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sc=new StringBuilder("abc");
        //添加字符串
        sc.append("abc");
        sc.append("def");
        sc.append("ghi");
        sc.append("jkl");
        //变回字符串
        String str=sc.toString();
        System.out.println(str);
    }
}

链式编程

当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法

代码演示

import java.util.Scanner;

public class demo15 {
    public static void main(String[] args) {
        //链式编程
        int len = getString().replace("a", "A").substring(0).length();
        System.out.println(len);
    }

    public static String getString() {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        return str;
    }

}

练习对称字符串

import java.util.Scanner;

public class demo16 {
    public static void main(String[] args) {
        /*需求:键盘接受一个字符串，程序判断出该字符串是否是对称字符串，
        并在控制台打印是或不是对称字符串:123321、111
        非对称字符串:123123*/
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

      /*  //反转，拼接键盘录入的字符串
        StringBuilder sb=new StringBuilder();
sb.append(str);//字符串的数值赋给sb对象
        sb.reverse();//反转方法*/

        //上面的内容通过链式方程来实现
        String result = new StringBuilder().append(str).reverse().toString();

        //比较
        if (str.equals(result)) {
            System.out.println("当前数据是对称的");
        } else {
            System.out.println("当前数据不是对称的");

        }
    }
}

练习拼接字符串

public class demo17 {
    public static void main(String[] args) {
        /*需求:定义一个方法，把int 数组中的数据按照指定的格式拼接成一个字符串返回调用该方法，并在控制台输出结果。
        例如:数组为in切]arr={1,2,3);执行方法后的输出结果为:[1,2,3]*/
        int[] arr = {1, 2, 3};
        String str = arrToString(arr);
        System.out.println(str);
    }

    public static String arrToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1) {
                sb.append(arr[i] + ",");
            } else if (i <= arr.length) {
                sb.append(arr[i] + "]");
            }
        }
        return sb.toString();
    }
}

StringJoiner

• Stringjoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的
• 作用:提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用
• JDK8出现的

构造方法

 成员方法

代码演示

import java.util.StringJoiner;

public class demo18 {
    public static void main(String[] args) {
        //创建对象
       /* StringJoiner sj=new StringJoiner("**");
        sj.add("ds").add("63").add("97");
        System.out.println(sj);//ds**63**97*/

        StringJoiner sj = new StringJoiner(",", "[", "]");
        sj.add("1").add("2").add("3");
        System.out.println(sj);//[1,2,3]

        int len = sj.length();//7

        String str = sj.toString();
        System.out.println(str);

    }
}

 字符串三大类总结

扩展字符串原理

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

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

• new出来不会复用，而是开辟一个新的空间 

原理2，==号比较的是什么

• 基本数据类型比较数据值
• 引用数据类型比较地址值

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

•  如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的
• 字符串如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。 

原理4，SringBuilder提高效率原理图

• 所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存 

StringBuilder源码分析 

•  默认创建一个长度为16的字节数组
• 添加的内容长度小于16，直接存
• 添加的内容大于16会扩容(原来的容量*2+2)
• 如果扩容之后还不够，以实际长度为准

综合练习

罗马字符转换（1）

做题思想，查表法，StringJoiner ，StringBuilder，charAt()等

import java.util.Scanner;
import java.util.StringJoiner;

public class demo20 {
    public static void main(String[] args) {
/*键盘录入一个字符串
要求1:长度为小于等于9
要求2:只能是数字
将内容变成罗马数字
下面是阿拉伯数字跟罗马数字的对比关系
I -1、Il -2、1l-3、IV -4、V -5、V- 6、VIl - 7、VIl - 8、IX -9注意点:
罗马数字里面是没有0的
如果键盘录入的数字包含0，可以变成””(长度为0的字符串)*/
        Scanner sc = new Scanner(System.in);
        String str;
        //校验代码
        while (true) {
            System.out.println("请输入长度小于9的数字");
            str = sc.next();
            boolean flag = checkstr(str);
            if (flag = true) {
                break;
            } else {
                System.out.println("当前数字是非法的，请重新输入");
            }
        }

        //阿拉伯数字和罗马数字对应关系
        String result = "";
        StringBuilder sb = new StringBuilder();
        StringJoiner sj = new StringJoiner(",", "{", "}");
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int number = c - 48;
            result = getLuoma(number);
            sb.append(result);
            sj.add(result);

        }
        System.out.println(sb);
        System.out.print(sj);

    }
    
    //罗马数字的对应关系
    public static String getLuoma(int number) {
        String[] arr = {",", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
        return arr[number];

    }


    //判断
    public static boolean checkstr(String str) {
        //判断长度
        if (str.length() > 9) {
            return false;
        }

        //判断是否全是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c > '9' || c < '0') {
                return false;
            }

        }
        return true;

    }


}

调整字符串

需求：给定两个字符串,A和B
A的旋转操作就是将A最左边的字符移动到最右边例如,若A='abcde'，在移动一次之后结果就是bcdea'如果在若干次调整操作之后，A能变成B，那么返回True。如果不能匹配成功，则返false

解法一 

import static jdk.nashorn.internal.objects.NativeString.charAt;
import static jdk.nashorn.internal.objects.NativeString.substring;
//第一种解法，substring 进行截取再来拼接的思路
public class test2 {
    public static void main(String[] args) {
        /*给定两个字符串,A和B
A的旋转操作就是将A最左边的字符移动到最右边例如,
若A='abcde'，在移动一次之后结果就是bcdea'如果在若干次调整操作之后
，A能变成B，那么返回True。如果不能匹配成功，则返false*/


        //定义两个字符串
        String strA="abcde";
        String strB="cdeab";
 strA=rotate(strA);
    //循环旋转并比较
        boolean result=check(strA,strB);
System.out.println(result);
    }


public static boolean check(String strA,String strB){
    for (int i = 0; i < strA.length(); i++) {
        strA=rotate(strA);
         if (strA.equals(strB)){
        return  true;}

    }
    //所有的情况比较完毕了，还不一样的情况
    return  false;
}


    //旋转
    public static String rotate(String str){

        char first=str.charAt(0);//获取最左侧的字符
        String end=str.substring(1);//获取剩余的字符
        return end+first;


    }

}

 解法二

import static jdk.nashorn.internal.objects.NativeString.charAt;
import static jdk.nashorn.internal.objects.NativeString.substring;
//第二种解法，str.Tochararray() 的方法把字符串转换为字符数组
public class test2case2 {
    public static void main(String[] args) {
        /*给定两个字符串,A和B
A的旋转操作就是将A最左边的字符移动到最右边例如,
若A='abcde'，在移动一次之后结果就是bcdea'如果在若干次调整操作之后
，A能变成B，那么返回True。如果不能匹配成功，则返false*/


        //定义两个字符串
        String strA="abcde";
        String strB="cdeab";
        strA=rotate(strA);
        //循环旋转并比较
        boolean result=check(strA,strB);

        System.out.println(result);
 
    }


    public static boolean check(String strA,String strB){
        for (int i = 0; i < strA.length(); i++) {
            strA=rotate(strA);
            if (strA.equals(strB)){
                return  true;}

        }
        //所有的情况比较完毕了，还不一样的情况
        return  false;
    }


    //旋转
    public static String rotate(String str){

        char[] arr=str.toCharArray();
//先存储零索引上的字符
        char first=arr[0];
        for (int i = 1; i < arr.length; i++) {
            arr[i-1]=arr[i];
        }
        arr[arr.length-1]=first;
        String result=new String(arr);
return  result;
    }

}

价盘录入任意字符串打乱里面的内容

import java.util.Random;
import java.util.Scanner;

public class test03 {
    public static void main(String[] args) {
        //打乱字符串
        //键盘录入一个字符串
       /* Scanner sc=new Scanner(System.in);
        System.out.println("请输入字符串");
        String str= sc.next();*/
String str="love";
        Random r=new Random();


        //2.打乱
String result=shuffle(str);
System.out.println(result);
    }
    public static String shuffle(String str){
        char[] arr=str.toCharArray();
        Random r=new Random();
        char index;
        for (int i = 0; i < arr.length; i++) {
            int   j=r.nextInt(arr.length-1);
          index=arr[i];
          arr[i]=arr[j];
          arr[j]=index;
        }
        String result=new String(arr);
        return  result;
    }
}

生成验证码

import java.util.Random;

public class test04 {
    public static void main(String[] args) {
             /*生成验证码
内容:可以是小写字母，也可以是大写字母，还可以是数字
规则:
长度为5
内容中是四位字母，1位数字。其中数字只有1位，但是可以出现在任意的位置。*/
//生成一个原料字符串
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        //获取随机数
        Random random=new Random();

        //生成四位验证码
        StringBuilder code=new StringBuilder();
        for (int i = 0; i < 4; i++) {
         char randomchar=str.charAt(random.nextInt(52));//将上面的字符串中获取字母段1-52中随机获取
            code.append(randomchar);
        }

char randomNumber=str.charAt(50+ random.nextInt(10));
        int position=random.nextInt(5);
        code.insert(position,randomNumber);
        System.out.println(code);
    }
}

public class test5 {
    public static void main(String[] args) {

        /*注意:需要用已有的知识完成。*/
        /*给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式*/

        String str1="123456";
        String str2="1234";

        int number1 =Integer.parseInt(str1);
        int number2 =Integer.parseInt(str2);
        int multip=number1*number2;
        String result=Integer.toString(multip);
        System.out.println(result);
    }
}