day08 String类, static关键字, Arrays类, Math类    今天我们继续学习java中常用API。今天主要学习字符串String类，用于数组操作的Arrays类和数学相关的工具类Math类。
以下是今天的学习目标：

• 能够使用String类的构造方法创建字符串对象
• 能够明确String类的构造方法创建对象,和直接赋值创建字符串对象的区别
• 能够使用文档查询String类的判断方法
• 能够使用文档查询String类的获取方法
• 能够使用文档查询String类的转换方法
• 能够理解static关键字
• 能够写出静态代码块的格式
• 能够使用Arrays类操作数组
• 能够使用Math类进行数学运算
  

以下是今天的详细笔记：

String类字符串概述和特点
String字符串的特点:
    1. 字符串的内容永不可变 "abc"
    2. 同一个字符串是被共享使用的   String s = "abc";   String s1 = "abc";
    3. 字符串可由char[]字符数组组成的, 但底层实际是byte[]字节数组
       JDK8及之前, String内部使用char[]保存内容
       JDK9开始, String内部使用byte[]保存内容

[Java] 纯文本查看 复制代码

// 1. 字符串的内容永不可变
String s = "hello";  // "hello"是第一个对象
s = s + "world";     // "world"是第二个对象, 拼接完的"helloworld"是第三个对象. "hello"本身不会改变

// 2. 同一个字符串是被共享使用的
String s1 = "a";  // 0x666
String s2 = "a";  // 也是0x666, 同一个对象

// 3. String可以由char[]组成, 但底层实际是byte[]
String s = "hello"; 
// 字符串可以由char[] chs = {'h', 'e', 'l', 'l', 'o'};组成
// 底层由byte[] bys = {104, 101, 108, 108, 111};组成

字符串的构造方法和直接创建
创建字符串对象的方式:
        1. 使用new调用构造方法创建对象
                new String(): 在堆内存中
        2. 使用双引号形式的字符串字面值常量
                "abc": 在常量池中

java.lang.String: 代表字符串, 包含了字符串的常用操作方法
        构造方法
                String(): 创建一个空白字符串, 不含有任何内容
                String(char[] array): 根据字符数组的内容, 来创建对应的字符串
                String(byte[] array): 根据字节数组的内容, 来创建对应的字符串

[Java] 纯文本查看 复制代码

// 利用无参构造String()创建一个空字符串
String s1 = new String();

// 利用String(char[] array)创建一个包含 'a', 'b', 'c' 字符的字符串
char[] ch = {'a','b','c'};
String s2 = new String(ch);

// 利用String(byte[] array)创建一个包含 'a', 'b', 'c' 字符对应数值的字符串
byte[] b = {'a','b','c'};
String s3 = new String(b);
// 利用字符串常量创建一个 hello 的字符串
String s4 = "hello";

字符串的常量池
字符串常量池: String contant pool. 用于保存字面值字符串常量的区域
        JDK6及之前, 在方法区中
        JDK7开始, 在堆内存中

String内部使用 byte[] 数组存储数据. char[] 数组的字符是根据系统编码表查询得到的

重点:
        1. "abc": 双引号的字符串对象, 是在堆内存中的字符串常量池中
        2. new String(): 构造方法的字符串对象, 是在堆内存中
        3. == 比较基本数据类型时, 比较值; 比较引用数据类型时, 比较地址值

字符串的比较相关方法
比较相关的方法
        boolean equals(Object obj): 比较字符串内容是否相同. 区分大小写
        boolean equalsIgnoreCase(String str): 比较字符串内容是否相同. 不区分大小写

注意事项：
    1. 任何对象都能用Object类型进行接收
    2. equals()方法具有对称性, 也就是a.equals(b)和b.equals(a)效果一样
    3. 如果比较双方一个常量一个变量, 推荐把常量字符串写在前面: "abc".equals(str). 可以避免空指针异常的可能

[Java] 纯文本查看 复制代码

// 说出以下结果
String s = "ABC";
boolean result1 = "abc".equals(s);            
System.out.println(result1);                  // 结果是 false

boolean result2 = "abc".equalsIgnoreCase(s);  
System.out.println(result2);                  // 结果是 true

字符串的获取相关方法
获取相关的方法:
        int length(): 获取字符串长度
        String concat(String str): 将当前字符串和参数字符串拼接, 返回值新的字符串
                效率高, 底层原理是利用System.arraycopy()来拼接byte[], 然后创建一个新的String对象
        char charAt(int index): 获取指定索引位置的单个字符 (索引从0开始)
        int indexOf(String str): 查找参数字符串在本字符串当中第一次出现的索引位置, 如果没有返回-1值

[Java] 纯文本查看 复制代码

// 说出以下结果
int length = "abc".length();
System.out.println(length);           // 长度是3

String result = "abc".concat("def");  
System.out.println(result);           // 结果为 abcdef

char ch = "abc".charAt(0);            
System.out.println(ch);               // 字符为 'a'

int index = "abc".indexOf("hello");   
System.out.println(index);            // 索引为 -1

字符串的截取方法
截取相关方法:
        String substring(int index): 截取从参数位置一直到字符串末尾, 返回新字符串
        String substring(int begin, int end): 截取从begin索引开始, 一直到end索引结束(不包含end), 中间的字符串

[Java] 纯文本查看 复制代码

// 说出结果
String result1 = "abc".substring(1);     // 结果为 "bc"
String result2 = "abc".substring(0, 3);  // 结果为 "abc"

字符串的转换相关方法
转换相关方法:
        char[] toCharArray(): 将当前字符串拆分成为字符数组作为返回值
        byte[] getBytes(): 获得当前字符串底层的字节数组
        String replace(CharSequence oldString, CharSequence newString): 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
                CharSequence是String的父类, 可以理解为能够传入String类型。

[Java] 纯文本查看 复制代码

// 说出结果
char[] chs = "abc".toCharArray();  // {'a', 'b', 'c'}
String result = "I like java, java is great!".replace("java", ""); // "I like ,  is great!"

字符串的分割方法
分割:
        public String[] split(String regex): 按照参数作为分割符, 将字符串切分成为字符串数组.
                参数是正则表达式的字符串, 常见的"\\+" "\\-" \\* \\. 都是正则表达式的特殊符号

[Java] 纯文本查看 复制代码

// 说出结果
String[] arr1 = "a,b,c".split(",");    // {"a", "b", "c"}
String[] arr2 = "a.b.c".split("\\.");  // {"a", "b", "c"}

练习：按指定格式拼接字符串5分钟练习:
需求:
定义一个方法, 把数组 {1, 2, 3} 按照指定格式拼接成一个 字符串
格式参照如下: [word1#word2#word3]   {张三丰@张无忌@张翠山}

分析:
        如何判断是最后一个元素: if (i == arr.length - 1) {}
        如何拼接字符串:
                方式1: +
                方式2: concat()
代码：

[Java] 纯文本查看 复制代码

/*
需求:
定义一个方法, 把数组 {1, 2, 3} 按照指定格式拼接成一个 字符串
格式参照如下: [word1#word2#word3]   {张三丰@张无忌@张翠山}
 */
public class Test {
    public static void main(String[] args) {
        // 定义数组
        int[] arr = {1, 2, 3};

        String result = arrayToString(arr);
        System.out.println(result);
    }

    // 将数组元素转换为指定格式的字符串
    public static String arrayToString(int[] arr) {
        // 先定义左括号字符串
        String result = "[";

        // 遍历数组
        /*for (int i = 0; i < arr.length; i++) {
            // 判断是否为最后一个元素
            if (i == arr.length - 1) {
                // 是最后一个, 拼接单词和右括号
                result += "word" + arr[i] + "]";
            } else {
                // 不是最后一个, 拼接单词和井号
                result += "word" + arr[i] + "#";
            }
        }*/

        // 使用concat()方法拼接
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            // 判断是否为最后一个元素
            if (i == arr.length - 1) {
                // 是最后一个, 拼接单词和右括号
                result = result.concat("word")
                            .concat(""+arr[i])
                            .concat("]");
            } else {
                // 不是最后一个, 拼接单词和井号
                result = result.concat("word")
                            .concat(""+arr[i])
                            .concat("#");
            }
        }
        
        // 返回字符串
        return result;
    }
}

练习：统计输入的字符串中各种字符的个数5分钟练习:
需求:
键盘输入一个字符串, 并且统计其中各种字符出现的次数
        大写字母
        小写字母
        数字
        其他

分析:
        如何获取字符串中的每个字符:
                char charAt(int index)
                char[] toCharArray()
        如何判断一个字符是大写字符: if (ch >= 'A' && ch <= 'Z')
        如何判断一个字符是小写字符: else if (ch >= 'a' && ch <= 'z')
        如何判断一个字符是数字字符: else if (ch >= '0' && ch <= '9')
        如何判断一个字符是其他字符: else {}
        如何计数: 定义4个计数器变量
代码：

[AppleScript] 纯文本查看 复制代码

/*
需求:
键盘输入一个字符串, 并且统计其中各种字符出现的次数
        大写字母
        小写字母
        数字
        其他
 */
public class Test {
    public static void main(String[] args) {
        // 键盘录入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String s = scanner.next();

        // 定义计数器
        int countLower = 0;
        int countUpper = 0;
        int countNumber = 0;
        int countOther = 0;

        // 将字符串转换为char[]
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            // 获取每个字符
            char ch = chars[i];
            // 判断字符的范围
            if (ch >= 'a' && ch <= 'z') {
                // 小写字母
                countLower++;
            } else if (ch >= 'A' && ch <= 'Z') {
                // 大写字母
                countUpper++;
            } else if (ch >= '0' && ch <= '9') {
                // 数字字符
                countNumber++;
            } else {
                // 其他
                countOther++;
            }
        }

        // 打印结果
        System.out.println("小写字符:" + countLower);
        System.out.println("大写字符:" + countUpper);
        System.out.println("数字字符:" + countNumber);
        System.out.println("其他字符:" + countOther);
    }
}

静态staticstatic关键字概述static: 静态修饰符. 可以修饰 成员变量, 成员方法
        被 static 修饰的成员, 只有一份属于类, 被该类所有对象共享
        可以用类名调用

static修饰成员变量
被static修饰的成员变量, 是属于类的. 是所有对象共享的同一个变量
        一个对象修改了静态成员变量, 另一个对象获取也是修改后的

可以对象名或类名直接调用, 但推荐使用类名调用:
        one.room = ""
    two.room
        类名.静态成员变量名
        Student.room
static修饰成员方法和访问规则
被static修饰的成员方法, 是属于类的. 可以对象名或类名直接调用, 推荐使用类名直接调用
        类名.静态方法名();

静态和非静态的相互访问规则:
        静态方法中, 只能访问静态成员, 不能访问非静态成员
        非静态方法中, 可以访问静态和非静态成员
        
        原因是:
                静态和非静态成员, 在内存中的生命周期不一样
                静态成员随着类的加载而创建, 非静态成员随着对象的创建而创建
        
静态成员中不能使用this, 因为静态方法是通过类调用的, 没有对象
补充：

[Java] 纯文本查看 复制代码

public class Student {
    // 静态方法
    public static void staticMethod() {
        System.out.println("静态方法");
    }
    
    // 非静态方法, 没有static
    public void nonStaticMethod() {
        System.out.println("非静态方法");
    }
}

public class Test {
    public static void main(String[] args) {
        // 调用静态方法: 类名.静态方法名
        Student.staticMethod();  // 静态方法
        
        // 调用非静态成员方法, 必须通过对象调用
        Student s1 = new Student();
        s1.nonStaticMethod();
    }
}

静态static的内存图
静态成员在内存中的位置:
        方法区中的静态区域中

静态代码块
静态代码块格式:

[Java] 纯文本查看 复制代码

// 静态代码块
    static {
        // 代码...
    }

        // 静态代码块要定义在类中
    public class 类名称 {
        // 静态代码块
        static {
            // 代码...
        }
    }

特点:
        加载类时, 静态代码块会执行唯一的一次
        静态代码块比构造方法先执行

静态代码块的应用场景：
        用来一次性地对静态成员变量进行赋值

补充：

[Java] 纯文本查看 复制代码

// 为静态成员变量赋值
public class Test {
    
    private static String username;  // 静态成员变量
    
    // 可以利用静态代码块为静态成员变量赋值
    static {
        username = "root";
    }
}

工具类数组工具类Arrays
java.util.Arrays: 数组相关的工具类, 里面提供了大量静态方法, 用来实现数组常见的操作
        常用静态方法
                static String toString(数组): 将参数数组变成字符串. 格式: [元素1, 元素2, 元素3...]
                static void sort(数组): 按照默认升序 (从小到大) 对数组的元素进行排序
补充：

[Java] 纯文本查看 复制代码

// 说出结果
int[] intArray = {10, 20, 30};
String intStr = Arrays.toString(intArray);
System.out.println(intStr);                  // [10, 20, 30]

// 数字排序
int[] array1 = {4, 2, 3};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1)); // [2,3,4]

// 字符串排序
String[] array2 = {"z", "a", "e"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); // ["a", "e", "z"]

Arrays练习：将字符串中的字符升序排列, 倒序打印5分钟练习:
需求: 请使用Arrays相关的API, 将一个随机字符串中的所有字符升序排列, 并倒序打印

分析:
        "asv76agfqwdfvasdfvjh" String -> char[] toCharArray()
        如何将字符串中的字符排序: Arrays.sort()  []
        如何倒序打印:
代码：

[Java] 纯文本查看 复制代码

import java.util.Arrays;

/*
需求: 请使用Arrays相关的API, 将一个随机字符串中的所有字符升序排列, 并倒序打印
 */
public class Test {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "df787d8f787dsfdsf";

        // 将字符串转换为char[]
        char[] chars = s.toCharArray();
        // 将数组排序
        Arrays.sort(chars);
        // 倒序遍历  数组名.forr
        for (int i = chars.length - 1; i >= 0; i--) {
            // 获取元素并打印
            System.out.println(chars[i]);
        }
    }
}

数学工具类Math
java.util.Math: 是数学相关的工具类, 里面提供了大量的静态方法, 完成与数学运算相关的操作
        常用静态成员变量
                static double PI: π代表近似的圆周率常量
        常用静态方法
                static double abs(double num): 获取绝对值. 有多种重载
                static double ceil(double num): 向上取整
                static double floor(double num): 向下取整
                static long round(double num): 四舍五入
Math练习：小学数学真题5分钟练习:
需求: 计算在-10.8到5.9之间, 绝对值大于6或者小于2.1的整数有多少个?

分析:
        获取-10.8到5.9之间的所有整数:
        将每个整数计算出绝对值:
        判断绝对值是否大于6或者小于2.1:
        计数:
代码：

[Java] 纯文本查看 复制代码

/*
需求: 计算在-10.8到5.9之间, 绝对值大于6或者小于2.1的整数有多少个?
 */
public class Test {
    public static void main(String[] args) {
        // 定义变量
        double min = -10.8;
        double max = 5.9;

        // 定义计数器变量
        int count = 0;

        // 方式1: 强转. for循环产生指定范围的整数
        /*for (int i = (int) min; i < max; i++) {
            // 将数值获取绝对值
            int abs = Math.abs(i);
            // 判断是否在区间内
            if (abs > 6 || abs < 2.1) {
                count++;
                System.out.println(i);
            }
        }*/


        // 方式2: ceil. for循环产生指定范围的整数
        for (double i = Math.ceil(min); i < max; i++) {
            // 将数值获取绝对值
            double abs = Math.abs(i);
            // 判断是否在区间内
            if (abs > 6 || abs < 2.1) {
                count++;
                System.out.println(i);
            }
        }

        // 输出结果
        System.out.println("符合要求的有" + count + "个");
    }
}

API总结
java.lang.String: 代表字符串, 包含了字符串的常用操作方法
        构造方法
                String(): 创建一个空白字符串, 不含有任何内容
                String(char[] array): 根据字符数组的内容, 来创建对应的字符串
                String(byte[] array): 根据字节数组的内容, 来创建对应的字符串
        比较相关的方法
                boolean equals(Object obj): 比较字符串内容是否相同. 区分大小写
                boolean equalsIgnoreCase(String str): 比较字符串内容是否相同. 不区分大小写
        获取相关的方法:
                int length(): 获取字符串长度
                String concat(String str): 将当前字符串和参数字符串拼接, 返回值新的字符串
                char charAt(int index): 获取指定索引位置的单个字符 (索引从0开始)
                int indexOf(String str): 查找参数字符串在本字符串当中第一次出现的索引位置, 没有返回-1
        截取相关方法:
                String substring(int index): 截取从参数位置一直到字符串末尾, 返回新字符串
                String substring(int begin, int end): 截取从begin索引开始, 一直到end索引结束(不包含end), 中间的字符串
        转换相关方法:
                char[] toCharArray(): 将当前字符串拆分成为字符数组作为返回值
                byte[] getBytes(): 获得当前字符串底层的字节数组
                String replace(CharSequence oldString, CharSequence newString): 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
                        CharSequence是String的父类, 可以理解为能够传入String类型。
     分割:
                public String[] split(String regex): 按照参数作为分割符, 将字符串切分成为字符串数组.
               
java.util.Arrays: 数组相关的工具类, 里面提供了大量静态方法, 用来实现数组常见的操作
        常用静态方法
                static String toString(数组): 将参数数组变成字符串. 格式: [元素1, 元素2, 元素3...]
                static void sort(数组): 按照默认升序 (从小到大) 对数组的元素进行排序
               
java.util.Math: 是数学相关的工具类, 里面提供了大量的静态方法, 完成与数学运算相关的操作
        常用静态成员变量
                static double PI: π代表近似的圆周率常量
        常用静态方法
                static double abs(double num): 获取绝对值. 有多种重载
                static double ceil(double num): 向上取整
                static double floor(double num): 向下取整
                static long round(double num): 四舍五入

先收藏了,晚上看

已收藏，感谢

谢谢谢美女!

感谢分享