Java常用API(1)

一、Object

Object是所有类的超级父类
equals hashCode toString clone getClass
native修饰方法 这个方法并不是java语言编写多数是由C语言后台处理
equals return this==obj

equals和hashCode原则
equals比较两个对象如果为true，这个两个对象的hashCode必须一样

package com.easy722;

import java.util.Objects;

public class EasyA {
   
    public static void main(String[] args) {
        //== 在引用类型中比较两个对象是否是同一个对象(地址是否一样)
        Object obj=new Object();
        Object obja=obj;
        System.out.println(obj==obja);//true
        Object objb=new Object();
        Object objc=new Object();
        System.out.println("objb==objc");//false

        //equals比较是否是相同的
        //如果要达到比较是否相同的效果，要对equals方法进行重写

        User userA=new User("zhangsan","123123");
        User userB=new User("zhangsan","123123");
        System.out.println(userA.equals(userB));//false
    }
}

class User{
    String username;
    String password;

    User(String username,String password){
        this.password=password;
        this.username=username;
    }

    /*public boolean equals(Object obj){
        //比较用户名和密码
        if(obj instanceof User) {
            User user = (User) obj;
            if(this.username.equals(user.username)&&this.password.equals(user.password)){//username属于字符串类型，就调用的字符串中的
                return true;
            }
        }
        return false;
    }*/
    //可快捷键自动生成
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(username, user.username) && Objects.equals(password, user.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(username, password);
    }
}

二、字符串

注意：
所有的字符串都是常量(不可改变）
1.private final value[] 不能在类外访问，也不能重新赋值
2.在String中也没有任何一个方法去修改value[]中的内容

import java.util.Arrays;

public class EasyB {
   
    public static void main(String[] args) {
        //字符串实例化
        String str="123";//字符串量
        String strA=new String();//""
        String strB=new String("123");
        char[] arr={};
        String strC=new String(arr);
        byte[] barr={};
        String strD=new String(barr);

        //字符串的方法
        str.equals("");//比较是否相同
        str.isEmpty();//验证字符串是否是空的
        str.toUpperCase();
        str.toLowerCase();//转成大小写
        str.getBytes();//获取byte数组 -- 一般用于流的传输
        str.charAt(1);//获取指定下标位置的字符
        str="abcabc";
        str.indexOf("a");//0,查找某一个串或字符出现的位置，找不到返回-1
        str.lastIndexOf("a");//3 查找某个元素最后出现的位置 从后往前
        str.length();//获取字符串中字符的个数
        int[] arra={};
        System.out.println(arra.length);
        str="abcabc";
        String newStr=str.replace("a","A");
        System.out.println(newStr);
        newStr=str.replaceAll(".","S");
        System.out.println(newStr);
        String[] arrs = str.split("b");//分割字符串
        System.out.println(Arrays.toString(arrs));
        str="123456789";
        newStr=str.substring(2);
        System.out.println(newStr);
        newStr=str.substring(2,6);//不包含结束为止
        System.out.println(newStr);

        //字符串常量池 字符串的比较        //在使用字符串时，先检测字符串常量池中是否有对应的字符串，如果有，就直接使用
        //如果没有，就在常量中创建该字符串并使用
        String strAA="123";
        String strBB="123";
        System.out.println(strAA==strBB);//true
        //堆
        String strCC=new String("abc");
        //创建了几个对象
        //哪些字符串会加入字符串常量池？ 直接以量的方式使用的字符串
//是否所有的字符串都会加入到常量池中？ 不是
//怎样将字符串加入到常量池中去？ intern方法
//intern方法 返回是字符串常量池中的副本对象
//str.intern() jvm会检查字符串常量池中是否有和str相同的字符串
//如果有，直接返回字符串常量池中的对象
//如果没有，将str字符串复制一份到字符串常量池中，返回字符串常量池中的对象
//所有 stra和strb equals为true stra.intern()==strb.intern() 结果为true
        char[] carr={'2','2'};
        String cstr=new String(carr);

        String a="1234";
        String b="1234";
        String c="12"+"34";
        String d="1"+"23"+"4";
        String e=new String("1234");
        String f="12"+new String("34");//执行时才能判断出来
        String g1="12";
        String g2="34";
        String g=g1+g2;
        System.out.println(a==b);//true
        System.out.println(a==c);//true  常量计算优化--编译阶段
        System.out.println(a==d);//true
        System.out.println(a==e);//false
        System.out.println(a==f);//false
        System.out.println(e==f);//false
        System.out.println(a==g);//false g1g2是变量，g是个新的串

    }
}

三、基本数据类型的封装类型

什么是基本数据类型的封装类型，为什么需要这个类型
为了实现万物皆对象的理念
byte short int long float double char boolean
Byte Short Integer Long Float Double Character Boolean
java中提供了基本数据类型和对应的封装类型相互转换的机制
基本数据类型转成对应的封装类型:装箱
封装类型的对象转成对应的基本数据类型:拆箱

比较:基本数据类型和封装类型进行比较,将封装类型的对象拆箱,然后再和基本数据类型比较

问：String不是基本数据类型 是关键字吗？不是

String是类名，像main这种类都不是关键字

public class EasyC {   
    int a=12;

    public static void main(String[] args){
        int a=200;
        Integer ia=200;
        ia.intValue();
        System.out.println(ia==a);

        Double dd=200.0;
        System.out.println(dd==a);//Java会统一提升到double 再比较
        //System.out.println(dd==ia); 封装类型之间不能比，比的是是否是同一个对象

        Integer a1=100;
        Integer a2=100;
        System.out.println(a1==a2);//true
        Integer a3=200;
        Integer a4=200;
        System.out.println(a3==a4);//false
        //基本数据类型的封装类型的缓存 缓存的范围 -128~127
        //哪些类型有缓存呢？ 整数  浮点型没有  character  0~127  boolean两个
        //只有Integer类型的缓存范围可以调整，其他类型都不可以调整
        Character c1='\u0000';
        Character c2='\u0000';
        System.out.println(c1==c2);
        Boolean b1=true;
        Boolean b2=true;
        System.out.println(b1==b2);
        float f=12000L;//float的取值范围更大，小的可以给赋值大的
        long l=(long)12.0f;
    }
}

四、时间

package com.easy722;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Objects;

public class EasyD {
    //时间  Date
    public static void main(String[] args) {
        java.util.Date d1=new Date();
        //当前时间
        System.out.println(d1);
        long time=d1.getTime();//获取时间戳
        System.out.println(time);
        SimpleDateFormat sdf=new SimpleDateFormat("YYYY-MM-dd HH:mm:ss SSS");
        System.out.println(sdf.format(d1));
        LocalDateTime ltime=LocalDateTime.now();
        //时间戳从1970.7.1开始

        Math.random();//获取随机数[0-1)
        int num=(int)(Math.random()*81);
        //0-80
        num=59+(int)(Math.random()*22);
        //59-80 59+(0-21)
        Math.ceil(12.1);//向上取整 获取的double double大long类型存不下
        Math.floor(12.9999999);//向下取整 12.0
        //负数的四舍五入：
        System.out.println(Math.round(-12.4));
        System.out.println(Math.round(-12.5));//-12
        System.out.println(Math.round(-12.6));

        //Arrays 对数组操作的工具类
        //Objects 对象的工具类
        Objects.isNull(sdf);

    }
}

五、异常

1、概念：异常：程序在运行阶段，发生的一些异常情况

如果程序中抛出了异常，不进行处理，程序就会中断

2、异常的分类：运行时异常 检查型异常

1、运行时异常：只有在程序运行阶段才会抛出的异常，可以通过编码技巧规避这些异常

继承RuntimeException
2、检查时异常：在编码时必须要处理的异常

直接继承Exception

3、自定义异常

抛出异常(具体对象) throw
声明方法可能抛出的异常类型 throws

4、处理异常

处理异常 try...catch...finally
执行过程：try尝试运行可能会抛出的异常，如果try块中的代码抛出了异常对象(不抛出接着往下把try运行完）
就会跳到执行对应的的catch类(只运行一下，从上往下识别)，finally块总是会运行

package com.easy722;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class EasyE {
    //异常：程序在运行阶段，发生的一些异常情况
    //异常的类 Exception
    //见过的异常 ClassCastException ArrayIndexOutOfBoundsException
    //ArithmeticException
    //内存溢出 Error OutOfMemoryError
   
    public static void main(String[] args)  {
       try{
           testException(-1);
           System.out.println("try代码块");
       } catch (EasyException|NullPointerException e) {
           e.printStackTrace();//捕捉，打印异常
           System.out.println("catch代码块");
       }//catch(NullPointerException e){}
       catch(Exception e){
            //大的异常放下面
       }
        finally{
           System.out.println("finally代码块");
       }

    }
    public static void testException(int price)throws EasyException,NullPointerException{
        if (price<0){
            throw new EasyException("价格为负数");
        }
        if(price==0){
            throw new NullPointerException();
        }
        System.out.println("你输入的价格是"+price);
    }
    //运行时异常可以不用throws
    public static void testRuntimeException(int price){
        if (price<0){
            throw new EasyRuntimeException("价格为负数");
        }
        System.out.println("你输入的价格是"+price);
    }
}

class EasyException extends Exception{
    public EasyException(){}
    public EasyException(String msg){
        super(msg);
    }
}

class EasyRuntimeException extends RuntimeException{
    public EasyRuntimeException(){}
    public EasyRuntimeException(String msg){
        super(msg);
    }
}