Java数组与数学工具详解-优快云博客

本文链接：https://blog.youkuaiyun.com/Imagine_cc/article/details/107231448

Arrays

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

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

public static void sort（数组）：按照默认升序（从小到大）对数组的元素进行排序

备注：

如果是数字，sort默认按照升序从小到大
如果是字符串，sort默认按照字母升序
如果是自定义的类型，那么这个自定义的类需要有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, 4, 1, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[1, 2, 4, 5, 6]

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

练习

题目：使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印

import java.util.Arrays;

public class Demo01ArraysPractise {
    public static void main(String[] args) {
        String str = "nfbw0tkx21afw08ew";
        //如何进行升序排列：sort
        //必须是一个数组，才能用Arrays.sort方法
        //String--->数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列

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

math

java.lang包下的数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作

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) {
        //获取绝对值
        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.0));//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(31.0));//31.0
        System.out.println("=============");

        //四舍五入
        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.一旦发现了一个数字，需要让计数器++进行统计

public class Demo03MathPractise {
    public static void main(String[] args) {
        int count = 0;//符合要求的数量

        double min = -10.8;
        double max = 5.9;
        //这样处理，变量i就是区间之内所有的整数
        for(int i = (int) min; i < max; i++){
            int abs = Math.abs(i);//绝对值
            if(abs > 6 || abs < 2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共有：" + count);
    }
}

继承

面向对象的三大特征：封装性、继承性、多态性

继承是多态的前提，如果没有继承，就没有多态

继承主要解决的问题就是：共性抽取

继承关系当中的特点：

子类可以拥有父类的“内容”
子类还可以拥有自己专有的内容

在继承关系中，“子类就是一个父类”，也就是说，子类可以被当做父类看待

例如父类是员工，子类是讲师，那么“讲师就是一个员工”，关系：is-a

定义父类的格式：（一个普通的类定义）

public class 父类名称{

//........

}

定义子类的格式：

public class 子类名称 extends 父类名称{

//.........

}

//定义一个父类：员工
public class Employee {
    public void method(){
        System.out.println("方法执行！");

    }
}

//定义了一个员工的子类：讲师
public class Teacher extends Employee{
}

//定义了员工的另一个子类：助教
public class Assistant extends Employee{
}

public class Demo02Extends {
    public static void main(String[] args) {
        //创建一个子类对象
        Teacher teacher = new Teacher();
        //Teacher类当中虽然什么都没有写，但是会继承来自父类的method方法
        teacher.method();//方法执行！

        //创建另一个子类：助教 的对象
        Assistant assistant = new Assistant();
        assistant.method();//方法执行！
    }
}

在父子类的继承关系中，如果成员变量重名。则创建子类对象时，访问有两种方式

直接通过子类对象访问成员变量

等号左边是谁，就优先用谁，没有则向上找

间接通过成员方法访问成员变量

该方法属于谁，就优先用谁，没有则向上找

public class Fu {
    int numFu = 10;

    int num = 100;

    public void methodFu(){
        //使用的是本类当中的，不会向下找子类的
        System.out.println(num);
    }
}

public class Zi extends Fu{
    int numZi = 20;

    int num = 200;

    public void methodZi(){
        //因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }
}

public class Demo03ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu();//创建父类对象
        System.out.println(fu.numFu);//10 只能使用父类的东西，没有任何子类内容
        System.out.println("===========");

        Zi zi = new Zi();

        System.out.println(zi.numFu);//10
        System.out.println(zi.numZi);//20
        System.out.println("===========");

        //等号左边是谁，就优先用谁
        System.out.println(zi.num);//优先子类，200
        System.out.println("===========");

        //这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi();//200
        //这个方法是在父类当中定义的
        zi.methodFu();//100
    }
}

20200709

Arrays

math

继承