java第五章(API)-CSDN博客

本文链接：https://blog.csdn.net/2302_76759730/article/details/136254860

API（Application Programming Interface）应用程序编程接口

API：指的是官方给开发人员提供的一个说明文档，对语言有哪些类，类中有哪些方法进行说明

Object类

java.lang.ObjectObject类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都继承实现这个类的方法

1.toString方法

/*输出一个对象，但是对象在内存中存储，是不能输出的，
当输出一个对象时，会默认调用此对象的toString（）；
如果类中没有定义toString（）；会调用object类中toString（）；
object类中toString（）；是把对象在内存的哈希值返回（16进制）
我们自己类中可以对object类中toString（）；进行重写，后面调用时调用我们自己的toString（）；*/
//人类
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//-------------------------------------------------------------
//测试类
public class Test_Person {
    public static void main(String[] args) {
        Person p1=new Person("大王",18);
        System.out.println(p1);
    }
}

2.equals（比较）

//测试类
public class Test_person2 {
    public static void main(String[] args) {

        /*
        * == 比较等号两边是否相等
        * 当==用于基本类型比较时，比的是变量是否相等
        * 而用于引用类型时，比的是两个对象地址是否相等
        * */

        /*boolean equals(Object obj)判断两个对象是否相等
        * object类中的equals
        *     public boolean equals(Object obj){
        *            return (this==obj);//默认比较的是两个对象的地址是否相等，我们就可以使用==代替
        *        }
        *
        * 在其他类中，一般重写了equals（）；把他改造为比较对象中的内容是否相等
        * */
        Person p1=new Person("ww",18);
        Person p2=new Person("ww",18);
        System.out.println(p1==p2);//比较地址，一定为false
        System.out.println(p1.equals(p2));//false ，但是在Person中重写equals，比较的是对象中的内容后变为ture
    }
}
//-------------------------------------------------------
//人类
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj){
        if (obj instanceof Person){
            Person other=(Person) obj;
            return name.equals(other.name)&& age==other.age;
        }
            return false;
    }
}

Arrays类（java.until.Arrays）

1.equals方法（比较数组）

2.copyOf方法（数组复制）

3.fill()方法（指定值充满数组）

4.toString方法

5.sort方法(对指定数组进行升序排序)

6.binarySearch 二分方法（查找指定元素位置）

//一
public class Arrays1 {
    public static void main(String[] args) {
        /*
        * 比较两个数组内容是否相等
        * */
        int[] a={1,2,3,4};
        int[] b={1,2,3,4};
        System.out.println(Arrays.equals(a,b));
//二----------------------------------------------------------
        /*
        * copyOf 数组复制
        *    将原数组内容复制到一个指定长度的新数组中
        * */
         int[] c=new int[5];
         c[0]=1;
         c[1]=1;
         c[2]=1;
         c[3]=1;
         c[4]=1;
         int[] d=Arrays.copyOf(c,10);
        System.out.println(Arrays.toString(d));
//三--------------------------------------------------------
        /*
        * fill()   用指定的值将指定数组的每个元素填充
        * */
        int[] e={1,2,3};
        Arrays.fill(e,0);
        System.out.println(Arrays.toString(e));
//四--------------------------------------------------------
        //toString() 将数组中的元素内容拼接为一个字符串输出
//五-------------------------------------------------------
       /*
        * sort()  对指定数组进行升序排序
        * */
        int[] f={3,1,2,9,1,2};
        Arrays.sort(f);
        System.out.println(Arrays.toString(f));

        int[] g={3,1,2,9,1,2};
        Arrays.sort(g,0,3);//指定区间排序
        System.out.println(Arrays.toString(f));
//六-------------------------------------------------------
       /*
        * binarySearch(); 二分查找指定元素位置，如果每找到，则返回-1
        * 二分查找前得先排序
        */
        int[] h={2,3,4,1,5};
        Arrays.sort(h);
        int index=Arrays.binarySearch(h,2);//kay是位置，即索引
        System.out.println(index);
    }
}

7.compareTo（对类进行排序）

public class Student implements Comparable<Student>{
/*
* 我们一个类要进行排序，那么这个类必须实现Comparable接口，指定一个排序的方法（这样所有的类都可以进行排序）
 */
    private String name;
    private int id;
    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
    /*
    * 用来指定排序规则
    * 可以执行用类中的那个数学系作为排序的项
    * 这个方法在sort（）方法的底层逻辑
    * */
   @Override
    public int compareTo(Student o) {
        return this.id-o.id;//int排序（升序）
      //return o.id- this.id;（降序）
    }
}

//------------------------------------------------
public class Arrays2 {
    public static void main(String[] args) {

        Student s1=new Student("章1",1);
        Student s2=new Student("章2",2);
        Student s3=new Student("章3",3);
        Student s4=new Student("章4",4);
        Student s5=new Student("章5",5);

        Student students[]=new Student[5];
        students[0]=s3;
        students[1]=s4;
        students[2]=s1;
        students[3]=s5;
        students[4]=s2;

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

基本类型包装类

基本数据类型不面向对象

* java中基本数据类型使用8个关键字声明的，不是面向对象的
* int a=10;
* java语言面向对象，可以为每个基本类型定义一个类进行表示
* 这样我们在类中还是保持有一个基本类型变量储存数据；
* 同时还可以提供许多方法对变量进行操作（将十进制转为二进制）

以Integer为例：

public class Integer_deom {
    public static void main(String[] args) {
        Integer a=new Integer(10) ;//构造Integer对象，里面包含着一个基本类型值，用该对象表示一个int值
        Integer b=new Integer(12);
        //静态方法方法
        System.out.println(Integer.toBinaryString(5));
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(9));
        System.out.println(Integer.max(12,13));//13
        System.out.println(Integer.compare(4,6));//两个整数比较大小  结果为1  0  -1
        //非静态方法
        System.out.println(a.equals(b));//false
        System.out.println(a.compareTo(b));//-1 即 a<b
        //转换方法  包装类型转基本类型
        int aa=a.intValue();
        int bb=Integer.parseInt("28");
        //         基本类型转为包装类型
        int c=10;
        Integer cc=new Integer(c);
        Integer dd=Integer.valueOf(cc);
    }
}

自动拆箱（把引用类型转为基本类型）

自动装箱（把基本类型转为引用类型）

public class Integer_Deom2 {
    public static void main(String[] args) {

        //自动拆箱：把引用类型 转为 基本类型
        Integer a= new Integer(10);
        //int d=a.intValue();
        int d=a;// 会默认自动调用为intValue（）；方法
//---------------------------------------------------------
        //自动装箱：把基本类型 转为 引用类型
        //注意：自动装箱时，会默认自动调用valueOf()方法
        //在valOf()中 如果基本类型值在-128——127之间，会从缓存数组中直接取出一个Integer对象，减少创建次数
        //如果两个值相同，获取的是同一个对象，
        //基本类型值如果不在-128——127区间，每次都船舰一个新Integer对象返回
        int x=10;
        Integer y=x;//相当于Integer y=Integer.valueOf(x); 会默认调用valueof();方法
        Integer z=x;
        System.out.println(y==z);//x=10ture  x=128 false
        System.out.println(y.equals(z));//ture 比较值时推荐使用equals();方法
    }
}

String类

public class String1 {
    public static void main(String[] args) {
        /*
        * java.long.String
        *   java中所有字符串都是此类的实例
        *   "abc"——>字符中对象  底层时一个char数组public  final  char value[]
        * 字符串对象创建方式：
        * 1.String s="abc"
        *    创建时，先去字符串常量池中去查找有没有相同值的对象，如果没有，就创建一个字符串对象，并返回地址
        *    如果字符串常量中已经储存，不用创建新的，直接返回已存在对象地址
        * 2.String s1= new Sring("abc");
        *    new每次都新建一个对象
        * */
        //两种创建方式区别（内存上）
        String s="abc";
        String ss="abc";
        System.out.println(s==ss);//true

        String s1=new String("abc");
        String s2=new String("abc");
        System.out.println(s1==s2);//false
        System.out.println(s1.equals(s2));//true
    }
}

    public class String2 {
        public static void main(String[] args) {
            //字符串不变；他们的值在创建后不能更改
            String s="abc";//第一个字符串对象 abc
            s+="def";//第二个字符串对象 abcdef
            s+="ghi";//第三个字符串对象 abcdefghi
            System.out.println(s);//abcdefghi
        }
    }



String类的方法：

构造方法

  public static void main(String[] args) {
        /*
        * 构造方法：
        * String
        * String(String s)
        * String(byte[] bytes)  把字节数组 转为 字符串
        * String(char[] chars)  把字符数组 转为 字符串
        * */
        String s1=new String();
        String s2=new  String("abc");

        String s3="你好";
        byte[] bytes=s3.getBytes(/*放指定编码 eg：GBK*/);//编码 ；把字符 转为 字节数组（数字）
        System.out.println(Arrays.toString(bytes));//字节
        String s4=new String(bytes/*,"GBK"*/);//解码 ；把字节数组 转为 字符
        System.out.println(s4);//你好

        String s5="cba";
        char [] chars=s5.toCharArray();//字符串转为字符数组
        Arrays.sort(chars);//排序
        String s6=new String(chars);//将字符数组转为字符串
        System.out.println(s6);//abc
    }
}

判断功能：

public class String4 {
    public static void main(String[] args) {
        String s1=new String("abcde");
        String s2=new String("abcdD");

        //boolean equals(Object obj)  比较字符对象中内容是否相等
        System.out.println(s1.equals(s2));

        //boolean equalsIgnoreCase(String str) 比较字符串对象中内容是否相等中忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));//

        //boolean contains(String str)  判断字符串中是否包含指定子串
        System.out.println(s1.contains("ab"));

        //boolean isEmpty()  判断字符串值是否为""（空）
        String s3=new String("");
        System.out.println(s3.isEmpty());

        //boolean startsWith(String prefix) 判断是否指定字符串开头
        System.out.println(s1.startsWith("ab"));

        //boolean endsWith(String suffix) 判断是否指定字符串结尾
        System.out.println(s1.endsWith("ab"));

获取功能：

public class String5 {
    public static void main(String[] args) {
        //获取功能

        //int length()  获取字符串长度
        String s1="abcdefg";
        System.out.println(s1.length());
        //-------------------------------------------------------------------------------
        //char charAt(int index)  获取指定位置上的字符
        for (int i=0;i<s1.length();i++){
            System.out.println(s1.charAt(i));
        }
        //-------------------------------------------------------------------------------
        // int indexOf(String str)  返回的指定字符串首次出现的位置
        System.out.println(s1.indexOf("c"));
        // int indexOf(String str,int fromIndex)  从指定位置开始查找,返回的指定字符串首次出现的位置
        System.out.println(s1.indexOf("c",4/*位置，即索引*/));
        // int indexOf(String str,int lastIndex)  从后向前
        //-------------------------------------------------------------------------------
        // String substring(int start)  从指定位置开始截取一个字符串副本到结束
         String s2=s1.substring(3);
         System.out.println(s1);//abcdefg
         System.out.println(s2);//defg

        // String substring(int start,int end)  从指定位置开始截取一个字符串副本到另一个位置(不包含结尾)
        String s3=s1.substring(0,3);//abcdefg
        System.out.println(s3);//abc

    }
}

转换功能:

public class String6 {
    public static void main(String[] args) {
       // 转换功能:

        //byte[] getBytes()  把字符 转为 字节数组（数字）
        //char[] toCharArray()  把字节数组 转为 字符数组

        //------------------------------------------------------------------------
        //static String valueOf(char[] chs)  将传入的参数转换为字符串类型
        String  s=String.valueOf(10);
        System.out.println(s);//10
        //System.out.println(s.charAt(1));//0
        //int a=Integer.parseInt(s);//== int a=10 == int a=Integer.valueOf(10);
        String s1=String.valueOf("abc".toCharArray());
        System.out.println(s1);
        //------------------------------------------------------------------------
        //String toLowerCase()  将英文字母转为小写
        String s2="abcdEFG";
        System.out.println(s2.toLowerCase());
        //String toUpperCase()将英文字母转为大写
        System.out.println(s2.toUpperCase());
        //------------------------------------------------------------------------
        //String concat(String str)  拼接指定的字符串内容到原字符串末尾，并返回一个新字符串对象
        String s3=s2.concat("aaa");//s2+="aaa"
        System.out.println(s3);
        //------------------------------------------------------------------------
        //Stirng[] split(分割符);   将一个字符串用指定的分割符号拆分成一个字符串数组
        String s4="ab;c;de";
        String[] SPLT=s4.split(";");
        System.out.println(Arrays.toString(SPLT));

    }
}

替换功能

public class String7 {
    public static void main(String[] args) {
        //替换功能

        //String replace(char old,char new)  用新内容替换字符串中指定的字符串
        //String replace(String old,String new)
        String s="    abcc2def3g   ";
        System.out.println(s.replace("c","C"));
        //--------------------------------------------------------------------------
        //replaceAll(String regex, String replacement) 用新内容替换字符串中正则表达式匹配的字符串
        System.out.println(s.replaceAll("\\d","C"));
        //replaceFirst(String regex, String replacement  用新内容替换字符串中正则表达式匹配的字符串,只替换第一个
        System.out.println(s.replaceFirst("\\d","C"));
        //------------------------------------------------------------------------------------------
        //去除字符串 两端 空格
        //String trim()
        System.out.println(s.trim());

    }
}

StringBuffer类

public class StringBuffer1 {
    public static void main(String[] args) {
        //因为String 声明的字符串中对象一旦给定就不能改变长度了，每次拼接都会创建新的字符串对象，耗时，占空间
        //StringBuffer 是内容可以改变的字符串
        //   char[] value; 没有使用final修饰，每次添加内容都是对此数组进行操作，不会创建新的字符串对象
        StringBuffer s1=new StringBuffer("abcd");//创建了一个内容+16的char数组  20
                     s1.append("efg");

        StringBuffer s2=new StringBuffer();//空参的构造方法，指定底层数组长度为16
        StringBuffer s3=new StringBuffer(10);//指定数组容量
        //添加功能
                     s3.append("abc");//向字符串末尾添加内容
                     s3.append("tyu");
        //插入功能
                     s3.insert(1,"A");//向指定位置上插入指定字符串
        //删除功能
                     s3.deleteCharAt(5);//删除指定位置元素
                     s3.delete(1,3);//删除指定区间元素，包含开头不包含结尾
        //替换功能
                     s3.replace(0,3,"B");//替换区间字符串
        //反转功能
                     s3.reverse();//反转字符串，使其逆序
        //
        String s4=s3.substring(0,5);//截取字符串，从StringBuffer中截取一个字符

    }
}

StringBuilder类

基本用法与StringBuffer相同

String StringBuffer StringBuilder用法区别：

String: 是一个值不可以改变的字符串
StringBuffer:值可以改变且不需要创建新对象，方法上都加了锁，是在多线程(任务)执行时是线程安全的

StringBuilder: 值可以改变且不需要创建新对象，由于方法上都没有加锁,在多线程(任务)执行时是线程不安全的，适合单线程

正则表达式

* 正则表达式（Regular Expression，简称regex）
* 正则表达式是一种规则（模式）匹配语法，
* 可以使他一些正则表达式中定义的特殊符号来定义一种规则，然后用此规则去匹配某个字符中，
* 如果字符串与规则和匹配返回ture

* 验证一个字符串是否是中国大陆地区手机号格式
* System.out.println(s1.matches("1[357]\\d{9}"));
* 长度11 开头为1 判断第二位判断之后的每位是数字
* 可以使用正则表达式，定义一个规则去匹配即可

        String s1="12425";
        System.out.println(s1.matches("b"));
        System.out.println(s1.matches("[0-9]"));
        System.out.println(s1.matches("[0-9]*"));  //[0-9]* 允许出现日次或多改数字
        System.out.println(s1.matches("[0-9]+"));  //[0-9]+ 允许出现至少1次或多改数字
        System.out.println(s1.matches("[0-9]{3}"));  //[0-9]{3} 只能是n次(3)
        System.out.println(s1.matches("[0-9]{3,}")); // [0-9]{3,}至少n次
        System.out.println(s1.matches("[0-9]{3,6}"));  //[0-9]{3,6} 至如次 不人于m战
        System.out.println(s1.matches("\\d[3-9]"));//  \d ==[0-9] 匹配数字   \D匹配非数字
//----------------------------------------------------------
        String s="aifHsdf_123";
        System.out.println(s.matches("[0-9A-z]*"));// \w==[0-9A-z]    允许出现大小写和数字和_
//-----------------------------------------------------------
        String s3="sdasd5616";
        //邮箱格式  xxxxx@xx.com    com.cn
        System.out.println(s.matches("\\w{6,10}@\\w{2,5}\\.(com|com\\.cn)"));

Match类

提供了一系列静态方法用于科学计算

 //abs 绝对值
    //sqrt 平方根
    //pow(double a, double b) a的b次幂
    //max(double a, double b)
    //min(double a, double b)
    //random() 返回 0.0 到 1.0 的随机数
    //long round(double a) double型的数据a转换为long型（四舍五入）
    //floor()向下取整
    //ceil()向上取整
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-3));
        System.out.println(Math.sqrt(4));
        System.out.println(Math.pow(2,3));
        System.out.println(Math.floor(9.9));//向下取整
        System.out.println(Math.ceil(9.1));//向上取整
        System.out.println(Math.max(0,9));//取两数最大值
        System.out.println(Math.min(0,9));//取两数最小值
        System.out.println(Math.random());//返回 0.0 到 1.0 的随机数
        System.out.println(Math.round(3.4));//四舍五入
    }
}

Random类

此类用于产生随机数

public class Random_deom {
// Random类机
//构造方法
//public Random()
// 成员方法
//public int nextInt()
//public int nextInt(int n)
public static void main(String[] args) {
    Random random=new Random();
    System.out.println(random.nextBoolean());
    System.out.println(random.nextInt());//在int取值范围内，随机返回一个整数
    System.out.println(random.nextInt(9));//在给定范围内随机获取一个数（n-1）

    byte[] bytes=new byte[5];
    random.nextBytes(bytes);
    System.out.println(Arrays.toString(bytes));//随机取出数组长度个byte类型随机数
}
}

BigInteger类

import java.math.BigInteger;

public class BigInteger_Test {
    public static void main(String[] args) {
        BigInteger bigInteger1 = new BigInteger("11111111111111111111111111111111111111111111111111111111");
        BigInteger bigInteger2 = new BigInteger("99999999999999999999999999999999999999999999999999999999");

        BigInteger bigInteger3 = bigInteger1.multiply(bigInteger2);
        BigInteger bigInteger6 = bigInteger1.divide(bigInteger2);
        BigInteger bigInteger5 = bigInteger1.subtract(bigInteger2);
        BigInteger bigInteger4 = bigInteger1.add(bigInteger2);

        System.out.println(bigInteger3);
        System.out.println(bigInteger4);
        System.out.println(bigInteger5);
        System.out.println(bigInteger6);
    }
}

BigDecimal类

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

public class BigDecimal_Test {
    public static void main(String[] args) {

        BigDecimal bigDecimal = new BigDecimal(0.1);
        BigDecimal bigDecima2 = new BigDecimal(0.2);

        BigDecimal bigDecima3 = bigDecimal.multiply(bigDecima2);
        BigDecimal bigDecima6 = bigDecimal.divide(bigDecima2);
        BigDecimal bigDecima4 = bigDecimal.subtract(bigDecima2);
        BigDecimal bigDecima5 = bigDecimal.add(bigDecima2);

        System.out.println(bigDecima3);
        System.out.println(bigDecima4);
        System.out.println(bigDecima5);
        System.out.println(bigDecima6);
    }
}

Date类

import java.util.Date;

public class Date_deom {
    public static void main(String[] args) {
        Date date=new Date();//获取程序运行的时间
        System.out.println(date.getYear()+1900);//  方法上有删除线表示方法已弃用，有新的类代替，但也是可以用的


        //获取的是从1970.1.1 0：0：0  至程序运行时刻的毫秒值
        System.out.println(date.getTime());//1708843591404 时间戳


        Date date1=new Date(16516456146l);//超出int的范围后面得加 l
        System.out.println(date1);

        //测试效率
        System.out.println(date.getTime()-date1.getTime());
    }
}

SimpleDateFormat类

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

public class SimpleDateFormat_deom {
    public static void main(String[] args) throws ParseException {
        /*
        * 字符串日期转为Date对象
        * */
        String s="2024-2-25";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date date=sdf.parse(s);

        System.out.println(date.getYear()+1900);
        System.out.println(date);

        /*
        * 把日期转为指定格式字符串
        * */
        Date date1=new Date();
        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");//把日期转为指定格式字符串
        String s1=sdf1.format(date1);
        System.out.println(s1);
    }
}

Calendar类

import java.util.Calendar;

public class Calender_Test {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //日历
        //System.out.println(calendar);

        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH) + 1);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));
        System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));

        Calendar calendar1 = Calendar.getInstance();

        //有参构造
        calendar1.set(2024,2,25);

        //获取自1970.1.1  0:0:0 到此Calendar的毫秒值。
        System.out.println(calendar1.getTimeInMillis());//1711350767288
    }
}