39、常用类之Math类、Arrays类、System类、BigInteger和BigDecimal类、日期类

最新推荐文章于 2023-06-30 10:41:45 发布

戏拈秃笔

最新推荐文章于 2023-06-30 10:41:45 发布

阅读量135

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_72052233/article/details/127953813

版权

java基础专栏收录该内容

61 篇文章 2 订阅

订阅专栏

一、Math类

1、Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

补：random返回的是0 <= x <1 之间的一个随机小数

        //请写出获取a-b之间的一个随机整数，a，b均为整数，比如a=2,b=7
        //返回一个数x，范围在[2，7]
        //1、0 <= x < 1
        //2、0*(b-a) <= x*(b-a) < 1*(b-a)
        //3、x*(b-a) = Math.random()*(b-a),
        4、核心公式:(int)(a+Math.random()*(b-a+1)); 返回的是[a,b]之间的一个数
        //5、+1是因为要取[2，7]之间的整数，(int)转换后会丢失小数部分，不加1就只能取到[2，6]
        //6、答案：(int)(2+Math.random()*6)
        //答案解析：
        //Math.random()*6返回的是[0，6)
        //2+Math.random()*6返回的是[2，8)
        //(int)转换后，会丢失精度，变成[2，7]

package Math_;
public class Math_ {
    public static void main(String[] args) {
        for(int i=0;i<3;i++){
            System.out.println((int)(2+Math.random()*(7-2+1)));
            //输出：
            //3
            //2
            //5
        }
    }
}

package Math_;
public class Math_ {
    public static void main(String[] args) {
        int abs=Math.abs(-9);
        System.out.println(abs);//9

        double pow=Math.pow(2,4);
        System.out.println(pow);//16

        double ceil=Math.ceil(-3.001);
        System.out.println(ceil);//-3

        double floor=Math.floor(-4.999);
        System.out.println(floor);//-5

        long round=Math.round(-5.001);
        System.out.println(round);//-5 四舍五入，该参数+0.5

        double sqrt=Math.sqrt(9.0);
        System.out.println(sqrt);//3.0

        int min=Math.min(1,9);
        System.out.println(min);//1

        int max=Math.max(1,9);
        System.out.println(max);//9
    }
}

二、Arrays类

1、Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

package Math_;
import java.util.Arrays;
import java.util.Comparator;
public class Math_ {
    public static void main(String[] args) {
        Integer arr[]={1,-1,7,0,89};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                Integer i1=(Integer) o1;
                Integer i2=(Integer) o2;
                return i2-i1;//[89, 7, 1, 0, -1]
            }
        });
        System.out.println("=======排序后=======");
        System.out.println(Arrays.toString(arr));
        //1、因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
        //2、sort重载的，也可以通过传入一个接口Comparator实现定制排序
        //3、调用定制排序时，传入两个参数：
        //（1）排序的数组arr（2）实现了Comparator接口的匿名内部类，要求实现compare方法

        //追源码：
//        while(left<right){
//            int mid=(left-right)>>>1;
//            if(c.compare(pivot,a[mid])<0)
//                right=mid;
//            else
//                left=mid+1;
//        }
        //public int compare(Integer o1, Integer o2) 返回的值>0还是<0
        //会影响整个排序结果
        //充分体现了 接口编程+动态绑定+匿名内部类 的综合使用
    }
}

//对上面的定制排序方法加以解释说明：
package Math_;

import java.util.Arrays;
import java.util.Comparator;

public class Math_ {
    public static void main(String[] args) {
        int[] arr={1,-1,8,0,20};
        bubble01(arr);
        System.out.println("====排序后====");
        System.out.println(Arrays.toString(arr));
        //====排序后====
        //[-1, 0, 1, 8, 20]

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1=(Integer) o1;
                Integer i2=(Integer) o2;
                return i2-i1;
                //如果是return i1-i2;则输出：
                //====定制排序后====
                //[-1, 0, 1, 8, 20]
            }
        });
        System.out.println("====定制排序后====");
        System.out.println(Arrays.toString(arr));
        //====定制排序后====
        //[20, 8, 1, 0, -1]
    }

    //冒泡排序
    public static void bubble01(int[] arr){
        int temp=0;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

    //结合冒泡+定制
    public static void bubble02(int[] arr,Comparator c){
        int temp=0;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                //数组排序由c.compare(arr[j],arr[j+1])返回的值决定
                //>0 表示前面的数大，要交换
                if(c.compare(arr[j],arr[j+1])>0){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

package Math_;

import java.util.Arrays;

public class Math_ {
    public static void main(String[] args) {
        Integer[] arr={1,2,90,123,567};
        //1、使用binarySearch二叉查找
        //2、要求该数组必须是有序，才可使用binarySearch
        //3、如果数组中不存在该元素，就返回return -(low+1);low是它本该在位置
        int index= Arrays.binarySearch(arr,92);
        System.out.println("index="+index);//index=-4 //-(3+1)
    }
}

package Math_;

import java.util.Arrays;
import java.util.List;

public class Math_ {
    public static void main(String[] args) {
        Integer[] arr={1,2,90,123,567};
        Integer[] arr2={1,2,90,123,567};
        //1、从arr数组中，拷贝arr.length个元素到newArr数组中
        //2、如果拷贝的长度 > arr.length就在新数组后面增加null
        //3、如果拷贝的长度 < 0就抛出异常NegativeArraySizeException
        System.out.println("====拷贝执行完毕后====");
        Integer[] newArr=Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(newArr));
        //====拷贝执行完毕后====
        //[1, 2, 90, 123, 567]

        Integer[] num=new Integer[]{9,3,2};
        //使用99去填充num数组，可以理解成是替换原来的元素
        System.out.println("====数组填充后====");
        Arrays.fill(num,99);
        System.out.println(Arrays.toString(num));
        //====数组填充后====
        //[99, 99, 99]

        boolean equals=Arrays.equals(arr,arr2);
        System.out.println(equals);//true
        //如果两个数组元素完全一样，则返回true，否则返回false

        List asList=Arrays.asList(2,3,4,5,6);
        System.out.println(asList);
        System.out.println("asList的运行类型："+asList.getClass());
        //[2, 3, 4, 5, 6]
        //asList的运行类型：class java.util.Arrays$ArrayList
        
        //ArrayList是Arrays的一个静态内部类
    }
}

2、练习题

//我的代码

package Math_;

import java.util.Comparator;

public class ArraysExercise {
    public static void main(String[] args) {
        Book[] books=new Book[4];
        books[0]=new Book("红楼梦~",100);
        books[1]=new Book("金瓶梅~",90);
        books[2]=new Book("青年文摘~",5);
        books[3]=new Book("java从入门到放弃~",300);
        bubbleSort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1=(Integer) o1;
                Integer i2=(Integer) o2;
                return i2-i1;
            }
        });
        System.out.println("====定制排序后====");
        for(int i=0;i<books.length;i++){
            System.out.println(books[i].getName()+" "+books[i].getPrice());
        }
    }
    public static void bubbleSort(Book[] books, Comparator c){
        Book temp=null;
        for(int i=0;i<books.length-1;i++){
            for(int j=0;j<books.length-1-i;j++){
                if(c.compare(books[j].getPrice(),books[j+1].getPrice())>0){
                    temp=books[j];
                    books[j]=books[j+1];
                    books[j+1]=temp;
                }
            }
        }
    }
}
class Book{
    private String name;
    private int price;

    public Book(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}
//输出：====定制排序后====
//java从入门到放弃~ 300
//红楼梦~ 100
//金瓶梅~ 90
//青年文摘~ 5

//老师的代码

package Math_;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysExercise {
    public static void main(String[] args) {
        Book[] books=new Book[4];
        books[0]=new Book("红楼梦~",100);
        books[1]=new Book("金瓶梅~",90);
        books[2]=new Book("青年文摘~",5);
        books[3]=new Book("java从入门到放弃~",300);
        Arrays.sort(books, new Comparator() {//主要是这里不一样
            @Override
            public int compare(Object o1, Object o2) {
                Book book1=(Book) o1;
                Book book2=(Book) o2;
                double priceVal= book2.getPrice()- book1.getPrice();
                //priceVal是double型的，在这个int型方法中不能直接返回（会丢失精度），所以下面提供了一个转换
                if(priceVal>0){
                    return 1;
                }else if(priceVal<0){
                    return -1;
                }else{
                    return 0;
                }
            }
        });
        System.out.println("====定制排序后====");
        System.out.println(Arrays.toString(books));
    }
    public static void bubbleSort(Book[] books, Comparator c){
        Book temp=null;
        for(int i=0;i<books.length-1;i++){
            for(int j=0;j<books.length-1-i;j++){
                if(c.compare(books[j].getPrice(),books[j+1].getPrice())>0){
                    temp=books[j];
                    books[j]=books[j+1];
                    books[j+1]=temp;
                }
            }
        }
    }
}
class Book{
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
//输出：====定制排序后====
//[Book{name='java从入门到放弃~', price=300.0}, Book{name='红楼梦~', price=100.0}, Book{name='金瓶梅~', price=90.0}, Book{name='青年文摘~', price=5.0}]

三、System类

1、常用方法

package Math_;

public class System_ {
    public static void main(String[] args) {
        System.out.println("ok1");
        System.exit(0);
        System.out.println("ok2");
        //输出：ok1
        //解读：0表示一个状态，正常的状态
    }
}

package Math_;

import java.util.Arrays;

public class System_ {
    public static void main(String[] args) {
        int[] src={1,2,3};
        int[] dest=new int[3];//dest={0.0.0}
        System.arraycopy(src,0,dest,1,2);
        //从src的第0个位置开始，拷贝3个数据到dest的第一个位置开始
        System.out.println("dest="+ Arrays.toString(dest));//dest=[0, 1, 2]
    }
}

package Math_;

import java.util.Arrays;

public class System_ {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
        //1668994160694
    }
}

四、BigInteger和BigDecimal类

1、介绍：

2、常用方法：

package Math_;

import java.math.BigInteger;

public class BigInteger_ {
    public static void main(String[] args) {
        //long l=1111111111111111;
        //System.out.println("l="+l);
        //在编程中，需要处理很大的整数时，long不再适用
        //引出BigInteger类来处理

        BigInteger bigInteger=new BigInteger("11111111111111111111111111111111");
        System.out.println(bigInteger);
        //11111111111111111111111111111111

        //用BigInteger进行算术运算
        BigInteger bigInteger1=new BigInteger("11111111111111111111111111111111");
        BigInteger bigInteger2=new BigInteger("11111111111111111111111111111111");
        BigInteger add=bigInteger1.add(bigInteger2);
        
        System.out.println(add);//加
        //22222222222222222222222222222222
        
        BigInteger subtract=bigInteger1.subtract(bigInteger2);
        System.out.println(subtract);//减
        //0
        
        BigInteger multiply=bigInteger1.multiply(bigInteger2);
        System.out.println(multiply);//乘
        //123456790123456790123456790123454320987654320987654320987654321
        
        BigInteger divide=bigInteger1.divide(bigInteger2);
        System.out.println(divide);//除
        //1
    }
}

package Math_;

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigDecimal_ {
    public static void main(String[] args) {
        //double d=11.1111111111111111111111111111111111;
        //System.out.println(d);
        //当我们需要保存一个精度很高的数时，double不够用
        //引出BigDecimal类

        BigDecimal bigDecimal=new BigDecimal(1.111111111111111111111);
        System.out.println(bigDecimal);

        //用BigDecimal进行算术运算
        BigDecimal bigDecimal1=new BigDecimal("2.2222222222222222222222");
        BigDecimal bigDecimal2=new BigDecimal("2.2222222222222222222222");
        System.out.println(bigDecimal1.add(bigDecimal2));
        System.out.println(bigDecimal1.subtract(bigDecimal2));
        System.out.println(bigDecimal1.multiply(bigDecimal2));
        //System.out.println(bigDecimal1.divide(bigDecimal2));
        //如果相除的结果是无限循环小数，则可能抛出ArithmeticException异常
        //在调用divide方法时，指定精度即可,BigDecimal.ROUND_CEILING
        //如果有无限循环小数，就会保留和分子一样的精度
        System.out.println(bigDecimal1.add(bigDecimal2,BigDecimal.ROUND_CEILING));

    }
}

五、日期类（知道怎么查，怎么用即可，不用每个方法都背）

1、第一代日期类

package Math_;

public class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void cry(){}
    class Air{}
    //说明一下diagram IDEA properties的含义
    public void setAddress(String address){}
    public double getSalary(){
        return 1.1;
    }
    //set,get方法后面的部分会自动转换成属性在类图里显示出来
}

package Math_;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Date01 {
    public static void main(String[] args) throws ParseException {
        //解读：
        //1、获取当前系统时间
        //2、这里的Date类是在java.util包
        //3、默认输出的日期格式是国外的方式，因此通常需要对格式进行转换
        Date d1=new Date();
        System.out.println("当前日期:"+d1);

        //通过指定毫秒数得到时间
        Date d2=new Date(123456);
        System.out.println("指定毫秒的日期："+d2);

        //获取某个时间对应的毫秒数
        System.out.println("指定日期的毫秒数："+d1.getTime());

        //解读：
        //1、创建SimpleDateFormat对象，可以指定相应的格式
        //2、这里的格式使用的字母是规定好的，不能乱写
        SimpleDateFormat sdf=new SimpleDateFormat("yyy年MM月dd日 HH:mm:ss E");
        String format=sdf.format(d1);//format将日期转换成指定格式的字符串
        System.out.println("当前日期:"+format);

        //把一个格式化的String转成对应的Date
        //在此过程中，使用的sdf格式需要和我给的String的格式一样，否则会抛出转换异常
        String s="2022年11月21日 20:45:32 周一";
        Date parse=sdf.parse(s);//有异常，抛出到方法签名处，alt+enter
        System.out.println("格式字符串转成日期（外国格式）："+parse);
        System.out.println("格式字符串转成日期（国内格式）："+sdf.format(parse));
    }
}
//输出：
//当前日期:Mon Nov 21 20:58:28 CST 2022
//指定毫秒的日期：Thu Jan 01 08:02:03 CST 1970
//指定日期的毫秒数：1669035508258
//当前日期:2022年11月21日 20:58:28 周一
//格式字符串转成日期（外国格式）：Mon Nov 21 20:45:32 CST 2022
//格式字符串转成日期（国内格式）：2022年11月21日 20:45:32 周一

2、第二代日期类

package Math_;

import java.util.Calendar;

public class Calendar_ {
    public static void main(String[] args) {
        //1、Calendar是一个抽象类，并且构造器是private
        //2、可以通过getInstance()来获取实例
        //3、提供了大量的方法和字段给程序员
        //4、Calendar没有提供对应的格式化的类，需要程序员自己组合来输出
        Calendar c= Calendar.getInstance();
        System.out.println("Calendar提供的字段："+c);

        //获取日历对象的某个日历字段
        System.out.println("年："+c.get(Calendar.YEAR));
        System.out.println("月："+c.get(Calendar.MONTH)+1);//因为月是从0开始编号的，所以要加上1
        System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("(12小时制)小时："+c.get(Calendar.HOUR));//12小时制
        System.out.println("(24小时制)小时："+c.get(Calendar.HOUR_OF_DAY));//24小时制
        System.out.println("分钟："+c.get(Calendar.MINUTE));
        System.out.println("秒："+c.get(Calendar.SECOND));

        //自由组合
        System.out.println(c.get(Calendar.YEAR)+"-"+(c.get(Calendar.MONTH)+1)+"-"+
                c.get(Calendar.DAY_OF_MONTH)+" "+c.get(Calendar.HOUR)+":"+c.get(Calendar.MINUTE)
                +":"+c.get(Calendar.SECOND));

    }
}
//输出：
//Calendar提供的字段：java.util.GregorianCalendar[time=1669036787267,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=21,DAY_OF_YEAR=325,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=9,HOUR_OF_DAY=21,MINUTE=19,SECOND=47,MILLISECOND=267,ZONE_OFFSET=28800000,DST_OFFSET=0]
//年：2022
//月：101
//日：21
//(12小时制)小时：9
//(24小时制)小时：21
//分钟：19
//秒：47
//2022-11-21 9:19:47

package Math_;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDate_ {
    public static void main(String[] args) {
        //使用now()返回表示当前日期时间的对象
        LocalDateTime ldt=LocalDateTime.now();
        System.out.println(ldt);
        System.out.println("年:"+ldt.getYear());
        System.out.println("月（英）:"+ldt.getMonth());
        System.out.println("月（中）:"+ldt.getMonthValue());
        System.out.println("日:"+ldt.getDayOfMonth());
        System.out.println("时:"+ldt.getHour());
        System.out.println("分:"+ldt.getMinute());
        System.out.println("秒:"+ldt.getSecond());

        LocalDate now1=LocalDate.now();//可以获取年月日，但不能获取时分秒
        LocalTime now2=LocalTime.now();//可以获取时分秒，但不能获取年月日
    }
}
//输出：
//2022-11-21T21:37:16.590506200
//年:2022
//月（英）:NOVEMBER
//月（中）:11
//日:21
//时:21
//分:37
//秒:16

package Math_;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class LocalDate_ {
    public static void main(String[] args) {
        LocalDateTime ldt=LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format=dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期："+format);
    }
}
//输出：格式化的日期：2022-11-21 21:49:08

package Math_;

import java.time.Instant;
import java.util.Date;

public class Instant_ {
    public static void main(String[] args) {
        //通过静态方法now()获取表示当前时间戳的对象
        Instant now=Instant.now();
        System.out.println(now);

        //通过from把Instant转成Date
        Date date=Date.from(now);
        System.out.println(date);

        //通过toInstant把Date转成Instant
        Instant instant=date.toInstant();
        System.out.println(instant);
    }
}
//输出：
//2022-11-21T13:55:22.780425Z
//Mon Nov 21 21:55:22 CST 2022
//2022-11-21T13:55:22.780Z

package Math_;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class Instant_ {
    public static void main(String[] args) {
        LocalDateTime ldt=LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter= DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //对当前时间进行加或减

        LocalDateTime localDateTime=ldt.plusDays(90);//加
        System.out.println("90天后："+dateTimeFormatter.format(localDateTime));

        LocalDateTime localDateTime1=ldt.minusMinutes(1234);//减
        System.out.println("1234分钟前的日期："+dateTimeFormatter.format(localDateTime1));
    }
}
//输出：
//90天后：2023-02-19 22:05:30
//1234分钟前的日期：2022-11-21 01:31:30