java之String类、static关键字、Arrays数组工具类（包含了操作数组的各种静态方法）、Math类

目录

String类

特点

创建字符串的3+1种方式

字符串共享（常量池）

​

字符串的内容的比较方法

字符串的获取相关方法

字符串的截取方法

字符串的转换相关方法

字符串的分割方法

静态static关键字

类变量（静态变量）

类方法（静态方法）

调用格式

静态static的内存图

​静态代码块

Arrays数组工具类（包含了操作数组的各种静态方法）

Math数学工具类

基本运算的方法（绝对值，取整的3种方式）

---

 

String类

概述：java.lang.String 类代表字符串（此类不需要导入）。Java程序中所有的字符串文字（例如"abc" ）都可以被看作是实现此类的实例。

特点

1.字符串的内容永不可变，是一个常量。【重点】

2.正是字符串的永不可变性，所以字符串是可以共享使用的。

3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的3+1种方式

三种构造方法：

1. public String（）：创建一个空白字符串，不含有任何内容。
2. public String（char[] array）：根据字符数组的内容，来创建对应的字符串。
3. public String（byte[]  array）：根据字节数组的内容，来创建对应的字符串。String

一种直接创建：

       String str = “Hello World”；

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

package demo5;

public class DemoString {
    public static void main(String[] args) {
        // 使用空参构造
        String str1 = new String(); // 字符串留空，说明字符串什么内容都没有
        System.out.println("第一个字符串："+str1);
        // 根据字符数组来创建字符串
        char[] chararray = {'a','b','c'};
        String str2 = new String(chararray);
        System.out.println("第二个字符串："+str2);
        // 根据字节数组创建字符串
        byte[] bytearray = {97,98,99};
        String str3 = new String(bytearray);
        System.out.println("第三个字符串："+str3);

        // 直接创建
        String str = "hello";
        System.out.println("直接创建的字符串："+str);
    }
}

字符串共享（常量池）

package demo5;

public class StringPool {
    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
    }
}

字符串常量池：程序中直接写上的双引号字符串，就在字符串常量池中。而new出来的不在常量池中，而是新建出的地址。

对于基本类型来说，==是进行数值的比较。

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

字符串的内容的比较方法

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

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

注意事项：

1. 任何对象都能用Object接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，经验推荐把常量字符串写在前面。推荐'abc'.equals(str)，不推荐str.equals('abc')。因为如果变量写在前面，当该变量是null值时，null是没有方法的即null.equals('abc')会报错，而不是理想中的false。

（2）public boolean equalsIgnoreCase（String str）：参数就是一个字符串，忽略大小写，进行内容的比较。

注意：只有英文字母区分大小写，这个大小写可以忽略；但是其他都不区分大小写，也就是说不一样。比如下面的中文例子，一和壹是不一样的。和大小写无关。

package demo5;

public class StringPool {
    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
        // equals方法比较的是内容
        System.out.println(str1.equals(str2)); // true
        System.out.println(str1.equals(str3)); // true
        System.out.println(str2.equals(str3)); // true
        System.out.println(str3.equals("abc")); // true
        System.out.println("abc".equals(str1)); // true
        // 大小写区分和忽略
        String strA = "Java";
        String stra = "java";
        System.out.println(strA.equals(stra)); // false,严格区分大小写
        System.out.println(strA.equalsIgnoreCase(stra)); // true，忽略大小写
        // 注意，只有英文区分大小写，其他都不区分大小写
        System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false，汉字一和壹不能忽略大小写
    }
}

字符串的获取相关方法

（1）public int length（）：获取字符串当中含有的字符个数，拿到字符串的长度。

（2）public String concat（String str）：将当前字符串和参数字符串拼接成新的字符串。

（3）public char charAt（int index）：获取指定索引位置的单个字符。

（4）public int indexOf（String str）：查找参数字符串在本字符串当中首次出现的索引位置，如果没有找到则返回-1.

package demo5;

public class StringGet {
    public static void main(String[] args) {
        // 获取字符串长度
        int length = "abcdefghijk字母表".length();
        System.out.println("字符串长度是："+length);
        // 拼接字符串
        String str1 = "我是某某";
        String str2 = "我喜欢某某";
        String str = str1.concat(str2);
        System.out.println(str1); // 我是某某，字符串不会改变
        System.out.println(str); // 我是某某我喜欢某某
        // 获取指定索引位置的单个字符
        char ch = "我的身份很厉害".charAt(0);
        System.out.println("第0个字符是："+ch); // 我
        // 直接查找字符串出现的首个位置
        int index = "北京天安门好雄伟壮阔，我爱北京天安门".indexOf("天安门");
        System.out.println("字符串中‘天安门’第一次出现在："+index); // 2
        int outindex = "北京天安门好雄伟壮阔，我爱北京天安门".indexOf("我喜欢天安门");
        System.out.println("字符串中‘我喜欢天安门’第一次出现在："+outindex); // -1， 不存在该字符串所以返回-1
    }
}

字符串的截取方法

（1）public String substring（int index）：截取从参数位置一直到字符串末尾，返回新的字符串。

（2）public String substring（int begin，int end）：截取从begin开始一直到end结束，中间的字符串。

备注：[begin，end)截取的是一个左闭右开的区间。

字符串的变量保存的是地址值，字符串的内容不会出现变化，变化的是地址值。

package demo5;

public class Substring {
    public static void main(String[] args) {
        String ch = "我爱北京天安门，天安门上太阳升，伟大领袖毛主席，天安门上高高挂!";
        String str1 = ch.substring(8);
        String str2 = ch.substring(8,15);
        System.out.println(ch); // 我爱北京天安门，天安门上太阳升，伟大领袖毛主席，天安门上高高挂!
        System.out.println(str1); // 天安门上太阳升，伟大领袖毛主席，天安门上高高挂!
        System.out.println(str2); // 天安门上太阳升
        // ch保存的是地址值，本来地址是天安门的0x666；后来地址值变成了颐和园的0x999
        ch = "颐和园好美!";
        System.out.println(ch); // 颐和园好美!
    }
}

字符串的转换相关方法

（1）public char[] toCharArray()：将当前字符串拆分成字符数组，并作为返回。

（2）public byte[] getBytes()：获得当前字符串底层的字节数组。

（3）public String replace（CharSequence oldString，CharSequence newString）：将出现的老字符串替换成新的字符串，返回替换之后的结果新字符串。

备注：CharSequence意思就是说可以接受字符串类型。

package demo5;

public class StringConvert {
    public static void main(String[] args) {
        // 转换成字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        // 转换成字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        // 替换
        String str1 = "how old are you?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // how old are you?
        System.out.println(str2); // h*w *ld are y*u?
    }
}

字符串的分割方法

public String[] split（String regex）：按照参数的规则，将字符串恩城若干部分。

注意：split方法的参数regex实际上是一个正则表达式。要注意正则表达式中特殊的功能符号。如果要按照英文句点“.”进行切分，必须进行转义，即写“\\.”（两个反斜杠）。

package demo5;

public class StringSplit {
    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]);
        }
        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        // 注意不能直接使用"."切割，因为在正则表达式中是一个特殊的功能字符
        System.out.println("==========================");
        String str3 = "aaa.bbb.ccc";
        String[] array3 = str3.split(".");
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
        System.out.println(array3.length); // 0
        // 必修使用对应的转义字符"\\."
        System.out.println("==========================");
        String[] array4 = str3.split("\\.");
        for (int i = 0; i < array4.length; i++) {
            System.out.println(array4[i]);
        }
        System.out.println(array4.length); // 3
    }
}

练习：

package demo5;
import java.util.Scanner;
/*
1.拼接字符串。定义一个方法，把数组{1，2，3}按照一定的格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。
2.键盘输入字符串，并且统计其中各种字符串出现的次数。种类有:大写字母、小写字母、数字、其他。
 */
public class Practice {
    public static void main(String[] args) {
        int[] list1 = {1,2,3};
        String str1 = fromArrayToString(list1);
        System.out.println(str1);
        // 练习题2
        Scanner sc = new Scanner(System.in);
        String input = sc.next();
        int countUpper = 0; // 大写字母类别
        int countLower = 0; // 小写字母类别
        int countNumber = 0; // 数字类别
        int countOther = 0; // 其他类别
        char[] chars = input.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            if ('A'<=ch && ch<='Z'){
                countUpper++;
            }else if('a'<=ch && ch<='z'){
                countLower++;
            }else if ('0'<=ch && ch<='9'){
                countNumber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母的数量："+countUpper);
        System.out.println("小写字母的数量："+countLower);
        System.out.println("数字的数量："+countNumber);
        System.out.println("其他种类字符的数量："+countOther);
    }
    public static String fromArrayToString(int[] list){
        String str = "[";
        for (int i = 0; i < list.length; i++) {
            if (i==list.length-1){
                str += "word"+list[i]+"]";
            }else{
                str += "word"+list[i]+"#";
            }
        }
        return str;
    }
}

静态static关键字

概述：关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

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

类变量（静态变量）

当 static 修饰成员变量时，该变量称为类变量，不再属于对象自己，而是属于所在的类。该类的每个对象都共享同一个类变量的值（多个对象共享一份数据）。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

类变量：使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名；
// 举例：static int numberID；

 具体举例如下：先定义一个Student类/数据

// Student.java
package demo6;
public class Student {
    private String name; // 成员变量
    private int age; // 成员变量
    private int id; // 成员变量
    private static int idCounter=0; // 静态变量。学号计数器，每当new了一个新的对象时，计数器加一
    static String room; // 静态变量。教室

    public Student() {
        idCounter++; // 构造函数也属于成员函数，成员函数使用静态变量
    }

    public Student(String name, int age) {
        this.name = name;  //成员函数使用成员变量
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


// StaticField.java
package demo6;
public class StaticField {
    public static void main(String[] args) {
        Student one = new Student("杨过",18);
        Student two = new Student("小龙女",20);
        one.room = "101教室"; // 静态变量是属于类变量，所以一个改了全都改了。推荐使用类来调用即Student.room = "101教室"
        // 成员变量id的值是由静态变量idCounter得到的，每新建一个对象就会自加1并且赋值给每个对象的id.
        System.out.println("姓名："+one.getName()+",年龄："+one.getAge()+",所在教室："+one.room+",学号："+one.getId()); // 姓名：杨过,年龄：18,所在教室：101教室,学号：1
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge()+",所在教室："+two.room+",学号："+two.getId()); // 姓名：小龙女,年龄：20,所在教室：101教室,学号：2
    }
}

类方法（静态方法）

当static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

如果没有static关键字，也就是普通方法/成员函数/成员方法，那么必须首先创建对象，然后通过对象才能使用它。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){
    // 执行语句
}

/*
举例：在Student类中定义静态方法
public static void showNum() {
   System.out.println("num:" + numberOfStudent);
}
*/

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；

注意：

1.静态只能直接访问静态，不能直接访问非静态。

原因：因为在内存中式【先】有静态内容，【后】有非静态内容。“先人不知后人，但是后人知道先人。” 

2.静态方法总是优先于非静态。

3.静态方法中不能使用this关键字。

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。静态和对象没有关系！

// MyClaass.java
package demo6;
public class MyClass {
    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method(){
        System.out.println("这是一个普通的成员方法");
        // 成员方法可以调用成员变量
        System.out.println(num);
        // 成员方法可以调用静态变量
        System.out.println(numStatic);
    }
    // 静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法。");
        // 静态方法可以调用静态变量
        System.out.println(numStatic);
        // 静态方法不能调用非静态变量【重点】
//        System.out.println(num); // 错误写法

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

// StaticAttention.java
package demo6;
public class StaticAttention {
    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能没有static关键字的成员方法
        obj.method();
        // 对于静态方法，可以通过对象名进行调用，也可以通过类名称进行调用。
        obj.methodStatic(); // 正确，不推荐
        MyClass.methodStatic(); // 正确，推荐
        // 对于本来当中的静态方法，可以省略类名称
        myMethod(); // 和下面等效
        StaticAttention.myMethod();
    }
    // 定义静态方法
    public static void myMethod(){
        System.out.println("自己类中的静态方法");
    }
}

静态static的内存图

静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
格式：

public class ClassName{
  static {
      // 执行语句
   }
}

执行：静态代码随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

 原因：静态方法总是优先于非静态，所以静态代码块比构造方法先执行。

作用：给类变量进行初始化赋值。

// 1.给变量进行初始化赋值
package demo6;
import java.util.ArrayList;

public class Block {
    public static int number;
    public static ArrayList<String> list;

    static {
        // 给类变量赋值
        number = 2;
        list = new ArrayList<String>();
        // 添加元素到集合中
        list.add("张三");
        list.add("李四");
    }
}

// 2.静态方法总是优于构造方法
// Person.java
package demo6;
public class Person {
    static{
        System.out.println("静态代码块执行！");
    }
    public Person() {
        System.out.println("构造方法执行！");
    }
}
// StaticBlock
package demo6;
public class StaticBlock {
    public static void main(String[] args) {
        Person one = new Person(); //  静态代码块执行！ 构造方法执行！
        Person two = new Person(); // 构造方法执行！
    }
}

Arrays数组工具类（包含了操作数组的各种静态方法）

概述：java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。所有方法均为静态方法（建议使用类调用），调用起来非常简单。

其中<T>表示泛型对象类型，array是泛型T的数组。泛型可以为对象，也可为基本类型；所以数组可以是基本类型数组，也可以是对象类型数组。

（1）public static <T> String toString（array<T> array）：将参数array数组变成字符串（按照默认格式：[元素1，元素2，元素3,...]）

（2）public static <T> void sort（array<T> array）：按照默认升序（从小到大）对array数组元素进行排序。

（3）public static <T> void sort（array<T> array，int  fromIndex，int  toIndex）：按照默认升序（从小到大）对指定范围的array数组元素进行排序。

（4）public static <T> void sort（array[T] array，Comparator<? super T>)：按照指定规则对数组元素进行排序。

备注：sort方法

1.如果是数值，sort默认按照升序，从小到大。

2.如果是字符串，sort按照字母升序（也就是byte值，ASCII值进行排序）

3.如果是自定义的类型，那么这个自定义的类需要有Comparable 或者Comparator接口的支持。

public static void main(String[]args){
// 定义int 数组
        int[]arr={2,34,35,4,657,8,69,9};
// 打印数组,输出地址值
        System.out.println(arr); // [I@2ac1fdc4
// 数组内容转为字符串
        String s=Arrays.toString(arr);
// 打印字符串,输出内容
        System.out.println("排序前："+s); // 排序前：[2, 34, 35, 4, 657, 8, 69, 9]
// 升序排序
        System.out.println("排序后："+s); // 排序后：[2, 4, 8, 9, 34, 35, 69, 657]
}

对于上面第三点下面做一个详细的解释（和Collections集合工具类是一样的处理）

1. 使用sort方法（上面方法的2和3）直接进行对数组排序：被排序的array数组里面存储的元素，必须实现Comparable接口，并重写接口中的compareTo方法定义排序的规则。

排序规则：通常规定，对于两个元素x和y，原来的顺序是x在前y在后。如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。

• 返回1，表示前后两个相邻元素要换位置，-1和0不换。比如:如果x = 10 ,y = 5 x > y return 1。当x>y的时候要交换位置，那么就是升序排序。

• 如果x = 10,y = 20 y > x return 1.表示当y>x的时候要交换位置,那么表示降序排序。

this.age永远是当前的元素，o.age是下一个元素。当为正的时候，即return 1.需要交换顺序。其余情况则不需要交换顺序。

通过上面的规则：

当 this.age>o.age时，年龄按升序排序。 所以当return this.age-o.age时，年龄升序排序。
当 this.age<o.age时，年龄按降序排序 。 所以当return o.age-this.age时，年龄降序排序。

2. 使用按指定规则的sort方法（上面方法的4）进行对数组按照指定规则排序，需要新建一个Comparator对象，并重写里面的compare方法，方法参数o1在前o2在后。

Comparator和Comparable的区别，也就是sort的方法三和方法四的区别：

Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较规则compareTo方法。

Comparator：相当于找一个第三方的裁判，比较两个，里面的参数原来的顺序是o1在前o2在后。

上述两种方式的代码：

// 定义一个Person类，其中重写了toString方法，实现Comparable接口并重写compareTo方法
public class Person implements Comparable<Person> {
    private String name;
    private int age;
    private int nice;  // 美貌值 0-10
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", nice=" + nice +
                '}';
    }
    public Person() {
    }
    public Person(String name, int age, int nice) {
        this.name = name;
        this.age = age;
        this.nice = nice;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getNice() {
        return nice;
    }
    public void setNice(int nice) {
        this.nice = nice;
    }
    @Override  // 如果没有重写该方法就不能对Person排序。
    public int compareTo(Person o) {
//        return 0; //原来的代码恒返回0，表示不需要交换未知也就是不进行排序返回原序列。
        if (this.age > o.age) {  // 只对年龄进行了排序
            return 1;  // 返回正序。原来的顺序：this.age是当前元素，o.age是下一个元素。return 1需要交换位置。
        }
        if (this.age < o.age) {
            return -1;
        }
        return 0;
        // 等效于下面这句
//        return this.age-o.age;  // this.age永远是当前的元素，o.age是下一个元素。当为正的时候，即return 1.需要交换顺序。其余情况则不需要交换顺序。
        /* 当 this.age>o.age时，年龄按升序排序。
           所以return this.age-o.age时，年龄升序排序。
           当 this.age<o.age时，年龄按降序排序
           所以当return o.age-this.age时，年龄降序排序。
        */
    }
}

// Arrays数组工具类的使用
import java.util.Arrays;
import java.util.Comparator;
import java.util;
import java.util;
public class ArraySortTest {
    public static void main(String[] args) {
        // array数组中的元素是基本数据类型
        Integer[] array = {10,23,11,5}; // 使用泛型类型的原因在于使用第三方规则的时候要保持一致
        System.out.println("原来的顺序："+array); // 原来的顺序：[Ljava.lang.Integer;@1b6d3586 (直接打印的是地址值，即使Person类已经重写了toString方法)
        System.out.println("原来的顺序："+Arrays.toString(array)); // 原来的顺序：[10, 23, 11, 5]
        Arrays.sort(array);  // 默认规则排序，从小到大。使用这种默认的方式可以使用基本数据类型数组，不需要使用泛型。
        System.out.println("升序顺序:"+Arrays.toString(array)); // 升序顺序: [5, 10, 11, 23]
        // 使用第三方规则,必须是数组对象，如果是基本数据类型那么对象时对应的泛型。
        Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1; // 第三方规则，从大到小
            }
        });
        System.out.println("降序顺序:"+Arrays.toString(array)); // 降序排序：[23, 11, 10, 5]
 
        // array数组中的元素是自定义类型/对象
        Person[] persons = {new Person("赵丽颖",20,7),new Person("迪丽热巴",18,9),new Person("古力娜扎",19,8)};
        // 被排序的array数组里面存储的元素，必须实现Comparable接口，重写接口中的compareTo方法定义排序的规则。
        Arrays.sort(persons); // 进行排序，排序规则已经重写，只对年龄排序，是升序排序。
        System.out.println("只对年龄升序排序："+Arrays.toString(persons)); // 只对年龄升序排序：[Person{name='迪丽热巴', age=18, nice=9}, Person{name='古力娜扎', age=19, nice=8}, Person{name='赵丽颖', age=20, nice=7}]
        System.out.println("只对年龄升序排序："+persons); // 只对年龄升序排序：[Ldemo20.Person;@4554617c  (打印的是地址值)
        // 还可以使用第三方的，不需要去继承Comparable类和重写compareTo方法
        Arrays.sort(persons, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getNice()-o2.getNice();// 美貌值从小到大排序
            }
        });
        System.out.println("只对美貌值升序排序："+Arrays.toString(persons)); // 只对美貌值升序排序：[Person{name='赵丽颖', age=20, nice=7}, Person{name='古力娜扎', age=19, nice=8}, Person{name='迪丽热巴', age=18, nice=9}]
    }
}

Math数学工具类

概述：java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

基本运算的方法（绝对值，取整的3种方式）

（1）public static double abs(double a) ：返回 double 值的绝对值。有多种重载。

（2）public static double ceil(double a) ：返回大于等于参数的最小的整数。

（3）public static double floor(double a) ：返回小于等于参数最大的整数。

（4）public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)，只有该方法返回的是long型

（5）Math.PI代表近似的圆周率常量（double）。

package demo6;

public class MathLearn {
    public static void main(String[] args) {
        // 获取绝对值
        System.out.println("获取绝对值");
        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("向上取整");
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(-3.1)); // -3.0
        System.out.println(Math.ceil(-3.9)); // -3.0
        // 向下取整
        System.out.println("向下取整");
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(-30.9)); // -31.0
        System.out.println(Math.floor(-30.1)); // -31.0
        // 四舍五入
        System.out.println("四舍五入");
        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); //11
        System.out.println(Math.round(-10.5)); // -10
        System.out.println(Math.round(-20.4)); // -20
    }
}

练习：

// 请使用Math 相关的API，计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？
public class MathTest {
    public static void main(String[] args) {
        // 定义最小值
        double min = -10.8;
        // 定义最大值
        double max = 5.9;
        // 定义变量计数
        int count = 0;
        // 范围内循环
        for (int i = (int)Math.ceil(min); i <= max; i++) {
        // 获取绝对值并判断
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                // 计数
                count++;
            }
        }
        System.out.println("个数为: " + count + " 个");
    }
}

// int可以自增操作++,double型也可以进行++,所以可以将上面的for循环中的条件稍微改一下，其他不变。
for (double i = Math.ceil(min); i <= max; i++) {
        // 这里的i设置为double类型，那么就不需要强制转换类型，因为ceil得到的就是double类型。
        }