常用API（二）

牛钰婷

已于 2023-11-25 21:14:06 修改

阅读量451

点赞数 10

分类专栏： #学习文章标签： java

于 2023-11-25 15:06:50 首次发布

本文链接：https://blog.csdn.net/2301_80460643/article/details/134563036

版权

#学习专栏收录该内容

30 篇文章 0 订阅

订阅专栏

一，Math,System,Runtine

Math

1.代表数学，是一个工具类，里面提供的是对数据进行操作的一些静态方法

        //1.取绝对值
        System.out.println(Math.abs(-12));//12
        //2.向上取整
        System.out.println(Math.ceil(4.001));//5.0
        System.out.println(Math.ceil(4.0));//4.0
        //3.向下取整
        System.out.println(Math.floor(4.99999));//4.0
        System.out.println(Math.floor(4.0));//4.0
        //4.四舍五入
        System.out.println(Math.round(4.99999));//5
        System.out.println(Math.round(4.0001));//4
        //5.取较大值
        System.out.println(Math.max(10, 20));//20
        //去较小值
        System.out.println(Math.min(10, 20));//10
        //6.取次方
        System.out.println(Math.pow(2, 3));//8.0
        System.out.println(Math.pow(3, 2));//9.0
        //7.随机数[0.0,1.0](包前不包后）
        System.out.println(Math.random());

System

1.代表程序所在的系统，也是一个工具类

//1.终止Java虚拟机
//System.exit(0)
//2.获取当前系统的时间，返回的是long类型的时间毫秒值，指的是从1970年1月1日 0：0：0走到此刻的总毫秒值，应该是很大的1s=1000ms
long time=System.currentTimeMillis();
System.out.println(time);

Runtime

1.（1）代表程序所在的运行环境

（2）runtime是一个单例类

Runtime r=Runtime.getRuntime();
        //2.终止当前运行的虚拟机，该参数用作状态代码；按照惯例，零状态代码表示异常终止
       // r.exit(0);
        //3.获取虚拟机能够使用的处理器部数
        System.out.println(r.availableProcessors());
        //4.返回Java虚拟机中的内存总量
        System.out.println(r.totalMemory()/1024.0/1024.0+"MB");//1024=1k,1024*1024=1M
        //5.返回Java虚拟机中的可用内存量
        System.out.println(r.freeMemory()/1024.0/1024.0+"MB");
        //6.启动某个程序，并返回代表该程序的对象
        //r.exec("QQ");//路径
        Process p=r.exec(...);
        Thread.sleep(5000);//让程序在这里停留5s后继续往下走
        p.destroy(...);//销毁，关闭程序

二，BigDecimal

1.用于解决浮点型运算时，出现结果失真的问题

//存入
 BigDecimal a1=BigDecimal.valueOf(a);
 BigDecimal b1=BigDecimal.valueOf(b);
//加减乘除
 BigDecimal c1=a1.add(b1);
 BigDecimal c1=a1.subtract(b1);
 BigDecimal c1=a1.multiply(b1);
 BigDecimal c1=a1.divide(b1);
//保留几位
 BigDecimal i=BigDecimal.valueOf(0.1);
 BigDecimal j=BigDecimal.valueOf(0.3);
 BigDecimal k=i.divide(j,2, RoundingMode.HALF_UP);

三，JDK8之前传统的日期时间

Date

        //1.创建一个Date的对象，代表系统当前时间信息
        Date d=new Date();
        System.out.println(d);
        //2.拿到时间毫秒值
        long time =d.getTime();
        System.out.println(time);
        //3.把时间毫秒值转换成日期对象，2s后的时间是多少
        time+=2*1000;
        Date d2=new Date(time);
        System.out.println(d2);
        //4.直接把日期对象的时间通过setTime方法进行修改
        Date d3=new Date();
        d3.setTime(time);
        System.out.println(d3);

SimpleDateFormat

1.代表简单日期格式化，可以用来把日期对象，时间毫秒值格式化成我们想要的形式

 Date d=new Date();
        System.out.println(d);

        long time=d.getTime();
        System.out.println(time);

        //2.格式化日期对象和实践毫秒值
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        String rs=sdf.format(d);
        String rs2=sdf.format(time);
        System.out.println(rs);
        System.out.println(rs2);
        System.out.println("------------------------");
        //目标：掌握字符串事件成为日期对象
        String dateStr="2022-12-12 12:12:11";
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2=sdf2.parse(dateStr);
        System.out.println(d2);

四，传统日期Calendar

1.代表的是系统此刻时间对应的日历，通过它可以单独获取，修改时间中的年，月，日，时，分，秒等

2.常见方法

  //1.得到系统此刻的时间对应的日历对象
        Calendar now=Calendar.getInstance();
        System.out.println(now);
        //2.获取日立的某个信息
        int year=now.get(Calendar.YEAR);
        System.out.println(year);
        int days=now.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);
        //3.拿到日历中记录的日期对象
        Date d=now.getTime();
        System.out.println(d);
        //4.拿到时间毫秒值
        long time=now.getTimeInMillis();
        System.out.println(time);
        //5.修改日历中的某个信息
        now.set(Calendar.MONTH,9);
        System.out.println(now);
        //6.为某个信息增加或者减少多少
        now.add(Calendar.DAY_OF_YEAR,100);

五，新型日期

   //传统的时间类(Date,SimpleDateFarmat,Calendar)存在如下问题
        //1.设计不合理，使用不方便，很多都被淘汰了
        Date d=new Date();
        System.out.println(d.getYear()+1900);//2023,过时
        Calendar c=Calendar.getInstance();
        int year=c.get(Calendar.YEAR);
        System.out.println(year);//2023
        //2.都是可变对象，修改后会丢失最开始的时间信息

        //3.线程不安全
        //4.不能精确到秒，只能精确到毫秒
        //1s=1000ms;1毫秒=1000微秒；1微秒=1000纳秒

六，jdk8新时间LocalDate,LocalTime,LocalDateTime，Zoneld,ZoneDateTime,Instant

LocalDate,LocalTime,LocalDateTime

 //0.获取本地日期对象
        LocalDate ld=LocalDate.now();
        System.out.println(ld);
        //1.获取日期对象中的信息
        int year=ld.getYear();//年
        int month= ld.getMonthValue();//月
        int day=ld.getDayOfMonth();//日
        DayOfWeek dayOfYear=ld.getDayOfWeek();//一年中的第几天
        int dayOfWeek=ld.getDayOfWeek().getValue();//星期几
        System.out.println(year);
        System.out.println(day);
        System.out.println(dayOfWeek);

        //2.直接修改某个信息：withYear,withMonth,withDayOfMonth,withDayOfyear
        LocalDate ld2=ld.withYear(2099);
        LocalDate ld3=ld.withMonth(12);
        System.out.println(ld2);
        System.out.println(ld3);
        System.out.println(ld);
        //3.把某个信息价多少：plusYear,plusMonths,plusDays,plusWeeks
        LocalDate ld4=ld.plusYears(2);
        LocalDate ld5=ld.plusMonths(2);
        //4.把某个信息减多少，minusYears,minusMonths,minusDays,minusWeeks
        LocalDate ld6=ld.minusYears(2);
        LocalDate ld7=ld.minusMonths(2);
        //5.获取指定日期的LocalDate对象：public static LocalDate of(int year,int month)
        LocalDate ld8=LocalDate.of(2099,12,12);
        LocalDate ld9=LocalDate.of(2099,12,12);
        //6.判断2个日期对象，是否相等，在前还是在后
        System.out.println(ld8.equals(ld9));//true
        System.out.println(ld8.isAfter(ld));//true
        System.out.println(ld8.isBefore(ld));//false

Zoneld，ZonedDateTime

 //1.ZoneId=ZoneId.systemDefault();,获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
        System.out.println(zoneId);
        //获取Java支持的全部时区Id
        System.out.println(ZoneId.getAvailableZoneIds());
        //把时区的id封装成ZoneId对象
        ZoneId zoneId1=ZoneId.of("Anerica/New_York");

        //2.ZonedDateTime带时区的时间
        //获取某个时区的ZonedDateTime对象
        ZonedDateTime now=ZonedDateTime.now(zoneId1);
        System.out.println(now);
        //世界标准时间了
        ZonedDateTime now1=ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);
        //获取系统的默认时区的ZonedDateTime对象
        ZonedDateTime now2=ZonedDateTime.now();
        System.out.println(now2);

Instent

 //1.创建Instant的对象，获取此刻
        Instant now=Instant.now();//不可变对象
        //2.获取总秒数
        long second=now.getEpochSecond();
        System.out.println(second);

        //3.不修1秒的纳秒数
        int nano=now.getNano();
        System.out.println(nano);
        System.out.println(nano);
        System.out.println(now);
        Instant instant=now.plusNanos(111);
        //Instant对象的作用,做代码的性能分析，或者记录用户的操作时间点
        Instant now1=Instant.now();
        //代码执行
        Instant now2=Instant.now();

七，JDK8新时间-DateTimeFormatter,Period,Duration

DateTimeFormatter

        //1.创建一个日期时间格式化器对象出来
        LocalDateTime formatter= LocalDateTime.now();
        //2.对时间进行格式化
        LocalDateTime now=LocalDateTime.now();
        System.out.println(now);
       // String rs= formatter.format(now);//正向格式化
        //3.格式化时间，其实还有一种方案
        //String rs2= now.format(formatter);//反向格式化
        //4.解析时间，解析时间一般使用LocalDateTime提供的解析方法来解析
        String dateSter="2029年12月12日 12：12：11";
        //LocalDateTime ldt=LocalDateTime.parse(dateStr,formatter);

Period

1.作用：可以用于计算两个LocalDate对象相差的年数，月数，天数

  LocalDate start=LocalDate.of(2029,8,10);
        LocalDate end=LocalDate.of(2029,8,15);
        //1.创建Period对象，封装两个日期对象
        Period period= Period.between(start,end);
        //2.通过period对象获取两个日期对象相差的信息
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());

Duration

1.作用：可以用于计算两个时间对象相差的天数，小时数，分数，秒数，纳秒数，支持LocalTime，LocalDateTime，Instent等时间

 LocalDateTime start=LocalDateTime.of(2025,11,11,11,10,10);
        LocalDateTime end=LocalDateTime.of(2025,11,11,11,11,11);
        //1.得到Duration对象
        Duration duration=Duration.between(start,end);
        //2.获取两个事件对象间隔的信息
        System.out.println(duration.toDays());//间隔多少天
        System.out.println(duration.toHours());//时
        System.out.println(duration.toMinutes());//分
        System.out.println(duration.getSeconds());//秒
        System.out.println(duration.toMillis());//毫秒
        System.out.println(duration.toNanos());//纳秒

八，Array类，自定义排序规则comparable，自定义比较器comparator

Array

1.用来操作数组的一个工具类

2.Array类提供的常见方法

 //1.public static String(类型[] arr);返回数组的内容
        int[] arr={10,20,30,40,50,60};
        System.out.println(Arrays.toString(arr));
        //2.hpublic static 类型[] copeOfRange(类型[] arr,起始索引，结束索引）拷贝数组（指定范围，包前不包后）
        int[] arr2=Arrays.copyOfRange(arr,1,4);
        System.out.println(Arrays.toString(arr2));
        //3.拷贝数组，可以制定新数组的长度
        int[] arr3=Arrays.copyOf(arr,3);
        System.out.println(Arrays.toString(arr3));
        //4.把数组中的数据改成新数据又存进去
        double[] prices={99.8,128,100};
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                return prices[value]*0.8;
            }
        });
        System.out.println(Arrays.toString(prices));
        //5.对数组进行升序排列
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));

自定义排序规则，自定义比较器

  Student[] students=new Student[4];
        students[0]=new Student("蜘蛛精",169.5,23);
        students[1]=new Student("紫霞",163.5,26);
        students[2]=new Student("紫霞",163.5,26);
        students[3]=new Student("至尊宝",167.5,24);
//        Arrays.sort(students);
//        System.out.println(Arrays.toString(students));
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
//                if (o1.getHeight()>o2.getHeight()){
//                     return 1;
//                }else if(o1.getHeight()<o2.getHeight()){
//                    return -1;
//                }
//                return 0;
              //  return Double.compare(o1.getHeight(),o2.getHeight());//升序
                return Double.compare(o2.getHeight(),o1.getHeight());//降序
            }
        });
        System.out.println(Arrays.toString(students));