Java笔记——Java API_javaapi

最新推荐文章于 2025-02-05 14:29:19 发布

原创最新推荐文章于 2025-02-05 14:29:19 发布 · 938 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#java #笔记 #python

一.JavaAPI的概述

JavaAPI：(Application Programming Interface)应用程序编程接口。

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。

二.Object类的介绍

2.1Object 类的简介

Object类是整个java类中最顶级的一个类，是所有Java类的父类（超类），所有的对象都继承这个类的方法。

在创建类的时候，没有刻意强调写出extends所继承的类，就会默认继承Object类。

例：

public class run{

Java代码块；
}

在这个示例中，没有写出此类具体继承哪个类，但实际上默认继承了Object类，如下代码：

public class run extends Object{

Java代码块；
}

这个继承Object类，平时是不用写的，Java会默认继承。

2.2roString类

在直接输出创建的对象时，会默认调用类中的toString（），默认输出的是对象的hashCode（）值（十进制数）。

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

Object类中有默认的toString方法，但是如果不能满足用户的需求，就可以对此方法进行重写，可以指定toString的格式，以实现用户的需求。

例如：

下面代码中的name和age都是用户自己提前自己定义的，你在用此方法时，就会按照Object类中的toString方法的默认格式输出。

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

2.3Equals方法

在Object类中，定义的equals方法为：

public boolean equals(Object obj) {
return (this == obj);
}

由此代码就可以看出，在Object类中的equals方法，比较的还是比较双方的对象地址是否相同，使用的任然是“==”。

而在String类中，就对equals方法进行了重写，比较的就是内容。

注意：在其他类中如果想比较的是对象的内容是否想同，就必须对equals方法进行重写。

三.Array类

3.1Array类中的equals方法

由于Array类中对equals方法进行了重写，因此比较的是对象的内容是否相同。

public class ArrayEqualsPractice {
    public static void main(String[] args) {
        int [] a ={1,2,4,5};
        int [] b ={1,2,4,5};
        System.out.println(a.equals(b));//此处比较的仍然是地址
        System.out.println(Arrays.equals(a,b));//Array类中对equals重写了，比较的是内容
    }
}

输出为：

在这里插入图片描述

?3.2Array类中的sort方法

sort方法的简介：就是对数组内容进行排序，主要是基本类型的排序。

public class ArrayEqualsPractice {
    public static void main(String[] args) {
        int [] a = {3,1,7,5,4};
        char [] b = {'a','c','e','b','z','f'};
        String [] c = {"banana","apple","pear","jim"};
        Arrays.sort(a);
        Arrays.sort(b);
        Arrays.sort(c);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        System.out.println(Arrays.toString(c));
    }
}

在此代码中，对a,b,c三个数组进行了排序。

输出结果为：

在这里插入图片描述
排序还可以通过继承Complare，创建complateTo方法进行排序。

package com.ffyc.javaaapi.arraydome;

public class Practice implements Comparable<Practice>{
    private int age;
    private String name;
//toString方法，可自定义输出格式
 @Override
    public String toString() {
        return "Practice{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
//对创建对象的年龄进行排序，大的在后，小的在前，想反一下，就把this和o的位置换一下
    @Override
    public int compareTo(Practice o) {
        return this.getAge()-o.getAge();
    }
}

在此类中，对创建的对象年龄进行了比较排序，比较的内容是自定义的，可根据实际情况进行排序。

在具体的使用时：

public class ArrayEqualsPractice {
    public static void main(String[] args) {
        Practice p1 = new Practice(18,"jim");
        Practice p2 = new Practice(12,"tom");
        Practice p3 = new Practice(19,"tim");
        Practice [] p = {p1,p2,p3};
        Arrays.sort(p);
        System.out.println(Arrays.toString(p));
    }
}

将创建好的对象存放到数组中进行排序，输出时可以通过for循环遍历输出，也可以通过数组直接进行输出。

3.3binarySearch()方法

binarySearch()方法的简介：使用二分搜索算法搜索指定数组

public class ArrayEqualsPractice {
    public static void main(String[] args) {
         int [] a ={1,2,4,5};
        int b = Arrays.binarySearch(a,2);
        System.out.println(b);
    }
}

想要查找数组中的某个元素是否存在，但查找的数组必须是有序的，不是有序的可以通过过sort方
法进行排序。

此方法返回的是int型，若存在，返回正数，不存在，返回负数。

3.4copyof方法

copyof简介：

数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回新数组。

具体使用如下示例：

public class ArrayEqualsPractice {
    public static void main(String[] args) {
        int [] a ={1,2,4,5};
        int [] b = Arrays.copyOf(a,a.length*2);
        System.out.println(Arrays.toString(b));
    }
}

输出的结果为：

[1, 2, 4, 5, 0, 0, 0, 0]

此方法就是把原来的数组的值赋值给新的数组，并扩容，长度由用户自己定。

3.5fill方法

fill简介：将指定的int值分配给指定的int数组的每个元素。

具体使用如下：

public class ArrayEqualsPractice {
    public static void main(String[] args) {
        int [] a ={1,2,4,5};
        Arrays.fill(a,3);
        System.out.println(Arrays.toString(a));
    }
}

结果为：[3, 3, 3, 3]

四.基本数据类型包装类

4.1基本数据类型包装类的简介

Java中的基本数据类型是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基本数据类型对应的类统称为包装类.

包装类：这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

基本类型的包装类以最常用的int类的包装类为例:

4.2Integer类的具体方法：

public static final int MAX_VALUE 最大的int型数
public static final int MIN_VALUE 最小的int型数

也可以直接输出：

System.out.print(Integer.Max_Value);
//此时输出的就是int类型的最大值

Integer中的方法有很多，常用的有以下这些：

Integer.BYTES：这可以输出int类型的字节长度

Integer.SiZE:输出的是int类的比特位

Integer.toBinaryString(n)：输出的是n的二进制数

Integer.toOctalString（n）：输出的是n的八进制数

Integer.toHexString（n）：输出的是n的十六进制数

Integer.parseInt(“n”) :将字符串型转换成整数型

Integer i = Integer.valueOf（“15”）：把基本类型转换成包装类型

Integer.max（n，m）；比较两个数字之间的大小，返回较大的那个

Ingeter.min（n，m）：比较两个数字之间那个是较小的并返回

具体示例如下：

public class IntegerTest {
    public static void main(String[] args) {
        Integer integer1 = new Integer(2);
        System.out.println(integer1);
        System.out.println(Integer.MAX_VALUE);//输出Int类型最大值
        System.out.println(Integer.MIN_VALUE);//最小值
        System.out.println(Integer.BYTES);//int的字节长度
        System.out.println(Integer.SIZE);//int比特位
        System.out.println(Integer.toBinaryString(8));//二进制
        System.out.println(Integer.toOctalString(8));//八进制
        System.out.println(Integer.toHexString(8));//16进制
        int c = Integer.parseInt("10");//将字符串型转换为整数型
        System.out.println(c);
        Integer d = Integer.valueOf("15");//把基本类型转换成包装类型
        System.out.println(d);
        Integer e = Integer.valueOf(8);//把字符串类型转换成包装类型
        System.out.println(e);
        int f = Integer.max(8,5);//比大小
        System.out.println(f);
        int g = Integer.min(7,4);
        System.out.println(g);
//通过构造方法,将字符串数字,基本类型值,包装到一个包装类对象中,使用面向对象方式进行操作
        Integer integer = new Integer(10);
        System.out.println(integer);
        Integer integer2 = new Integer("10");
        System.out.println(integer2);
        System.out.println(integer==integer2);//比较的是地址
        System.out.println(integer.equals(integer2));//比较的是内容
        System.out.println(integer.compareTo(integer1));//比较的是大小，大：1  相等：0  小：-1
        int a =  integer.intValue(); //返回的是包装类型中的原始基本值
        long b =  integer.longValue( );
    }
}

结果如下：

2
2147483647
-2147483648
4
32
1000
10
8
10
15
8
8
4
10
10
false
true
1

4.3基本类型的装箱与拆箱

自动装箱：基本数据类型转换成包装类型

把基本数据类型直接赋给引用类型时，进行包装产生了一个Ingeter类的对象。

int a = 10;
Ingeter i = a;
//相当于是
//Ingeter i = new Ingeter（a）;
//也可以是Ingeter i= Ingeter。valueOf（a）;

自动拆箱：把包装类型转换成基本类型

Ingeter i = new Ingeter(10);
int i1 = i;

拆箱时，默认调用n.intValue（），去除其中的int值，隐式的。

包装类型直接转换成基本类型为：

int b = i.intValue();

注意：

Ingeter i1-= 127；
Ingeter i2 = 127；
System.out.println(i1==i2);
-->true

在Ingeter类中，为节省空间，对-128~+127之间256个对象进行缓存数组，在此范围内的值，直接从数组中获取，创建的对象之间获取的地址是相同的，因此输出为True。若不是，则会创建一个新的对象，且地址不相同。

五.String类

5.1String类的概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.

5.2String类的创建

String类的创建有两种形式：

第一种：

String s1 = “abc”;

第二种：

String s2 = new String(“abc”);

5.3String类的构造方法

编码：传输时，将字符串转为byte数组

byte [] b1 = "abc".getBytes();

解码：将byte数组转换成字符串

String s3 = new String(b1);

把b2用指定的编码形式进行编码

byte b2 []= "哈喽".getBytes("GBK");

用指定的编码形式进行解码

String s4 = new String(b2,"GBK");

把字符串转换成数组：

char c [] = "dcfgh".toCharArray();

5.4String类中的方法

以String s1 = “abcdecf”为例

String类中的判断

//        判断
        System.out.println(s1.equals("c"));//将字符串s1与equals中的字符串进行比较，内容是否想同
        System.out.println("abC".equalsIgnoreCase(s1));//判断内容是否相同，不区分大小写
        System.out.println(s1.contains("c"));//判断字符串s1中是否包含了字符“c”
        System.out.println(s1.isEmpty());//判断是否是空字符串
        System.out.println(s1.startsWith("ab"));//判断字符串是否是以字符"ab"开头
        System.out.println(s1.endsWith("bc"));//判断字符串是否以字符串“bc”结尾

String类中的获取

//        获取
        System.out.println(s1.length());//字符串长度
        System.out.println(s1.charAt(1));//查找字符串具体位置上的字符
        System.out.println(s1.indexOf("c"));//查找字符“c“在字符串上的位置
        System.out.println(s1.indexOf("c",3));//查找字符，从指定位置开始查找
        System.out.println(s1.lastIndexOf("f"));//从后往前查找指定字符
        System.out.println(s1.substring(5));//截取指定位置之后的字符串
        System.out.println(s1.substring(2,5));//截取指定区间的字符串

String类中的转换

//转换
        byte b [] = s1.getBytes();//转换成byte数组 编码
        System.out.println(b);
        String s2 =new String(b);
        System.out.println(s2);//解码

        char c [] = s1.toCharArray();//将字符串s1转换为char型数组
        System.out.println(Arrays.toString(c));
        String s3 = new String(c);
        System.out.println(s3);

        System.out.println(String.valueOf(c));//char数组转为字符串型

        String s4 = "abcDEFg";
        System.out.println(s4.toLowerCase());//转为小写
        System.out.println(s4.toUpperCase());//转为大写
        s4+="xxx";s4+=888;//+=可以连接任何字符
        System.out.println(s4);
        System.out.println(s4.concat("ab"));//连接字符串

        String s5 = "a:b:c:8";
        String s6 [] = s5.split(":");//去除指定正则表达式
        Arrays.sort(s6);
        System.out.println(Arrays.toString(s6));

String类中的替换

//        替换
        String s7=s1.replace("b","XX");//将原来字符串中的某个字符或者连续字符串进行替换
        System.out.println(s7);
        String s8 = s5.replaceAll(":","+");//将字符串s5中的字符：改变为+
        System.out.println(s8);

5.5StringBuffer和StringBuilder

StringBuffer 的简介：String在拼接字符串的时候，每次都要创建一个新的对象，时间长，还浪费空间。而StringBuffer在做这件事的时候，则可以解决这个问题。

public static void main(String[] args) {

        String s1 = "aa";
        Date date1 = new Date();
        long l1 = date1.getTime();//运行之前的时间
        for (int i = 0; i <=100000; i++) {
            s1+="aa";
        }
        Date date2 = new Date();
        long l2 = date2.getTime();//String结束的时间
        System.out.println("String的拼接时长为"+(l2-l1)+"毫秒");
        StringBuffer s3 = new StringBuffer("aa");
        for (int i = 0; i <=100000; i++) {
            s3.append("aa");
        }
        Date date3 = new Date();
        long l3 = date3.getTime();//StringBuffer结束的时间
        System.out.println("StringBuffer的拼接时长为"+(l3-l2)+"毫秒");
    }

结果为

在这里插入图片描述
从此结果可看出两者之间的差别。

StringBuffer和StringBuilder的方法如下所示：

public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer("abcxxcba");
//        StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
        s1.append("a");//拼接字符串在末尾
        s1.append("a");
        s1.append("a");
        s1.append("a");
        System.out.println(s1);
        s1.insert(2,5);//指定位置添加
        System.out.println(s1);
        s1.deleteCharAt(6);//删除指定位置的字符串
        System.out.println(s1);
        s1.delete(2,5);//删除指定区间
        System.out.println(s1);
        s1.replace(2,3,"hhh");//替换指定区间
        System.out.println(s1);
        s1.reverse();//逆序输出
        System.out.println(s1);
        String s2 = s1.substring(2,5);//substring截取的需要存放在新的字符串对象当中
        System.out.println(s2);
    }

结果如下图所示：

在这里插入图片描述
注意：

String与StringBuffer和StringBuilder之间的区别：

● String：是字符常量,适用于少量的字符串操作的情况
● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

六.Math类

● java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

Math类中的常见方法：

public static void main(String[] args) {
        int i1 = Math.abs(-8);//求绝对值
        System.out.println(i1);
        double i2 = Math.pow(2,3);//2的三次方
        System.out.println(i2);
        double i3 = Math.sqrt(2);//平方根
        System.out.println(i3);
        int i4 = Math.max(5,6);//比大
        System.out.println(i4);
        int i5 = Math.min(4,8);//比小
        System.out.println(i5);
        double i6 = Math.random();//随机一个0-1之间的数
        System.out.println(i6);
        System.out.println(Math.floor(5.9));//向下取整
        System.out.println(Math.ceil(5.1));//向上取整
        System.out.println(Math.round(5.6));//四舍五入
    }

运行结果如下图所示：

在这里插入图片描述
七.Random类

Random类的简介：

此类在运用时，首先要创建一个子类对象，通过子类对象调用Random类中的方法，生成随机数，生成随机数的范围，取决于创建时赋的值。

Random r = new Random();
int i = r.nextInt(5);//此时随机数的范围就是0-5之间，但是不包括5

八.Date类/Calender类/SimpleDateFormat类

Date类可以获取当前的时间。在使用此类之前，需要创建一个对象，此类中的方法通过子类对象调用。

Date date1 = new Date();
        System.out.println(date1.getTime());//输出的是1970.1.1 0：0：0至今的毫秒差
        System.out.println(date1.getYear()+1900);//年份
        System.out.println(date1.getMonth()+1);//月份
        System.out.println(date1.getDate());//日期
        System.out.println(date1.getHours());//小时

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

此类中的常用方法：

//Calender 日历类   具体方法必须在子类对象中实现
        Calendar calendar = new GregorianCalendar();
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//这个月的第几天
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));//这个月的第几周
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));

SimpleDateFormat 日期格式化类

具体常用实现如下：

//SimpleDateFormat 简单日期格式化类  把日期转换成规定格式
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");//首先现规定格式
        String str = s.format(date1);//转换成字符串形式
        System.out.println(str);
        //将字符串类型的日期转换成日期
        String s1 = "2001-1-1";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date2 = simpleDateFormat.parse(s1);
        System.out.println(date2.getYear()+1900);
        String birthdayStr = "2001-1-1";
        SimpleDateFormat simple =  new SimpleDateFormat("yyyy-MM-dd");
        Date date = simple.parse(birthdayStr);
        System.out.println(date.getYear()+1900);

此类中的所有代码运行结果如图所示：

在这里插入图片描述
?九.BigDeimal类和BigIngeter类

public class BigIngeterDemo {
    public static void main(String[] args) {
        //BigIngeter 不看数字大小，计算的时候不可以用+-*/
        BigInteger b1 = new BigInteger("1623716457271846");
        BigInteger b2 = new BigInteger("1623716457271846");
        //计算加减乘除
        BigInteger b3 = b1.add(b2);//加
        System.out.println(b3);
        BigInteger b4 = b1.subtract(b2);//减
        System.out.println(b4);
        BigInteger b5 = b1.multiply(b2);//乘
        System.out.println(b5);
        BigInteger b6 = b1.divide(b2);//除
        System.out.println(b6);
    }
}

在这里插入图片描述
为了解决此类问题，java提供了BigDeimal类来解决此类问题。

如下图所示：

public class BigDeimalDemo {
    public static void main(String[] args) {
        //double，float 浮点数都是无限接近于，都不是整数
        //例如：
        double d1 = 1.0-0.9;
        double d2 = 0.8-0.7;
        System.out.println(d1);
        System.out.println(d2);
        System.out.println(d1==d2);//false

        BigDecimal b1 = new BigDecimal("13421");
        BigDecimal b2 = new BigDecimal("13421");
        System.out.println(b1.add(b2));
        //用法与BigInteger相同
    }
}