Java之API

于 2024-10-11 21:22:52 发布
阅读量647 收藏 8
点赞数 16
文章标签： java API Object 方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79981885/article/details/142639554
版权

前言

这一篇讲API，有很多很多的API

1. Object

它是所有类的祖宗类，所以任何类都可以直接使用Object的一些方法

1.1 toString

在这里插入图片描述
从这个我们就可以看出，平时对s1的打印其实是默认调用了它的toString函数，因为toString是灰色的
在这里插入图片描述
但是默认打出来的是地址，这也是为什么我们会认为名字就是地址，其实就是地址

要想打印出真正的内容，就必须在Student类中把toString函数重写
这也是为什么String打出来的不是地址，因为重写了

public class Student {

    private int age;
    private String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Student() {
    }
}

        System.out.println(s1);
        System.out.println(s1.toString());

在这里插入图片描述

1.2 equals

System.out.println(s1.equals(s2));

在这里插入图片描述
正常的equals就是比较的地址，重写之后，比的就是里面的内容了

System.out.println(s1==s2);

没有重写的话，就和上面这个是一样的效果

我们用系统的快捷方式来重写

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

getClass() != o.getClass()这个主要是判断类型的，看两个的类型相不相同
getClass() 会返回一个Student.class
至于Objects，这也是一个类，后面再说

1.3 clone

clone会克隆一个一模一样的对象，然后返回，但是克隆的只是浅克隆，对于里面的自定义对象，只会克隆地址，不会克隆里面的数据
在这里插入图片描述
但是注意一下，克隆是被保护的，所以要重写一下，才可以正常调用

public Object clone() throws CloneNotSupportedException {
        Object clone = super.clone();
        return clone;
    }

throws CloneNotSupportedException这个是抛异常，暂时不讲

****在idea中我们有错误，点上去显示错误，然后ALT+回车就可以修正错误

Student s3= (Student) s1.clone();

这样就可以克隆，因为返回的是Object，所以要强转一下

Student s1=new Student(12,"111111");
        Student s3= (Student) s1.clone();
        System.out.println(s3.getName());
        System.out.println(s3.getAge());
        System.out.println(s1.getName());
        System.out.println(s1.getAge());

深克隆就是面对里面的自定义类型（除了String），不是拷贝地址，而是自己开辟来拷贝，String这个自定义就是直接拷贝地址就可以了，因为它存的内容在静态区，不可改变
如果里面都是普通类型，那么就不会存在深浅拷贝的问题

2.Objects

Objects调用的直接就是静态方法，但方法都和Object差不多

2.1 equals

String s1="aaaaa";
        String s2="aaaaa";
        System.out.println(s1.equals(s2));
        System.out.println(Objects.equals(s1, s2));

在这里插入图片描述

这就是两个的区别，都是比的地址，因为String是存在静态区的，所以String的内容一样，地址就一样

这个s1.equals(s2)的坏处就是，万一s1为null，那么就会出错了
而Objects.equals(s1, s2)是直接返回false，不会出错

2.2 isNull

String s1="aaaaa";
        String s2=null;
        System.out.println(Objects.isNull(s1));
        System.out.println(Objects.isNull(s2));

在这里插入图片描述
这个函数的作用就是看是否为null，如果是的话就直接返回true
等价于这个

System.out.println(s2==null);

2.3 nonNull

String s1="aaaaa";
        String s2=null;
        System.out.println(Objects.nonNull(s1));
        System.out.println(Objects.nonNull(s2));

在这里插入图片描述
这个就是不是null返回true

3. 包装类

这个就是把基本的数据类型包装成对象的类
因为万物皆对象，所以也需要把基本数据类型包装成类
除了int和char，其余的基本数据类型的包装类的名字就是首字母大写
int是Integer，char是Character
这里我们以int为例
它有构造函数，但是它的构造函数已经过时了，不能用了
在这里插入图片描述
我们一般用calueOf来构造

这是个静态方法

Integer i=Integer.valueOf(1);

valueOf这个方法，会返回一个Integer的类对象

System.out.println(i);

在这里插入图片描述
对这个对象的打印就是打印int这个数值

下面我们来讲一下自动装箱

Integer a1=10;

可以把基本数据类型自动转化为对象，这个过程就叫做自动装箱

int a2=a1;

把包装类型的对象转换成对应的基本数据类型，这个就叫做自动拆箱

又因为泛型和集合不支持基本数据类型，只能用引用数据类型，但是我们放入Integer就可以插入intl了

3.1 toString

String a3=a1.toString();
        System.out.println(a3 + 1);

在这里插入图片描述
这个方法的作用主要就是将里面的基本数据转换为字符串
所以得到的结果就是101而不是11

3.2 parseInt

String a4="1234";
        int age=Integer.parseInt(a4);
        System.out.println(age + 1);

在这里插入图片描述
这个函数的主要作用就是将字符串转换为基本数据类型，注意Integer的parseInt就只能将字符串转换为int，所以字符串为double类型时就会报错

在这里插入图片描述
这时就要用Double的parseDouble了

4. StringBuilder

这个也是装字符串的，只不过这个装的字符串是可变的，不像String，由于String不可变，每次都要重新找一个新的字符串，所以效率String的要低一点

4.1 构造器

StringBuilder s3=new StringBuilder();
        StringBuilder s4=new StringBuilder("aaaa");

4.2 append

这个方法的主要作用就是拼接

StringBuilder s3=new StringBuilder();
        s3.append(12);
        s3.append("aaa");
        s3.append(true);
        System.out.println(s3);

在这里插入图片描述
这个拼接不管你传入的参数是什么类型，结果最终都是会转成字符串来拼接的
在这里插入图片描述
由于append返回的还是StringBuilder，所以我们可以链式编程

        StringBuilder s4=new StringBuilder("aaaa");
        s4.append(12).append("int");
        System.out.println(s4);

在这里插入图片描述

4.3 reverse

s4.reverse();
        System.out.println(s4);

在这里插入图片描述

这个就是反转

4.4 toString

String s5=s4.toString();

就是将StringBuilder的内容转换为String

5. StringBuffer

这个和StringBuilder的方法使用是一样的，只不过这个是线程安全的

5.1 练习

设计一个方法，返回整型数组，返回的数组类型为[11, 22, 33]

public static String change(int[] arr){
        StringBuffer s=new StringBuffer();
        s.append("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                s.append(arr[i]);
            }else{
                s.append(arr[i]+", ");
            }
        }
        s.append("]");
        return  s.toString();
    }

System.out.println(change(new int[]{1, 2, 3, 4, 5, 6}));

在这里插入图片描述

5-6. StringJoiner

这个方法的主要作用就是优化上面这个方法的

StringJoiner s6=new StringJoiner(", ");
        s6.add("12");
        s6.add("14");
        s6.add("15");
        System.out.println(s6);

在这里插入图片描述

构造器的作用就是给每个add添加的数据提供一个分隔符，这里的分隔符就是逗号＋空格
然后add添加的内容只能是字符串

StringJoiner s6=new StringJoiner(", ","[","]");
        s6.add("12");
        s6.add("14");
        s6.add("15");
        System.out.println(s6);

在这里插入图片描述
这个构造器后面两个参数的意思就是，串的开始符号是[,结束符号是]

然后这个类也是有toString和length方法的

6. Math

这个数学类就是一个工具类，提供的都是一些静态方法

6.1 abs

这个就是求绝对值

System.out.println(Math.abs(-1234));

在这里插入图片描述

6.2 ceil

这个就是向上求整

6.3 floor

向下取整

6.4 round

四舍五入保留整数，返回的是长整型

System.out.println(Math.round(3.49));

在这里插入图片描述

6.5 max与min

取俩个数的最大值或者最小值

        System.out.println(Math.max(12, 13));

在这里插入图片描述

6.6 pow

取次方

System.out.println(Math.pow(2, 3));

在这里插入图片描述
这里取的就是2的3次方，其中两个参数可以为浮点数，返回值也可以是浮点数

6.7 random

这个返回的就是一个随机数，在[0,1)

System.out.println(Math.random());

在这里插入图片描述

7. System

也是一个工具类

7.1 exit

System.out.println(Math.pow(2, 3));
        System.exit(0);
        System.out.println(Math.random());

在这里插入图片描述
exit是终止程序，参数为0，就是人为的终止程序，它后面的程序就不会执行了，非0的话，就是异常终止程序

一般不使用这个方法

7.2 currentTimeMillis

这个就是获取时间的，返回值是一个long类型的

        long time=System.currentTimeMillis();
        System.out.println(time);

在这里插入图片描述

这个返回的是一个时间戳，只不过是以毫秒为单位的

这个方法的主要作用就是计算用时多久

long time=System.currentTimeMillis();
        for(int j=0;j<1000000;j++){
            System.out.println(j);
        }
        long time1=System.currentTimeMillis();
        System.out.println("用时"+(time1-time)/1000+'s');

在这里插入图片描述

8. Runtime

代表程序的运行环境
是一个单例类

Runtime r=Runtime.getRuntime();

8.1 exit

r.exit(0);

终止程序

8.2 availableProcessors

System.out.println(r.availableProcessors());

在这里插入图片描述
这里是获取虚拟机能使用的处理器数

8.3 totalMemory

System.out.println(r.totalMemory());

System.out.println(r.totalMemory()/1024.0+"KB");

System.out.println(r.totalMemory()/1024.0/1024.0+"MB");

在这里插入图片描述
这个就是返回虚拟机的内存总量

8.4 freeMemory

System.out.println(r.freeMemory()/1024.0/1024.0+"MB");

在这里插入图片描述
这个是返回虚拟机中可用的内存总量

8.5 exec

 r.exec("\"C:\\Users\\zjdsx\\Desktop\\贪吃蛇.exe\"");

r.exec("QQ");

在这里插入图片描述
这个函数的作用就是启动某个程序，输入路径就可以了
因为QQ我们加入了PATH路径的，所以会默认去环境变量PATH里面去找

但是用这个要抛异常，AIT+回车就可以了

Process p=r.exec("QQ");
        Thread.sleep(5000);//单位是毫秒
        p.destroy();

我们可以定义一个Process变量，来接收我们打开的QQ,然后destroy就是关闭

9. BigDecimal

这个是用来解决浮点数计算，结果失真的问题的

System.out.println(0.1 + 0.2);

在这里插入图片描述
为什么会这样呢，因为某些浮点数无法用二进制精确表示，只能无限接近，所以会有这种失真问题

9.1 构造器

在这里插入图片描述
在这里插入图片描述
注意不推荐使用第一个构造器，因为第一个的话，没什么区别，还是会失真，它只是把浮点数存在里面了而已

BigDecimal a1=new BigDecimal(Double.toString(0.2));
        BigDecimal b1=new BigDecimal(Double.toString(0.1));

这样就可以了，里面存的是字符串了

9.2 valueOf

BigDecimal a1=BigDecimal.valueOf(0.2);
        BigDecimal b1=BigDecimal.valueOf(0.1);

或者这样也可以

9.3 add

BigDecimal c1=a1.add(b1);
        System.out.println(c1);

在这里插入图片描述

9.4 divide

BigDecimal a1=BigDecimal.valueOf(0.2);
        BigDecimal b1=BigDecimal.valueOf(0.1);
        BigDecimal c1=b1.divide(a1);
        System.out.println(c1);

在这里插入图片描述
除法

BigDecimal a1=BigDecimal.valueOf(0.3);
        BigDecimal b1=BigDecimal.valueOf(0.1);
        BigDecimal c1=b1.divide(a1);
        System.out.println(c1);

在这里插入图片描述
但是这个除法就不行了，因为0.1/0.3是无限循环小数

BigDecimal a1=BigDecimal.valueOf(0.3);
        BigDecimal b1=BigDecimal.valueOf(0.1);
        BigDecimal c1=b1.divide(a1,2, RoundingMode.HALF_UP);
        System.out.println(c1);

在这里插入图片描述

这样写就可以了
表示保留两位小数

9.5 subtract

BigDecimal c1=b1.subtract(a1);
        System.out.println(c1);

在这里插入图片描述

9.6 multiply

BigDecimal c1=b1.multiply(a1);
        System.out.println(c1);

在这里插入图片描述
这个就是当做的字符串来计算，小数点对齐来算的

9.7 doubleValue

BigDecimal a1=BigDecimal.valueOf(0.3);
        BigDecimal b1=BigDecimal.valueOf(0.1);
        double rs=a1.doubleValue();
        System.out.println(rs);

在这里插入图片描述
这个就是把BigDecimal转化为double

10.Date

10.1 构造器

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

在这里插入图片描述
这样的构造器就是默认以当前时间为准的，存的就是当前的时间

10.2 getTime

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

在这里插入图片描述
这个getTime获得的就是时间戳，单位为毫秒值

10.3 构造器2

Date d=new Date();
        System.out.println(d);
        long time=d.getTime();
        time+=10000;
        Date d1=new Date(time);
        System.out.println(d1);

在这里插入图片描述
这个构造器就是以我们传入的时间戳来设置时间

10.4 setTime

Date d=new Date();
        System.out.println(d);
        long time=d.getTime();
        time+=10000;
        Date d1=new Date(time);
        System.out.println(d1);
        
        Date d2=new Date();
        d2.setTime(time);
        System.out.println(d2);

在这里插入图片描述
这个setTime就是用来更改时间的，用时间戳来更改

11. LocalDate，LocalTime,LocalDateTime

上面我们讲的Runtime，BigDecimal，Date都是JDK8之前的时间API
不太好，
还有没讲的Calendar，格式化器，都可以不学的，因为都老了
第一，很多方法被淘汰了
第二，可变的对象，修改后里面的内容就变了
第三，线程不安全的
第四只能精确到毫秒
后面我们讲的这些时间API都是新的，不可变对象，线程安全，能精确到纳秒的

LocalDate(年月日星期)
LocalTime（时分秒纳秒）
LocalDateTime（年月日星期时分秒纳秒）

11.1 LocalDate

LocalDate ld=LocalDate.now();
        System.out.println(ld);

通过静态方法now就可以了
在这里插入图片描述
获取数据

int year=ld.getYear();//年
        int month=ld.getMonthValue();//月
        int day=ld.getDayOfMonth();//日
        int dayOfYear=ld.getDayOfYear();//一年中的第几天
        int dayOfWeek=ld.getDayOfWeek().getValue();//星期几

        //直接修改某个信息,修改完之后，会返回一个新的对象，原来的对象不改变
        LocalDate ld2=ld.withYear(2099);
        //withMonth,withDayOfMonth,withDayOfYear
        System.out.println(ld2);

在这里插入图片描述

        LocalDate ld3=ld.plusDays(2);//加上一些东西，并返回

        LocalDate ld4=ld.minusDays(2);//减上一些东西，并返回

        LocalDate ld5=LocalDate.of(2022,2,2);
        System.out.println(ld5);//获取指定的对象

在这里插入图片描述

        System.out.println(ld3.equals(ld4));
        System.out.println(ld3.isAfter(ld4));//ld3日期是否在ld4后面
        System.out.println(ld3.isBefore(ld4));

11.2 LocalTime

然后就是LocalTime的使用和LocalDate几乎是一模一样的，getHour，getMinute等等，还有就是这个可以存到纳秒

11.3 LocalDateTime

LocalDateTime就是前面两个的合体，也是差不多的，get，with，isafter
讲一个稍微不同的，就是LocalDateTime可以转换为其他两个，其他两个又可以转化回来

        LocalDateTime ldt=LocalDateTime.now();
        LocalDate ld=ldt.toLocalDate();
        LocalTime lt=ldt.toLocalTime();
        LocalDateTime ldt1=LocalDateTime.of(ld,lt);

11.4 时区时间

ZoneId代表一个时区的id

        ZoneId zoneId=ZoneId.systemDefault();//获取我们这个系统的默认时间
        System.out.println(zoneId.getId());//获取id
        System.out.println(zoneId);

在这里插入图片描述
因为我们与伦敦相差八个小时，所以就是这样，这就是北京时间

        System.out.println(ZoneId.getAvailableZoneIds());//获取Java所支持的全部时区

在这里插入图片描述

        ZoneId zoneId1=ZoneId.of("America/New_York");//这个是把某个时区分装成ZoneId

        ZoneId zoneId1=ZoneId.of("America/New_York");//这个是把某个时区分装成ZoneId
        ZonedDateTime now=ZonedDateTime.now(zoneId1);//这个是把时区时间分装成相应的时间对象
        System.out.println(now);

在这里插入图片描述
可以看出，这个时候，纽约才8点

        ZonedDateTime now1=ZonedDateTime.now(Clock.systemUTC());//这个是获取伦敦的，也就是经度线0的
        System.out.println(now1);

        ZonedDateTime now2=ZonedDateTime.now();
        System.out.println(now2);//这个是获取当前时区的时间的

在这里插入图片描述
然后这个时区时间也可以调用get，with那些方法

还有就是其实原来的Calendar也是可以得到时区的
在这里插入图片描述

11.5 时间戳

获得时间戳精确到纳秒
就是总秒数加上不足1秒的纳秒数

        Instant now=Instant.now();//存储的就是总秒数加纳秒
        long second=now.getEpochSecond();//获得总秒数
        System.out.println(second);

在这里插入图片描述

        int nano=now.getNano();//纳秒数
        System.out.println(nano);

        Instant now=Instant.now();//存储的就是总秒数加纳秒
        long second=now.getEpochSecond();//获得总秒数
        System.out.println(second);
        int nano=now.getNano();//纳秒数
        System.out.println(nano);
        System.out.println(now);

在这里插入图片描述
后面从小数点开始的就是纳秒数，前面的都是总秒数

       Instant instant=now.plusNanos(111);

加上纳秒并返回

        Instant instant1=Instant.now();
        //代码
        Instant instant2=Instant.now();

这个类的主要作用就是记录自己的函数执行了好久

11.6 格式化器

JDK8之前也有格式化器，但那个是线程不安全的，我们用这个更安全

        DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");//格式化器对象
        //后面的时间就用这个来格式化了
        LocalDateTime now=LocalDateTime.now();
        System.out.println(now);
        
        String rs=formatter.format(now);
        System.out.println(rs);

在这里插入图片描述
注意除了字母，其他的都可以随便变，因为字母有特定含义，比如y表示年，四个y就表示年是四位数

然后就是格式化时间还有其他方式，就是把格式化器作为参数传进去

        String rs2=now.format(formatter);
        System.out.println(rs2);

在这里插入图片描述

然后就是格式化了时间，我们对应就要解析时间

        String date="2024年10月11日 21:09:44";
        LocalDateTime ldt=LocalDateTime.parse(date,formatter);//就是把字符串解析成时间对象，前面是将时间格式化为字符串
        System.out.println(ldt);

在这里插入图片描述

11.7 Period

这个主要是用来计算两个日期相差的天数，月数，年数

        LocalDate start=LocalDate.of(2029,8,10);
        LocalDate end=LocalDate.of(2029,8,15);
        Period period=Period.between(start,end);//这个period对象分装两个日期对象
        System.out.println(period.getDays());//获取相差天数
        System.out.println(period.getMonths());//获取相差月数
        System.out.println(period.getYears());//获取相差年数

在这里插入图片描述

11.8 Duration

算两个时间相差的天数，分钟数，纳秒数等

        LocalDateTime start=LocalDateTime.of(2025,11,11,11,2,2,2);
        LocalDateTime end=LocalDateTime.of(2025,11,11,11,2,5,4);
        Duration duration=Duration.between(start,end);
        System.out.println(duration.toDays());
        System.out.println(duration.toNanos());//纳秒
        System.out.println(duration.toSeconds());//相差秒数

在这里插入图片描述

12. Arrays

12.1 toString

这个是它的静态方法，可以把数组内容转换成字符串
什么类型的数组都可以转换

        int[]arr={1,2,3,4,5,6,7};
        System.out.println(Arrays.toString(arr));

在这里插入图片描述

12.2copyOfRange

        int[]arr2=Arrays.copyOfRange(arr,1,4);
        System.out.println(Arrays.toString(arr2));

在这里插入图片描述

copyOfRange可以把arr的数组下标1~4（左闭右开）的内容拷贝创建一个新数组，并返回

12.3 copyOf

        int[]arr3=Arrays.copyOf(arr,10);
        System.out.println(Arrays.toString(arr3));
        int[]arr4=Arrays.copyOf(arr,3);
        System.out.println(Arrays.toString(arr4));

在这里插入图片描述
这也是一个数组的拷贝，后面那个参数是长度，长度不够，用0，长度太短，有多少拷贝多少

12.4 setAll

在这里插入图片描述

这个是将原数组的内容修改，并保存，第一个参数就是原数组，第二个参数是你修改的方法，其实也是一个匿名对象

        double[]arr5={100,200,300};
        Arrays.setAll(arr5, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                return arr5[value]*0.8;
            }
        });
        System.out.println(Arrays.toString(arr5));

在这里插入图片描述
匿名对象中value其实就是下标，他会慢慢变大的
在这里插入图片描述
这个就是setAll的实现

12.5 sort

        double []arr={99.8,128,100};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

在这里插入图片描述
这个的作用就是排序，排的是升序

但我们如果排的是对象呢

public class Student {
    private String name;
    private double height;
    private int age;
    public Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }
    public Student() {
    }
}

        Student[]arr=new Student[4];
        arr[0]=new Student("aaaa",169.5,23);
        arr[1]=new Student("bbbb",163.8,26);
        arr[2]=new Student("bbbb",163.8,26);
        arr[3]=new Student("cccc",167.5,24);
        Arrays.sort(arr);

在这里插入图片描述
我们可以看出，直接对对象排序肯定是不行的，所以下面我们来讲两个方法

12.6 实现Comparable接口

public class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int age;
    public Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }
    public Student() {
    }

    @Override
    public int compareTo(Student o) {
        return 0;
    }
}

意思就是我们用要比较的类去实现一个Comparable接口，然后重写compareTo，这个方法就是我们的比较规则
在这里插入图片描述
然后就是这个Comparable也是一个泛型，类型就是我们要比较的类型
然后compareTo比较的就是this和o

一般有三个约定
左边对象大于右边，返回正整数
左边对象小于右边，返回负整数
左边对象等于右边，返回0

如果严格按照这个要求来，那么返回的就是升序的
如果要实现降序的，把逻辑反过来就可以了，接下来我们讲的都是升序

public class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int age;
    public Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }
    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照年龄来排序
        if(this.age>o.age){
            return 1;
        }else if(this.age<o.age){
            return -1;
        }else {
            return 0;
        }
    }
}

在这里插入图片描述
其实上面的逻辑可以更简单点

    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }

12.7 传入比较器对象

在这里插入图片描述
其实sort不止可以传一个参数，它被重载了的，可以传两个参数，第二个参数就是比较器

这个比较器就是Comparator的匿名内部类对象，然后自己定义比较方法

        Arrays.sort(arr, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return 0;
            }
        });

//我们在Student这个类里面增加一些函数
    public String getName() {
        return name;
    }

    public double getHeight() {
        return height;
    }

    public int getAge() {
        return age;
    }

Comparator也是一个泛型，类型就是我们要比较的类型
然后规则就是上面的规则
这里我们比较身高
在这里插入图片描述
首先不能这样写
因为返回的是整型
也不能强转，因为0.1这种就被强转为0了

只能自己乖乖的比较

        Arrays.sort(arr, 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;
                }else {
                    return 0;
                }
            }
        });

在这里插入图片描述

        Arrays.sort(arr, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });

我们也可以这样写
在这里插入图片描述
这个方法的实现也是和我们原来写的是一样的

总结

下一节我们继续讲Java的相关知识，从lambda开始讲

曾经的三心草
关注
Java的API帮助文档
人生得意须尽欢
01-17 2万+
JDK帮助文档 SUN公司为JDK工具包提供了一整套文档资料,我们习惯上称之为JDK文档。 JDK文档中提供了Java中的各种技术的详细资料,以及JDK中提供的各种类的帮助说明。 JDk文档是Java语言的完整说明,大多数书籍中的类的介绍都要参照它来完成,它是编程者经常查阅的资料 如何理解API：就当做是一个“字典”，“使用手册”，API就相当于是一个电子的帮助文档，可以帮我们查看JDK提供的类的信息，平时查看的时候可结合百度一起看。 官网下载： 1、登录Oracle官网（Oracl.
java api是什么_JAVA_API概述
weixin_34194520的博客
02-12 4902
static关键字学习目标能够明确API使用的步骤能够使用Scanner类获取键盘录入数据能够使用Random类生成随机数能够使用数组存储自定义类型并且遍历能够使用ArrayList集合的构造方法创建ArrayList集合对象能够使用ArrayList集合存储数据能够使用ArrayList集合中的常用方法能够使用ArrayList集合中存储字符串并遍历能够使用ArrayList集合存储自定义的对象...
Java之API的使用
q66562636的博客
04-02 1万+
1.API 1.1API概述 什么是API API (Application Programming Interface) ：应用程序编程接口 java中的API 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。 1.2API帮助文档的具体使用 ​打开帮助文档​​ ​​找到索引选项卡中的输入框​​ ​​在输入框中输入Random​
下载Java API文档
weixin_44538361的博客
08-03 2257
下载Java api文档
Java_API文档
热门推荐
weixin_49667274的博客
02-26 1万+
简单深刻了解Java_API文档
JAVA中的API文档
qq_28623001的博客
10-23 3604
直译：应用程序 编程 接口意义： 各种工具就是所有工具的说明书（使用方法）#注：API文档中【已弃用】代表：当前此方法不推荐使用，请寻找替代方案。若实在无替代方案情况下，可以使用。
java堆栈队列api
wcy1034036507的博客
05-06 1298
java堆栈队列api栈队列链表实现 栈 Stack<Integer> stack = new Stack<>(); // 新建堆栈 stack.push(1); // 向栈顶压入元素 stack.pop(); // 从栈中弹出栈顶元素 stack.peek(); // 查看栈顶元素不弹出 stack.empty(); // 判断是否是空栈 stack.search(2); // 查找某个值是否在栈中，如果存在，返回对象在此堆栈上的从1开始的位置。栈顶元素为对象时，返回1。若不存在
java访问api接口
llyyds0902的博客
03-15 5124
最近有个需求是从别人的接口拿数据然后存入数据库，话不多说直接上代码。 首先拿到别人的接口文档，看访问形式然后在postman上尝试访问能不能获取。 能获取后就在后端代码中实现 public String getJob(){ String s2 = "你的token"; String json = "{\"status\":1,\"startTime\":\"2021-03-11T16:51:24\",\"endTime\":\"2120-02-16T17:.
java webapi_java 调用接口webapi
weixin_36314050的博客
02-12 3020
原理：实现get post 请求package com.dataMonitor.bo.common;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.util.HashMap;import ...
java Compiler API (java编译api)
长河的博客
05-23 1万+
在早期的版本中(Java SE5及以前版本)中只能通过tools.jar中的com.sun.tools.javac包来调用Java编译器，但由于tools.jar不是标准的Java库，在使用时必须要设置这个jar的路径。而在Java SE6中为我们提供了标准的包来操作Java编译器，这就是javax.tools包。 编译java文件 使用Java API来编译Java源代码有非常多方法，目前让...
JAVA_API1.6文档（中文）
04-12
本文档是 Java 2 Platform Standard Edition 6.0 的 API 规范。 请参见： 描述 Java 2 Platform 软件包 java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。 java.awt 包含...
binance-java-api:binance-java-api是Binance API的轻量级Java库，支持同步和异步请求以及使用WebSockets进行的事件流传输
05-23
Java Binance API binance-java-api是一个轻量级的Java库，用于与进行交互，提供完整的API覆盖，并支持同步和异步请求以及使用WebSockets进行的事件流传输。 注意：该项目赢得了Java语言的，因此，此存储库已被...
redmine-java-api:Redmine Java API
05-14
Redmine / Chiliproject Java API。 使用Redmine的REST API（不要忘记在Redmine服务器设置中启用它）。 不需要在Redmine / Chiliproject服务器上安装任何插件。 需要JVM 11或更高版本。 支持HTTP代理 支持来自...
java1.8api文档中文版
03-02
archjdk1.8_сп╣ю.CHM
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1286
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 381
JDK1.0主要特性。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 782
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 608
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1134
2024最新Java面试题，针对一些小厂，中厂
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值