Java学习笔记7

😋😋😋😋😋

API

应用程序接口（application programming interface）

简单理解：API就是别人已经写好的东西，我们不需要自己编写，直接使用即可。

Java API:指的就是JDK中提供的各种功能的Java类。

例如

Scanner	键盘录入
Random	随机数

API：目前是jdk中提供各种功能的Java类。

这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

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

字符串

java.lang.String类代表字符串，Java程序中的所有字符串文字都为此类的对象。（使用时不需要导包）

字符串的内容是不会发生改变的，他的对象在创建后不能被更改。

创建String对象的两种方式

1直接赋值
String name = "张彧"；

2new 

构造方法	说明
public String()	创建空白字符串，不包含任何内容
public String(String original)	根据传入的字符串，创建字符串对象
public String(char[] chs)	根据字符数组，创建字符串对象
public String(byte[] chs)	根据字节数组，创建字符串对象

eg

public class Hello {
    public static void main(String[] args) {
        //1直接使用赋值方法获取一个字符串对象
        String s1 = "张彧";
        System.out.println(s1);

        //2使用new的方式来获取一个字符串对象
        String s2 =new String();
        System.out.println(s2);

        //传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
        String s3 = new String("abc");
        System.out.println(s3);

        //传递一个字符数组，根据字符数组的类容在创建一个新的字符串对象
        //需求：要修改字符串的内容
        char[] chas = {'a','b', 'c','d'};
        String s4 = new String(chas);
        System.out.println(s4);

        //传递一个字节数组，根据字节数组的类容在创建一个新的字符串对象
        byte[] bytes= {99,98,97};
        String s5 = new String(bytes);
        System.out.println(s5);
    }
}

字符串比较

boolean equals方法（要比较的字符串）
完全一样结果才是true，否则为false

boolean equalslgnoreCase(要比较的字符串)
忽略大小写的比较

练习：已知正确的用户名和密码，请用程序员实现模拟用户登录。总共三次机会，登录之后，给出相应的提示。

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        String rightUsername = "zhangsan";
        String rightPassword = "123456";
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入账号:");
            String username = sc.next();
            System.out.println("请输入密码:");
            String password = sc.next();

            if(rightUsername.equals(username) && rightPassword.equals(password)){
                System.out.println("登陆成功");
                break;
            }else{
                if(i ==2){
                    System.out.println("你的账号" +username+"已经被锁定，请联系客服");
                }
                else{System.out.println("输入的账号或密码错误，你还剩下"+(2-i)+"次机会，从新输入");}
            }
        }
    }
}

遍历字符串

需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串。

注意

public char charAt(int index):根据索引返回字符

public int length(): 返回此字符串的长度

数组的长度：数组名.length

字符串的长度：字符串对象.length（）

例如

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        //1键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();

        //2str.length().fori遍历字符串
        for (int i = 0; i < str.length(); i++) {
            char s =str.charAt(i);
            System.out.print(s);
        }
    }
}

例题：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数。

import java.util.Scanner;

public class Hello{
    public static void main(String[] args) {
        //1创建一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //2统计个数
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //3遍历字符串比较
        for (int i = 0; i < str.length(); i++) {
        //char类型的变量在参与计算的时候自动类型提升为int，查询ascii码表
            char c = str.charAt(i);
            if(c >= 'a' && c <= 'z'){
                smallCount++;
            }else if (c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }
        System.out.println("大写字符的个数：" +bigCount+"个");
        System.out.println("小写字符的个数：" +smallCount+"个");
        System.out.println("数字字符的个数：" +numberCount+"个");
    }
}

拼接字符串

例题：定义一个方法，把int数组中的数据按照指定格式拼接成一个字符串返回调用该方法，并在控制台输出结果。例如：数组为int【】arr = {1，2，3}；执行方法后的输出结果为：【1，2，3】

只要看到定义方法，就问自己三个问题
1我要干嘛？
2我干这件事情需要什么才能完成？
3我干完了是否要把结果返回给调用处
如果调用处需要继续使用，那么必须返回
如果调用处不需要继续使用，那么可以返回也可以不返回

public class Hello {
    public static void main(String[] args) {
        int[]arr = {1,2,3};
        String arr1 = arrToString(arr);
        System.out.println(arr1);
    }
    public static String arrToString(int[]arr){
        if(arr == null){
            return "";
        }if(arr.length == 0){
            return "[]";
        }
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                result = result + arr[i];
            }else{result = result + arr[i] + ", ";}
        }
        result = result+ "]";
        return result;
    }
}

字符串反转

例题：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。例如，键盘录入abc，输出结果cba。

public class Hello {
    public static void main(String[] args) {
        String result =reverser("abc");
        System.out.println(result);
    }
    public static String reverser(String str){
        String result ="";
        //str.length().fori从0开始遍历
        //str.length().forr从最后开始遍历
        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 Hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int money;
        while (true){
            System.out.println("请输入一个金额：");
            money = sc.nextInt();
            if(money>=0 && money<=9999999){
                break;
            }else{
                System.out.println("输入的金额有误，请重新输入：");
            }
        }
        String moneyStr = "";
        while (true){
            int ge = money%10;
            String capitalNumber = getCapitalNumber(ge);
            money = money/10;
            moneyStr = capitalNumber+moneyStr;
            if(money == 0){
                break;
            }
        }
        int count =7-moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" +moneyStr;
        }
        System.out.println(moneyStr);
    }
    //定义一个方法，对应大小写
    public static String getCapitalNumber(int number){
        String[]arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        return arr[number];
    }
}

截取方法

String substring(int beginindex,int endindex) 截取
包头不包围，包左不包右
只有返回值才是截取的小串
String substring(int beginindex) 截取到末尾

例题：身份证信息查看

public class Hello {
    public static void main(String[] args) {
        String id = "340321202010104993";
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);
        System.out.println("个人信息为：");
        System.out.println("出生年月份:" +year+"年"+month+"月"+day+"日");
        char num = id.charAt(16);
        int gender =num-48;
        if(gender%2==0){
            System.out.println("性别：男");
        }else{
            System.out.println("性别：女");
        }
    }
}

替换方法

String replace(旧值,新值) 替换
只有返回值才是替换之后的结果

StringBuilder概述

StringBuilder可以看作是一个容器，创建之后里面的内容是可变的。作用：提高字符串的操作效率

StringBuilder构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

StringBuilder常用方法

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	反转容器中的内容
public int length()	返回长度（字符出现的个数）
public String toString()	通过toString()就可以实现把StringBuilder转为String

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

例题：对称字符串

需求：键盘录入一个字符串，程序判断该字符串是否对称，并在控制台打印是不是对称字符串。

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //反转键盘录入字符串
        String result = new StringBuilder().append(str).reverse().toString();
        //比较
        if(str.equals(result)){
            System.out.println("当前字符串是对称字符串");
        }else{
            System.out.println("当前字符串不是对称字符串");
        }
    }
}

例题：定义一个方法，把int数组中的数据按照指定格式拼接成一个字符串返回调用该方法，并在控制台输出结果。例如：数组为int【】arr = {1，2，3}；执行方法后的输出结果为：【1，2，3】

public class Hello {
    public static void main(String[] args) {
        //定义数组
        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{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

StringJoiner概述

StringJoiner的构造方法

方法名	说明
public StringJoiner(间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号，开始符号，结束符号

StringJoiner的构成员方法

方法名	说明
public StringJoiner add(添加的内容)	添加数据，并返回对象本身
public int length()	返回长度（字符出现的个数）
public String toString()	返回一个字符串（该字符串就是拼接之后的结果）

字符串原理

扩展底层原理：字符串存储的内存原理

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

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

扩展底层原理：==号比较的到底是什么

基本数据类型比较数据值

引用数据类型比较地址值

扩展底层原理：字符串拼接的底层原理

字符串拼接的时候会有变量参与，在内存中创建了很多对象，浪费空间，时间也慢。

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

*如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串

*如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存

扩展底层原理：StringBuilder提高效率原理图

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

扩展底层原理：StringBuilder源码分析

默认创建一个长度为16的字节数组

添加内容长度小于16，直接存

添加内容大于16会扩容（原来的容量*2+2）

如果扩容之后还不够，以实际长度为准

例如

public class Hello {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        //容量：最多能装多少
        //长度：已经装了多少
        System.out.println(sb.capacity()); //默认16，没扩容
        System.out.println(sb.length()); //0

        sb.append("abcdefghijklmnopqrstuvwxyz");
        System.out.println(sb.capacity()); //需要扩容，16*2+2=34
        System.out.println(sb.length()); //26
    }
}

例题：键盘录入一个字符串。要求：长度小于等于9，只能是数字，将内容变成罗马数字。

查表法解题

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        //1键盘录入
        Scanner sc =new Scanner(System.in);
        String str;
        //ctrl+alt+t变成循环
        while (true) {
            System.out.println("请输入一个字符串：");
            //alt+回车把str移到循环外面
            str = sc.next();
            boolean flag = checkStr(str);
            if(flag){
                break;
            }else{
                System.out.println("输入字符串错误，请重新输入：");
                continue;
            }
        }
        //变成罗马数字
        StringBuilder sb =new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int number = c-48;
            String result = luoMaNumber(number);
            sb.append(result);
        }
        System.out.println(sb);
    }
    //要求0-9，只能是数字
    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<'0' || c>'9'){
                return false;
            }
        }
        return true;
    }
    public static String luoMaNumber(int number){
        String[]arr = {"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};
        return arr[number];
    }
}

switch解题

import java.util.Scanner;

public class Hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个字符串：");
            str = sc.next();
            boolean flag = checkStr(str);
            if(flag){
                break;
            }else{
                System.out.println("输入错误，请重新输入：");
                continue;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            String s = luMaNumber(c);
            sb.append(s);
        }
        System.out.println(sb);
    }
    //定义一个方法：要求输入必须为0-9，且都为数字
    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;
    }
    //定义一个方法：将数字转换罗马数字
    public static String luMaNumber(char number){
        String str = switch (number){
            case '0' -> "";
            case '1' -> "Ⅰ";
            case '2' -> "Ⅱ";
            case '3' -> "Ⅲ";
            case '4' -> "Ⅳ";
            case '5' -> "Ⅴ";
            case '6' -> "Ⅵ";
            case '7' -> "Ⅶ";
            case '8' -> "Ⅷ";
            case '9' -> "Ⅸ";
            default -> "";
        };
        return str;
    }
}

例题：给定两个字符串A与B，将A旋转，就是把最左边的移到最右边，与B相比较，一样返回true，不一样返回false。

public class Hello {
    public static void main(String[] args) {
        String strA = "abcde";
        String strB = "cdeab";
        boolean result = check(strA, strB);
        System.out.println(result);
    }
    //方法比较A与B
    public static boolean check(String strA,String strB){
        for (int i = 0; i < strA.length(); i++) {
             strA = whirl(strA);
            if(strA.equals(strB)){
                return true;
            }
        }
        return false;
    }
    //方法旋转A
    public static String whirl(String str){
        char first = str.charAt(0);
        String end = str.substring(1);
        return end+first;
    }
}

方法2

public class Hello {
    public static void main(String[] args) {
        String strA = "abcde";
        String strB = "cdeab";
        boolean result = check(strA, strB);
        System.out.println(result);
    }
    //方法比较A与B
    public static boolean check(String strA,String strB){
        for (int i = 0; i < strA.length(); i++) {
             strA = whirl(strA);
            if(strA.equals(strB)){
                return true;
            }
        }
        return false;
    }
    //方法旋转A
    public static String whirl(String str){
        char[]arr = str.toCharArray();
        char first = arr[0];
        for (int i = 1; i < str.length(); i++) {
            arr[i-1] = arr[i];
        }
        arr[arr.length-1] = first;
        String result = new String(arr);
        return result;
    }
}

如果以后我们看到要修改字符串内容时

可以有两个办法：

1用subString进行截取，把左边的字符截取出来拼接到右侧去

2可以把字符串先变成一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变成字符串。

例题：键盘输入任意字符串，打乱里面的内容

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

public class Hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        String shuchu = reTO(str);
        System.out.println(shuchu);
    }
    public static String reTO(String s){
        char[] arr = s.toCharArray();
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length);
            char temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        String result = new String(arr);
        return result;
    }
}

例题：生成验证码

内容：可以是小写字母，也可以是大写字母，还可以是数字

规则：长度为5

内容中是四位字母，1位数字。

其中数字只有1位，但是可以出现在任意的位置。

import java.util.Random;

public class Hello {
    public static void main(String[] args) {
        char[]arr = new char[52];
        for (int i = 0; i < arr.length; i++) {
           //添加小写字母，大写字母A-65 a-97
            if(i<=25){
                arr[i] = (char)(97+i);
            }else{
                arr[i] = (char)(97+i-26);
            }
        }
        String code = "";
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int randerIndex = r.nextInt(arr.length);
            code = code+arr[randerIndex];
        }
        int number =r.nextInt(10);
        code = code+number;
        char[]arr1 = code.toCharArray();
        for (int i = 0; i < arr1.length; i++) {
            int index = r.nextInt(arr1.length);
            char temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        String result = new String(arr1);
        System.out.println(result);
    }
}