第五章(常用API)

object类

java.lang.Object

是java类体系结构中最顶层的类

Object可以表示java中任意的类

toString方法

输出一个对象,但是对象是在内存中存储,是不能输出的

当输出一个对象时,会默认调用此对象的toString方法

如果类中没有定义toString(),会调用Object类中toString()

Object类中toString();是吧对象在内存中的哈希值返回(以16进制返回)

把对象信息以字符串输出

我们自己类中可以重写Object类中的toString()方法,

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
public class Person_Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",30);
        System.out.println(person1.toString());
    }
}

 

equals方法

源码

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

boolean equals(Object obj) 判断两个对象是否相等

/*
*   == 比较等号两边是否相等
*   == 用于基本类型时,比较数值
*   == 用于引用类型时,比较地址
* */
/*
    可以使用==代替他
​
    在其他类中,一般都重写了 equals(Object obj),把他改造为比较对象内容是否相等
​
​
*/

举例

判断两个对象是否相等 

public class Person {
    private String name;
    private String gender;

    public Person() {
    }

    public Person(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }

    //对Object类中对toString方法进行重写
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    //对equals进行重写
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person other=(Person)obj;//强制转换  将Object向下转换为Person
            return name.equals(other.name)&&gender.equals(other.gender);
        }
            return false;
    }


}

Arrays类

equals方法

比较两个数组内容是否相等

copyOf方法

copyOf 数组复制

将数组内容复制到一个指定长度的数组中

fill方法

将指定的int值将指定数组中的每个元素填充

toString方法

将数组中的元素内容拼接成一个字符串输出

public class TwstArrays {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = {1, 2, 3, 4, 5};
        int[] c = {1, 1, 3, 4, 5};

        //equals方法    比较两个数组内容是否相等
        System.out.println(Arrays.equals(a, b));
        System.out.println(Arrays.equals(b, c));

        //copyOf方法  将数组内容复制到一个指定长度的数组中
        int []D=Arrays.copyOf(a, 10);
        System.out.println(Arrays.toString(D));

        //fill方法  将指定的int值将指定数组中的每个元素填充
        Arrays.fill(a,10);

        //toString方法  将数组中的元素内容拼接成一个字符串输出
        System.out.println(Arrays.toString(a));

    }
}

sort方法

sort() 对指定数组进行升序排序

binarySearch方法

binarySearch() 二分查找

二分搜索算法查找指定的元素的位置,找到 返回索引值 ,没找到返回负数,,,,,,前提数组 必须排序

public class Arrays2 {
    public static void main(String[] args) {
            /*
        sort()  对指定数组进行升序排序
    */
        int [] a={9,8,7,4,2};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        int [] b={9,6,4,1,3,2};

        Arrays.sort(b,0,3);
        System.out.println(Arrays.toString(b));

        //binarySearch()  二分搜索算法查找指定的元素的位置,找到返回索引值
        //没找到返回负数,,,,,,前提数组必须排序
        int [] c={9,6,4,5,3,2,1};
        Arrays.sort(c);
        int index=Arrays.binarySearch(c,3);
        System.out.println(index);
    }
}

引用类型排序

/*
    类要进行排序，那么这个类必须要实现Comparable接口
    指定一个排序的接口(所有的类都可以进行排序)
 */

public class Student implements Comparable<Student>{
    String name;
    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) {
        //int排序
        //return this.id - o.id;//小于0  等于0  大于0  升序
        //return o.id - this.id//降序
​
        //String比较
        //return this.name.compareTo(o.name);//小于0  等于0  大于0 
    }
}
​
import java.util.Arrays;
​
public class Arr_Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("王一",1);
        Student s2 = new Student("刘二",2);
        Student s3 = new Student("张三",3);
        Student s4 = new Student("赵四",4);
        Student s5 = new Student("李五",5);
​
        Student students[] = new Student[5];
                students[0] = s3;
                students[1] = s4;
                students[2] = s1;
                students[3] = s5;
                students[4] = s2;
        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
​
        String str1 = "a";
        String str2 = "b";
        System.out.println(str1.compareTo(str2));
    }
}

基本类型包装类

定义

基本数据类型不面向对象，它只是一个关键字，但在实际使用中经常需要把基本类型转换成对象，因次Java为每个基本类型定义了一个类来表示；

用途

作为和基本类型对应的类类型存在；

在包装类中定义着基本数据类型的一系列相关操作以及常用值，例：最大最小值、取最大最小值...

拆箱与装箱

定义

自动拆箱(Auto-boxing)：把引用类型转换为基本类型；

自动装箱((unboxing)：把基本类型转换我引用类型；

 

public class Test {
       /*
    基本类型包装:
        java中基本数据类型使用八个关键字声明,不是面向对象的
        int a=10
        java语言是面向对象的.可以为每个类定义
    */
       public static void main(String[] args) {
           Integer a=new Integer(10);
           Integer b=new Integer("20");
           System.out.println( Integer.compare(a,b));
           System.out.println(Integer.MAX_VALUE);
           System.out.println(Integer.MIN_VALUE);
           System.out.println(Integer.toOctalString(a));
           System.out.println(Integer.toBinaryString(a));
           System.out.println(Integer.toHexString(a));



           /*
                自动拆箱:  把引用类型 转为 基本类型
            */
           int dd=a.intValue();
           int d=a;//自动拆箱 会默认自动的调用 intvalue()方法



           /*
                自动装箱: 把基本类型 转为 引用类型
                    自动装箱时,会默认调用valueOf()方法
                    在valueOf()方法中,如果 基本类型值在 -128~~+127之间
                    会从缓存数组中直接取出一个Integer对象,减少创建次数
                    如果两个值相同,获取同一个对象
                    基本类型值如果不在-128~~+127之间,每次创建一个Integer对象返回
            */
           int x=10;
           Integer yy=Integer.valueOf(x);
           Integer y=x;//自动装箱  会默认调用valueOf()方法
           Integer z=x;
           System.out.println(y==z);// x= 10 true   x=128  false
           System.out.println(y.equals(z));//true



       }

}

String类

java.lang.String
    java中所有字符串都是此实例
    "abc"----->字符串对象  底层是一个char数组 private final char value[]
 字符串对象创建方式:
    1.String s="abc";
        创建时,先去字符串常量池中去查找有没有相同值的对象,如果没有,就创建以个字符串对象,
        并返回地址,如果字符串在常量中已经存储,不用创建新的,直接返回已存在对象的地址;
    2.String s1=new String("abc");
        new 每次都在堆中创建新的字符串对象

String s="abc";
String ss="abc";
System.out.println(s==ss);//两个内容相同,用的同一个地址,所以返回true
System.out.println(s.equals(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
//字符串不变;它的值在创建后不能被改变
String s="abcd"; //abcd   第一个字符串对象
        s+="efg"; //abcdefg 第二个字符串对象
        s+="aaaa"; //abcdefgaaaa 第三个字符串对象
System.out.println(s);

构造方法

构造方法:
     String()
     String(String s)
     String(byte[] byte)
     String(char[] chars)
String s1=new String();
String s2=new String("abc");
​
String s3="你好";
//getBytes()方法
byte [] bytes=s3.getBytes();//编码 把字符串 转为 字节数组(数字)
System.out.println(Arrays.toString(bytes));
​
String s4=new String(bytes);//解码 把字节数组 转为 字符串
System.out.println(s4);
​
String s5="cab";
//通过tocharArray方法将字符串转为char数组
//可以通过数组中的方法对字符串进行操作
char [] chars= s5.toCharArray();
Arrays.sort(chars);
String s6=new String(chars);
System.out.println(s6);

判断方法

boolean equals(Object obj) 比较字符串对象中内容是否相等
boolean equalsIgnoreCase(String str) 比较字符串对象中内容是否相等 忽略大小写
boolean contains(String str) 判断字符串中是否包含指定的子串
boolean isEmpty() 判断字符串值是否为 "" (空串)
boolean startsWith(String prefix) 判断是否以指定的字符串开头
boolean endsWith(String suffix)  判断是否以指定的字符串结尾

获取功能

int length() 获取字符串长度
char charAt(int index) 获取指定位置上的字符
int indexOf(String str) 返回指定字符首次出现的位置
int indexOf(String str,int fromIndex) 从指定的位置开始查找,返回指定字符首次出现的位置
int lastIndexOf("c") 从后往前找,返回指定字符首次出现的位置
int lastIndexOf("c",6) 从指定的位置从后往前找开始查找,返回指定字符首次出现的位置
String substring(int start) 从指定的开始位置开始截取一个字符串副本到完
String substring(int start,int end) 从指定的开始位置开始截取一个字符串副本到指定位置(不包含结束位置)

StringBuffer类

定义

对字符串进行拼接操作，每次都要创建新对象，费时间费空间，StringBuffer类就可以很好解决这个问题

package cmd.ffyc.api.stringdemo.Stringdemo;

public class StringBuffer1 {
    public static void main(String[] args) {
       /*
        因为String声明的字符串值一旦给定就不能改变
        每次拼接都会创建新的字符串对象,耗时,占用空间

        StringBuffer是内容可以改变的字符串
        char[] value; 没有使用final修饰,每次添加都是对此数组进行操作,不会创建新的字符串对象

        */

        StringBuffer s1=new StringBuffer("abcd");
        s1.append("efg");
        System.out.println(s1);

        //无参构造
        StringBuffer s2=new StringBuffer();

        //指定数组容量
        StringBuffer s3=new StringBuffer(10);
        s3.append("ABCDEFGHIJKLMN");//向字符串末尾添加内容
        s3.insert(1,"p");//向指定的位置插入指定的字符串
        s3.deleteCharAt(2);//删除指定位置上的字符
        s3.delete(0,3);//删除指定区间的元素,包含开始,不包含结尾
        s3.replace(0,3,"A");//将指定区间的字符串替换为指定的字符串
        s3.reverse();//反转字符串
        String s4= s3.substring(0,1);//截取字符串,从StringBuffer
        System.out.println(s3);
        System.out.println(s4);
    }
}

StringBuilder类

该类使用方法StringBuffer没有差异，StringBuffer仅多一个权限修饰符synchronized(同步)

public class StringBuilder_Test {
    public static void main(String[] args) {
​
        //没有🔒，安全，适合单线程
​
        //StringBuilder s1 = new StringBuilder("asd");创建一个长度+16的字符
        StringBuilder s1 = new StringBuilder(10);//指定数组容量
    }
}
​

 

​Math类

该类为我们提供了一系列静态的数学方法

public class Math_Test {
    public static void main(String[] args) {
        /*
            提供了一系列静态的数学方法
         */
​
        System.out.println(Math.PI);//Π值
        System.out.println(Math.abs(-3));//绝对值  3
        System.out.println(Math.sqrt(9));//开平方  3
        System.out.println(Math.pow(2,3));//前者的后者次幂  8
​
        System.out.println(Math.floor(9.9));//向下取整  9
        System.out.println(Math.ceil(9.9));//向上取整  10
        System.out.println(Math.round(9.4));//标准四舍五入  9
​
        System.out.println(Math.max(1,9));//比较大小,返回较大的  9
        System.out.println(Math.min(1,9));//比较大小，返回较小的  1
        System.out.println(Math.random());//返回0-1间的随机数，可能会等于0，但一定小于1
​
    }
}

Random类

该类为我们提供了关于随机数的方法

import java.util.Arrays;
import java.util.Random;
​
public class Random_Test {
    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.nextLong());//随机在long范围内返回一个整数
        System.out.println(random.nextInt(7));//随机在0-(参数-1)范围内返回一个整数
​
        byte bytes[] = new byte[10];
        random.nextBytes(bytes);//随机取出数组个长度的byte类型的随机数
        System.out.println(Arrays.toString(bytes));
    }
}

 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_Test {
    public static void main(String[] args) {
        //日期
        Date date = new Date();//获取程序运行的时间
        System.out.println(date);
​
        /*
            方法上有删除线，表示该方法以弃用，有新的方法代替，但仍然可以使用
         */
​
        System.out.println(date.getYear());//124
        System.out.println(date.getMonth());//1
        System.out.println(date.getDate());//25
        System.out.println(date.getHours());//14
        System.out.println(date.getMinutes());//43
        System.out.println(date.getSeconds());//56
​
        //获取的是自1970.1.1  0:0:0 到程序运行时的毫秒值  时间戳
        System.out.println(date.getTime());//1708843676901
​
        Date date1 = new Date();
        System.out.println(date1.getTime() - date.getTime());
​
        Date date2 = new Date(1708843676901L);//将指定的long类型的时间戳构造一个时间对象
        System.out.println(date2);
    }
}

SimpleDateFormat类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
​
public class SimpleDateFormat_Test {
    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.getMonth() + 1);
        System.out.println(date.getDate());
​
        /*
            把日期对象转为指定格式的字符串
         */
        Date date1 = new Date();
        //2024年02月25日 15:31:04 星期日
        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
    }
}
​

正则表达式

定义

正则表达式-->Regular Expression 简称regex，是一种用与处理文本处理和搜索的的工具，也是一种规则(模式)匹配语法，可以使正则表达式中定义的特殊符号来定义一种规则，如果字符串与规则匹配则返回true，否则返回false

public class RegEx_Test {
    public static void main(String[] args) {
      /*
​
        用String.matches()方法;
        一些常用的正则表达式
        \\d == [0-9]   \\D-->匹配非非数字  \\w == [0-9A-z_]  \\W-->不能包含[0-9A-z_]
        \\s-->匹配空格  \\S-->匹配非空
        [\\ue00-\\u9fa5]-->匹配汉字  .-->除换行等特殊符号外任一符号
        |-->逻辑或  .-->匹配任意字符，使用时\\.
​
        //使用正则表达式的基础语法
        *  允许出现0次或多次
        +  允许出现一次或多次
        {n}  表示只能出现n次
        {n,}  表示至少出现n次
        {n,m}  表示至少n次，不超过m次
​
     */
​
     //
        String num = "19000000000@qq.com";
        System.out.println(num.matches("19[0]{5,}"));
        //匹配电话号码
        System.out.println(num.matches("1[379]\\d{9}"));
        //匹配邮箱
        System.out.println(num.matches("\\w{5,11}@\\w{2,8}\\.(com|com\\.cn)"));
    }
}