Java基础整理----常用类

EXERCISE

Test04

Object

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。

Object类中所定义的方法，是所有对象都具备的方法。

Object类型可以存储任何对象。作为参数，可以接受任何对象。

              作为返回值，可返回任何对象。

getClass()方法

返回引用中存储的实际对象类型，通常用于判断两个引用中实际存储对象类型是否一致。

public final Class<?> getClass(){}

hashCold()方法

返回该对象的哈希码值，哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值，一般情况下相同对象返回相同哈

希码。

public int hashCold(){}

toString()方法

返回该对象的字符串表示（表现形式），可以根据程序需求覆盖该方法（重写），如：展示对象各个属性值。

public String toString(){}

equals()方法

默认实现为（this == obj），比较两个对象地址是否相同，可进行覆盖，比较两个对象的内容是否相同。

public boolean equals(Object obj){}

equals()方法覆盖步骤：①比较两个引用是否指向同一个对象。

           ②判断obj是否为null。

           ③判断两个引用指向的实际对象类型是否一致。

           ④强制类型转换。

           ⑤依次比较各个属性值是否相同。

public class Demo04 {
    private String name;
    private int age;
    public Demo04(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
     @Override  //重写toString()方法，使hashcold转换成字符串
    public String toString() {
        return "Demo04{" +"name='" + name + '\'' +'}';
    }
}
    @Override  //重写equals()方法
    public boolean equals(Object obj) {
        if (this == obj){                     //①比较两个引用是否指向同一个对象
            return true;
        }
        if (obj == null){                     //②判断obj是否为null
            return false;
        }
        if (obj instanceof Demo04){           //③判断两个引用指向的实际对象类型是否一致
            Demo04 s = (Demo04)obj;           //④强制类型转换
            if (this.name.equals(s.getName()) && this.age == s.getAge()){       //⑤依次比较各个属性值是否相同
                return true;
            }
        }
        return false;
    }

    
public class DemoTest04 {
    public static void main(String[] args) {
        Demo04 s1 = new Demo04("aaa",20);           //判断s1和s2是不是同一类型
        Demo04 s2 = new Demo04("bbb",20);
        System.out.println(class1==class2);
        System.out.println("-------------------------------------");
        System.out.println(s1.hashCode());          //hashCold()方法
        System.out.println(s2.hashCode());
        System.out.println("-------------------------------------");
        System.out.println(s1.toString());          //toString()方法
        System.out.println(s2.toString());
        System.out.println("-------------------------------------");
        System.out.println(s1.equals(s2));
        Demo04 s3 = new Demo04("久诚",21);
        Demo04 s4 = new Demo04("久诚",21);
        System.out.println(s3.equals(s4));          //地址不一样
}

默认实现：
重写后： 

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

包装类

基本数据类型所对应的引用数据类型

Object可统一所有数据，包装类的默认值是null。

装箱与拆箱

装箱：基本数据类型 -> 引用数据类型（栈 -> 堆）

拆箱：引用数据类型 -> 基本数据类型（堆 -> 栈）

public class Demo05 {
    public static void main(String[] args){
        //jdk1.5之前
        //两种装箱
        int num = 10;
        Integer integer = new Integer(num);         //①
        Integer integer1 = Integer.vaLueOf(num);    //②
        //拆箱
        Integer integer2 = new Integer(100); 
        int num1 = integer2.intValue();
        
        //jdk1.5之后，提供自动装箱和拆箱
        int age = 20;
        Integer integer3 = age;   //自动装箱
        int age1 = integer3;      //自动拆箱
    }
}

基本类型和字符串转换

public class Demo05 {
    public static void main(String[] args){
        //两种基本类型转换成字符串
        int n =15;
        String s1 = n + "";                   //①使用+
        String s2 = Integer.toString(n);      //②使用Integer中的toString()方法
        String s3 = Integer.toString(n,16);   //十六进制
        System.out.println(s1);               //15
        System.out.println(s2);               //15
        System.out.println(s3);               //f
        //字符串转换成基本类型
        String str = "150";
        int n1 = Integer.parseInt(str);       //使用Integer.parseXXX()
        System.out.println(n2);               //150
        //boolean字符串形式转成基本类型
        String str1 = "true";
        String str2 = "ture";
        boolean b1 = Boolean.parseBoolean(str1);
        boolean b2 = Boolean.parseBoolean(str2);
        System.out.println(b1);               //true
        System.out.println(b2);               //false（非"true"都是false）
    }
}

注：需保证类型兼容，否则抛出NumberFormatException异常。

整数缓冲区

Java预先创建了256个常用整数包装类型对象

public class Demo05{
    public static void mian(String[] args){
        Integer i1 = new  Integer(100);
        Integer i2 = new  Integer(100);
        System.out.println(i1 == i2);       //false（堆内存地址不同）
        Integer i3 = 100;                   //自动装箱（Integer.vaLueOf）
        Integer i4 = 100;
        System.out.println(i3 == i4);       //true
        Integer i5 = 200;                   //自动装箱（Integer.vaLueOf，缓冲区范围：-127——128，超出范围则new Integer）
        Integer i6 = 200;
        System.out.println(i5 == i6);       //false
    }
}

String类

字符串是常量，创建之后不可改变。

字符串字面值存储在字符串池中，可以共享。

String s = "Hello"; 产生一个对象，字符串池中存储。

String s = new String("Hello"); 产生两个对象，堆，池各存储一个。

public class Demo05 {
    public static void main(String[] args) {
        String name = "久诚";     //常量存储在字符串池中
        name = "Hello";           //给字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2 = "Hello";
        String str = new String("请回答1998");    //创建两个对象，分别在堆和池里
        String str2 = new String("请回答1998");
        System.out.println(str == str2);         //false
        System.out.println(str.equals(str2));    //true
    }
}

常用方法

1）public int length()：返回字符串的长度

2）public char charAt(int index)：根据下标获取字符

3）public boolean contains(String str)：判断当前字符串中是否包含str

public class Demo05 {
    public static void main(String[] args) {
        String content = "请回答1998";
        System.out.println(content.length());                       //7
        System.out.println(content.charAt(content.length()-5));     //答
        System.out.println(content.contains("1998"));               //true
        System.out.println(content.contains("2001"));               //false
    }
}

4）public char[] toCharArray(); 将字符串转换成数组。

5）public int indexOf(String str); 查找str首次出现的下标，存在则返回该下标；不存在，则返回-1

6）public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引

public class Demo05 {
    public static void main(String[] args) {
        String content = "1998请回答1998 1998";
        System.out.println(Arrays.toString(content.toCharArray())); //[1, 9, 9, 8, 请, 回, 答, 1, 9, 9, 8,  , 1, 9, 9, 8]
        System.out.println(content.indexOf("1998"));      //0
        System.out.println(content.indexOf("1998",4));    //7
        System.out.println(content.lastIndexOf("1998"));  //12
    }
}

7）public String trim(); 去掉字符串前后的空格

8）public String toUpperCase(); 将小写转成大写，toLowerCase(); 把大写转成小写

9）public boolean endWith(String str); 判断字符串是否以str结尾，starWith(str); 判断是否以str开头

public class Demo05 {
    public static void main(String[] args) {
        String content = " hello World ";
        System.out.println(content.trim());
        System.out.println(content.toUpperCase());
        System.out.println(content.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
    }
}

10）public String replace(char oldChar,char newChar); 将旧字符串替换成新字符串

11）public String[] split(String str); 根据str拆分

public class Demo05 {
    public static void main(String[] args) {
        String content = "请回答1988";
        System.out.println(content.replace("1988","2001"));    //请回答2001
        String say = "There was an accident  on this road,11";
        String[] arr = say.split("[ ,]+");                     //空格和逗号都拆分，+解决两个空格拆分
        System.out.println(arr.length);                        //8
    }
}

补充：equals和compareTo()的区别：

public class Demo05 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));   //忽略大小写比较
        String s3 = "abc";    //97
        String s4 = "xyz";    //120
        System.out.println(s3.compareTo(s4));          //比较大小（字典表里的顺序）
        String s5 = "abcxyz";
        System.out.println(s3.compareTo(s5));          //顺序一样的话比长度
    }
}

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。

StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全

public class Demo06 {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        str.append("请回答");
        System.out.println(str.toString());     //请回答
        str.append("1988");                     //①追加
        System.out.println(str.toString());     //请回答1988
        str.insert(0,"2001");                   //②在0处添加
        System.out.println(str.toString());     //2001请回答1988
        str.replace(0,4,"1820");                //③替换[0,4)（左闭右开）
        System.out.println(str.toString());     //1820请回答1988
        str.delete(0,4);                        //④删除（左闭右开）
        System.out.println(str.toString());     //请回答1988
        str.delete(0,str.length());             //⑤清空
        System.out.println(str.toString());     //
    }
}

BigDecimal

位于java.math包中，可以精确计算浮点数。

BigDecimal bd = new BigDecimal("1.0");

很多实际应用中需要精确运算，而double是近似值存储，不符合要求，需要借助BigDecimal。

package com.weibo02.exercise;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Demo06 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);            //0.09999999999999998
        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);           //0.9999999999999999
        System.out.println("------------------------------------------------------");
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal r1 = bd1.subtract(bd2);    //减法
        System.out.println(r1);               //0.1
        BigDecimal r2 = bd1.add(bd2);         //加法
        System.out.println(r2);               //1.9
        BigDecimal r3 = bd1.multiply(bd2);    //乘法
        System.out.println(r3);               //0.90
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));//除法
        System.out.println(r4);               //1
        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2, RoundingMode.HALF_UP);//保留两位小数，四舍五入
        System.out.println(r5);               //3.33
    }
}

时间类

Date类

很多方法被Calendar代替。

public class Demo07 {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println(date1.toString());                         //Tue Nov 01 12:49:28 CST 2022（当前时间）
        Date date2 = new Date(date1.getTime() - (60*60*24*1000));     //前一天的时间
        System.out.println(date2);                                    //Mon Oct 31 12:52:45 CST 2022
        boolean b1 = date1.after(date2);                              //判断今天在昨天之后
        System.out.println(b1);                                       //true
        boolean b2 = date1.before(date2);                             //判断今天在昨天之前
        int d = date2.compareTo(date1);                               //比较毫秒值
        System.out.println(d);                                        //-1
        boolean b3 = date1.equals(date2);                             //比较时间相等
        System.out.println(b3);                                       //false
    }
}

Calendar类

提供了获取或设置各种日历字段的方法

protected Calendar(){}      //构造方法，修饰符是protected，无法直接创建该对象

其他方法：

package com.weibo02.exercise;

import java.util.Calendar;

public class Demo07 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();               //使用静态方法创建Calendar对象
        System.out.println(calendar.getTime().toLocaleString());  //2022年11月1日 下午8:41:34
        System.out.println(calendar.getTimeInMillis());           //1667306494193
        //获取当前时间信息
        int year = calendar.get(Calendar.YEAR);         //获取年
        int month = calendar.get(Calendar.MONTH);       //获取月(0—11)
        int day = calendar.get(Calendar.DAY_OF_MONTH);  //日
        int hour = calendar.get(Calendar.HOUR);         //HOUR:12小时，HOUR_OF_DAY:24小时
        int minute = calendar.get(Calendar.MINUTE);     //分
        int second = calendar.get(Calendar.SECOND);     //秒
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second); //2022年11月1日8:41:34
        System.out.println("----------------------------------------------------------------");
        //修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar1.getTime().toLocaleString());      //2022年11月5日 下午8:41:34
        //add()方法修改时间
        calendar1.add(Calendar.HOUR,1);                                //-1就是减少一小时
        System.out.println(calendar1.getTime().toLocaleString());      //2022年11月5日 下午9:41:34
        //获取当前时间最大、最小值
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);   //30（一个月中最大的一天）
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);   //1
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat

一个以与语言环境有关的方式来格式化和解析日期的具体类

进行格式化（日期 -> 文本）、解析（文本 -> 日期）

常用的时间模式字母：

package com.weibo02.exercise;

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

public class Demo08 {
    public static void main(String[] args) throws Exception {
        //创建SimpleDateFormat对象 y 年 M 月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        Date date = new Date();                          //创建Date
        String str = sdf.format(date);                   //格式化date(把日期转成字符串)
        System.out.println(str);                         //2022.11.01 21:10:54
        Date date1 = sdf.parse("1998.12.26 13:14:01");   //解析（把字符串转成日期）
        System.out.println(date1);                       //Sat Dec 26 13:14:01 CST 1998
    }
}

System系统类

主要用于获取系统的属性数据和其他操作，该类构造方法是私有的

public class Demo08 {
    public static void main(String[] args) {
        int arr[] = {12,45,89,32,41,78};
        int dest[] = new int[6];
        //复制数组
        System.arraycopy(arr,0,dest,0,arr.length);  //从0开始赋值，目标数组的位置是0
        for (int i = 0;i < dest.length;i++){
            System.out.println(dest[i]);
        }
        System.out.println(System.currentTimeMillis());
        //计时
        long start = System.currentTimeMillis();
        for (int i = 0;i < 999999;i++){
            for (int j = 0;j < 999999;j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
        System.exit(0);      //程序退出
    }
}