基础03String类、static、Arrays类、Math类

String类

java.lang.String类代表字符串。
API当中说：Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

特点

1、字符串内容永不改变。【重点】
2、字符串不可改变，所以字符串是可以共享的。
3、字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。
三种构造方法：

public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = “Hello”; // 右边直接用双引号

注意：直接写上双引号，就是字符串对象。

    public static void main(String[] args) {
        // 使用空参构造
        String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
        System.out.println("第1个字符串：" + str1);

        // 根据字符数组创建字符串
        char[] charArray = { 'A', 'B', 'C' };
        String str2 = new String(charArray);
        System.out.println("第2个字符串：" + str2);

        // 根据字节数组创建字符串
        byte[] byteArray = { 97, 98, 99 };
        String str3 = new String(byteArray);
        System.out.println("第3个字符串：" + str3);

        // 直接创建
        String str4 = "Hello";
        System.out.println("第4个字符串：" + str4);
    }

第1个字符串：
第2个字符串：ABC
第3个字符串：abc
第4个字符串：Hello

字符串常量池

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，== 是进行数值的比较。
对于引用类型来说，== 是进行【地址值】的比较。

public static void main(String[] args) {
    String str1 = "abc";
    String str2 = "abc";

    char[] charArray = {'a', 'b', 'c'};
    String str3 = new String(charArray);

    System.out.println(str1 == str2); // true
    System.out.println(str1 == str3); // false
    System.out.println(str2 == str3); // false
}

解释：
堆中有字符串常量池，代码时直接创建的字符串，是在常量池中，（str1是直接双引号写出的字符串所以保存在常量池中。）代码中abc底层用byte字节数组来表示，（参考ASCII，对应97.98.99）也就是字节数组的地址保存在常量池中的字符串对象中，

但是字符串对象也要有地址（0x666），str1保存了对象地址，创建str2，就把池子中的对象再用一遍，也就是str1和str2都保存了该字符串对象

然后创建了char型数组charArray，保存在堆中，后面紧接创建str3对象，（new出来的str3不在常量池）把char类型数组放了进来，
过程是：把原本char类型数组，转换成byte类型数组并且创建字符串对象保存了byte数组的地址，然后把字符串对象地址交给了str3。

String类的功能方法

判断，比较：
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。

注意事项：

1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
   推荐：“abc”.equals(str) 不推荐：str.equals(“abc”)

public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

 public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2)); // true
        System.out.println(str2.equals(str3)); // true
        System.out.println(str3.equals("Hello")); // true
        System.out.println("Hello".equals(str1)); // true

        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false
        System.out.println("=================");

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐：false
//        System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException
        System.out.println("=================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写

        // 注意，只有英文字母区分大小写，其他都不区分大小写
        System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false
    }

String当中与获取相关的常用方法有：

public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

public static void main(String[] args) {
    // 获取字符串的长度
    int length = "hahahah".length();
    System.out.println("字符串的长度是：" + length);

    // 拼接字符串
    String str1 = "Hello";
    String str2 = "World";
    String str3 = str1.concat(str2);//和sql类似
    System.out.println(str1); // Hello，原封不动
    System.out.println(str2); // World，原封不动
    System.out.println(str3); // HelloWorld，新的字符串
    System.out.println("==============");

    // 获取指定索引位置的单个字符
    char ch = "你好啊".charAt(1);
    System.out.println("在1号索引位置的字符是：" + ch);
    System.out.println("==============");//好

    // 查找参数字符串在本来字符串当中出现的第一次索引位置
    // 如果根本没有，返回-1值
    String original = "nihaoaxixi";
    int index = original.indexOf("xi");
    System.out.println("第一次索引值是：" + index); // 6

    System.out.println("HelloWorld".indexOf("abc")); // -1
}

字符串的截取方法

public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
备注：[begin,end)，包含左边，不包含右边。

public static void main(String[] args) {
    String str1 = "HelloWorld";
    String str2 = str1.substring(5);
    //z只读取world，一定要搞清楚w是几号元素
    // 用键盘和光标光标处于H左边，敲几下键盘右键就是几号
    System.out.println(str1); // HelloWorld，原本字符串不变,一定要清楚
    // 字符串创建了就不会发生改变,每当变化了就是创建了新的字符串
    System.out.println(str2); // World，新字符串
    System.out.println("================");

    String str3 = str1.substring(4,7);
    System.out.println(str3); // oWo
    System.out.println("================");

    // 下面这种写法，字符串的内容仍然是没有改变的
    // 下面有两个字符串："Hello"，"Java"
    // strA当中保存的是地址值。
    // 本来地址值是Hello的0x666，
    // 后来地址值变成了Java的0x999
    String strA = "Hello";
    System.out.println(strA); // Hello
    strA = "Java";//此时strA所管理的东西发生了改变
    System.out.println(strA); // Java
}

String当中与转换相关的常用方法

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组 。
public String replace(CharSequence oldString, CharSequence newString)：
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。

public static void main(String[] args) {
    // 转换成为字符数组
    char[] chars = "Hello".toCharArray();
    System.out.println(chars[0]); // H
    System.out.println(chars.length); // 5
    System.out.println("==============");

    // 转换成为字节数组
    byte[] bytes = "abc".getBytes();
    for (int i = 0; i < bytes.length; i++) {
        System.out.println(bytes[i]);//97 98 99
    }
    System.out.println("==============");

    // 字符串的内容替换
    String str1 = "How do you do?";
    String str2 = str1.replace("o","*");
    System.out.println(str1); // How do you do?
    System.out.println(str2); // H*w d* y*u d*?
    System.out.println("==============");

    String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！";
    String lang2 = lang1.replace("你大爷的", "****");
    System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！
}

字符串分割

一定注意和字符串的截取不一样。
分割字符串的方法：
public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注意事项：

split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意：如果按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）

public static void main(String[] args) {
    String str1 = "aaa,bbb,ccc";
    String[] array1 = str1.split(",");
    for (int i = 0; i < array1.length; i++) {
        System.out.println(array1[i]);
    }//aaa bbb ccc

    String str2 = "aaa bbb ccc";
    String[] array2 = str2.split(" ");
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i]);
    }//aaa bbb ccc
    System.out.println("===============");

    String str3 = "XXX.YYY.ZZZ";
    String[] array3 = str3.split("\\.");//注意加\\反斜杠
    System.out.println(array3.length); //3
    for (int i = 0; i < array3.length; i++) {
        System.out.println(array3[i]);
    }
}

static关键字

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

/*
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()

注意事项：
1. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
静态和对象没关系。
 */
 public class Demo02StaticMethod {

    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); // 正确，推荐

        // 对于本来当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }

}

public class MyClass {

    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量z
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态【重点】
//        System.out.println(num); // 错误写法！

        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }

}

方法区有一块独特的静态区，堆中创建了one，two 对象实体，其中有成员变量，
地址分别放到栈中。栈中根据类名称访问静态成员变量时候，全程和对象没关系，
只和类有关系。

静态代码块：
/*
静态代码块的格式是：

public class 类名称 {
   
     static {
        // 静态代码块的内容
    }
}

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
 */
public class Demo04Static {

    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }

}
/*
静态代码块执行！
构造方法执行！
构造方法执行！
*/


public class Person {

    static {
        System.out.println("静态代码块执行！");
    }

    public Person() {
        System.out.println("构造方法执行！");
    }

}

Arrays类

操作数组的各种方法，其所有方法都是静态方法。也就是说不需要new对象就可以进行调用

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
 */
public class Demo01Arrays {

    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb","ccc","aaa"};//sort默认按照字母升序
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
 */
public class Demo01Arrays {

    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb","ccc","aaa"};//sort默认按照字母升序
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));

         // [aaa, bbb, ccc]
    }

}
         // [aaa, bbb, ccc]
    }

}

练习：

import java.util.Arrays;

/*
题目：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
 */
public class Demo02ArraysPractise {

    public static void main(String[] args) {

        String str = "sd1a5ndqwiodjwpojdqwwq659w5";

        //升序sort
        //必须是数组才能用Arrays.sort方法
        //String -->数组，用tocharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        //倒序打印
        for(int i = chars.length - 1; i >= 0 ; i--){//for循环可千万别越界，别忘了长度减1
            System.out.println(chars[i]);
        }


    }

}

Math类

基本数学运算方法，方法均为静态方法，并且不创建对象，直接调用
绝对值：abs Math.abs()
向上取整：ceil
向下取整：floor
四舍五入：round

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs(double num)：获取绝对值。有多种重载。
public static double ceil(double num)：向上取整。
public static double floor(double num)：向下取整。
public static long round(double num)：四舍五入。
Math.PI代表近似的圆周率常量（double）。

public class Demo03Math {

    public static void main(String[] args) {
        // 获取绝对值 abs
        System.out.println(Math.abs(3.14)); // 3.14
        System.out.println(Math.abs(0)); // 0
        System.out.println(Math.abs(-2.5)); // 2.5
        System.out.println("================");

        // 向上取整 ceil
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(3.0)); // 3.0
        System.out.println("================");

        // 向下取整，抹零 floor
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(31.0)); // 31.0
        System.out.println("================");
        //四舍五入 round 
        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); // 11
    }

}

/*
题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

分析：
1. 既然已经确定了范围，for循环
2. 起点位置-10.8应该转换成为-10，两种办法：
    2.1 可以使用Math.ceil方法，向上（向正方向）取整
    2.2 强转成为int，自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
4. 如何拿到绝对值：Math.abs方法。
5. 一旦发现了一个数字，需要让计数器++进行统计。

备注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。
 */
public class Demo04MathPractise {

    public static void main(String[] args) {
        //-10.8-->5.9
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        for (int i = (int)(min); i < max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1) {
                count++;

            }
        }
        System.out.println("满足要求的个数：" + count);
    }
}