Arrays 数组工具类

概述

java.util.Arrays是一个与数组相关的工具类，用来实现数组常见的操作，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

操作数组的方法

• 返回指定数组内容的字符串表示形式。

public static String tostring(数组);

• 按照默认升序（从小到大）对数组的元素进行排序。

public static void sort(数组)

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

2. 如果是字符串，sort默认按照字母升序

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

代码：

import java.util.Arrays;

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, 5, 6, 4, 3};
        int[] arrayA = {2,5,6,4,3};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));  // [2,3,4,5,6]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));  // [aaa, bbb, ccc]

        String[] array3 = {"beb", "abc", "cca"};
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));
    }
}

结果：

[10, 20, 30]
[2, 3, 4, 5, 6]
[aaa, bbb, ccc]
[abc, beb, cca]

案例：倒序打印

使用Arrays相关的API，将一个随机字符串生序排列，并倒序打印

package cn.luis.demo4;

import java.util.Arrays;

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

    public static void main(String[] args) {
        String str = "asag24dfdh";

        // 必须是一个数组，才能使用Arrays.sort方法
        // String -->数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        System.out.print(chars);
        System.out.println("\n=================");

        // 需要倒序遍历
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.print(chars[i]);
        }

    }
}

结果：

24aaddfghs
=================
shgfddaa42

3.1 Math类

概述

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

基本运算的方法

• public static double abs(double num): 获取绝对值，有多种重载。

double d1 = Math.abs(-5); // 5
double d2 = Math.abs(5); // 5

• public static double ceil(double num): 向上取整

double d1 = Math.ceil(3.9));  // 4.0
double d2 = Math.ceil(3.1));  // 4.0
double d3 = Math.ceil(3.0));  // 3.0

• public static double floor(double num): 向下取整

double d1 = Math.floor(30.1));  // 30.0
double d2 = Math.floor(30.9));  // 30.0
double d3 = Math.floor(31.0));  // 31.0

• public static long round(double num): 四舍五入

long l1 = Math.round(20.4));  // 20
long l2 = Math.round(10.5));  // 11
long l3 = Math.round(10));  // 10

• Math.PI代表近似的圆周率常量(double)。

3.2 练习

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

package cn.luis.demo4;

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

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

    备注：如果使用Math.ceil方法，-10.8可以变成10.0，注意double也是可以进行++的。
 */
public class Demo04MathPractise {
    public static void main(String[] args) {

        int count = 0;

        double min = -10.8; // -10.8到5.9之间
        double max = 5.9;

        double numA = 6;  // 绝对值大于6或者小于2.1
        double numB = 2.1;
        // 这样处理，变量i就是区间内所有的整数
        for (int i = (int) min; i < max; i++) {  // [-10,5]

           int abs = Math.abs(i);  // 绝对值

           if (abs > numA || abs < numB) {  // abs = 2; i = 5;
                if (abs == Math.floor(numB)) {
                    System.out.print(i);
                    count++;
                } else {
                    System.out.print(i + ",");
                    count++;
                }
            }
        }
        System.out.println("\n共有:" + count);  // 9
    }
}

结果：

-10,-9,-8,-7,-2-1,0,1,2
共有:9

增强版

package cn.luis.demo4;

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

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

    备注：如果使用Math.ceil方法，-10.8可以变成10.0，注意double也是可以进行++的。
 */
public class Demo05MathPractisePro {
    public static void main(String[] args) {

        int count = 0;

        double min = -10.8; // -10.8到5.9之间
        double max = 5.9;

        double numA = 6;  // 绝对值大于6或者小于2.1
        double numB = 2.1;
        // 这样处理，变量i就是区间内所有的整数
        for (double i = Math.ceil(min); i < max; i++) {  //i的值：-10.0, -9.0,...5.0

            double abs = Math.abs(i);  // 绝对值
            if (abs > numA || abs < numB) {  // abs是double型
                int num = (int)Math.ceil(i);
                if (abs == Math.floor(numB)) {
                    System.out.print(num);
                    count++;
                } else {
                    System.out.print(num + "*");  // -10,-9,-8,-7,-2,-1,0,1,2,
                    count++;
                }
            }
            //System.out.println(i);
        }
        System.out.println("\n总共有：" + count);  // 9
    }
}

结果：

-10*-9*-8*-7*-2-1*0*1*2
总共有：9

END