java自学笔记（day06），归纳总结自：B站千锋教育

Object类

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如果没有书写extends显式继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所有定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
  • 作为参数，可接受任何对象。
  • 作为返回值，可返回任何对象。

getClass()方法

public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用：通过用于判断两个引用中实际存储对象类型是否一致。

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("yangge", 18);
        Student s2 = new Student("wangge", 20);

        Class class1 = s1.getClass();
        Class class2 = s2.getClass();

        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

hashCode()方法

public int hashCode(){}

返回该对象的哈希码值。

哈希值根据对象的地址或 字符串或数字使用hash算法计算出来的int类型的数值。

一般情况下相同对象返回相同哈希码。

System.out.println("hashCode()方法结果如下：");
System.out.println("s1.hashCode() = "+s1.hashCode());
System.out.println("s2.hashCode() = "+s2.hashCode());

Student s3 = s1;
System.out.println("s3.hashCode() = "+s3.hashCode());

hashCode()方法结果如下：
s1.hashCode() = 1163157884
s2.hashCode() = 1956725890
s3.hashCode() = 1163157884

toString()方法

public String toString(){}

返回该对象的字符串表示(表现形式)

可以根据程序需求覆盖该方法，如：展示对象各个属性值。

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

System.out.println(s1.toString());

equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。
  • equals()方法覆盖步骤
  • 比较两个引用是否指向同一个对象
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致
  • 强制类型转换
  • 依次比较各个属性值是否相同

@Override
public boolean equals(Object obj) {
    //1.判断两个对象是否是一个引用
    if (this == obj){
        return true;
    }
    //2.判断obj是否为null
    if (obj == null){
        return false;
    }
    //3.instanceof 判断对象是否某种类型
    if (obj instanceof Student){
        //4.强制类型转换
        Student s = (Student) obj;
        //5.比较熟悉
        if (this.name.equals(s.getName()) && this.age == s.getAge()){
            return true;
        };
    }
    return false;
}

Student s4 = new Student("zhangsan", 15);
Student s5 = new Student("zhangsan", 15);
System.out.println(s4.equals(s5));

finalize()方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

@Override
protected void finalize() throws Throwable {
    System.out.println(this.name+"对象被回收了");
}

new Student("aaa",18);
new Student("bbb",18);
new Student("ccc",18);
new Student("ddd",18);
new Student("eee",18);
new Student("fff",18);

System.gc();

包装类

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

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

包装类对应

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换与装箱、拆箱

JDK1.5之后有自动装箱和拆箱，可以从生成的class文件中看出<

public class Demo1 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转为引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱，引用类型转为基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
        
    }
}

基本类型和字符串转换

System.out.println("========基本类型和字符串之间的转换==========");
//基本类型和字符串之间转换
//1.基本类型转为字符串
int n1 = 15;
//1.1使用+号
String str1 = n1+"";
//1.2使用Integer的toString()方法
String str2 = Integer.toString(n1,16);
System.out.println(str1);
System.out.println(str2);

//2.字符串转为基本类型
String str3 = "12";
//使用Integer.parseXXX()方法
int n2 = Integer.parseInt(str3);
System.out.println(n2);

//3.boolean字符串形式转为基本类型；"true" ---> true， 非"true" ---> false
String str4 = "true";
boolean b1 = Boolean.parseBoolean(str4);
System.out.println(b1);

• 8种包装类提供不同类型间的转换方式：
  • Number父类中提供的6个共性方法。
  • parseXXX()静态方法。
  • valueOf()静态方法。
• 注意：需保证类型兼容，否则抛出NumberFormatException异常。

Integer缓冲区（理解）

• Java预先创建了256个常用的整数包装类型对象。
• 在实际应用当中，对已创建的对象进行复用。

重点理解Integer.valueOf()

public class Demo2 {
    public static void main(String[] args) {
        //整数缓冲区面试题

        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

        Integer integer3 = Integer.valueOf(100);//自动装箱Integer.valueOf()
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4);//true

        Integer integer5 = Integer.valueOf(200);
        Integer integer6 = Integer.valueOf(200);
        System.out.println(integer5 == integer6);//false
    }
}

String类概述（重点）

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中，可以共享。
• String s = “Hello”; 产生一个对象，字符串池中存储。
• String s = new String(“Hello”); //产生两个对象，堆、池各存储一个。

public class Demo3 {
    public static void main(String[] args) {
        String name = "Hello"; //"Hello"常量存储在字符串池中，
        name = "zhangsan";  //"zhangsan"赋值给name变量，给字符串赋值的时候并没有修改数据，而是重新开辟空间
        String name2 = "zhangsan";

        //演示字符串的另一种创建方式，new String();
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str == str2); //false
        System.out.println(str.equals(str2)); //true

    }
}

String的常用方法

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

String str = "java是最好的编程语言！";
System.out.println(str.length()); //13

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

System.out.println(str.charAt(str.length()-1));// !

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

System.out.println(str.contains("j")); //true

public char[] toCharArray()：将字符串转为数组

String str2 = "java是最好的编程语言，java真香~";
System.out.println(Arrays.toString(str2.toCharArray())); //[j, a, v, a, 是, 最, 好, 的, 编, 程, 语, 言, ，, j, a, v, a, 真, 香, ~]

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

System.out.println(str2.indexOf("java"));  //0
System.out.println(str2.indexOf("java",5));//13，因为从第二位开始，后得到java的首字母j位于13号位置，所以返回。

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

System.out.println(str2.lastIndexOf("va")); //15

public String trim()：去掉字符串前后的空格

String str3 = "   Hello World   ";
System.out.println(str3.trim());  //Hello World

public String toUpperCase()，toLowerCase()：将小写转成大写或大写转成小写

System.out.println(str3.toUpperCase());  //   HELLO WORLD
System.out.println(str3.toLowerCase());  //   hello world

public boolean endWith(String str)，startWith(String str)：判断字符串是否以str结尾或以str开始

String str4 = "hello.java";
System.out.println(str4.endsWith(".java"));  //true
System.out.println(str4.startsWith("he"));  //true

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

String str5 = "我爱java，一天不用IDEA写java就难受";
System.out.println(str5.replace("java","php"));  //我爱php，一天不用IDEA写php就难受

public String[] split(String str)：根据str做拆分

String str6 = "java is the best porgraming   languae in the world,java xiang";
String[] arr = str6.split("[ ,]+");//[]代表供选择的，+代表可以有多个
for (String string: arr) {
    System.out.println(string);
}
//java
//is
//the
//best
//porgraming
//languae
//in
//the
//world
//java
//xiang

补充两个方法equals()、compareTo()；比较大小

equals()

String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));  //false
System.out.println(s1.equalsIgnoreCase(s2));  //true

compareTo()两个字符串比较大小实质上是比较其在编码表的位置

String s3 = "abc";  //a的ASCII值为97
String s4 = "xyz";  //x的ASCII值为120
System.out.println(s3.compareTo(s4));  //比大小

String s5 = "abc";
String s6 = "abcd";
System.out.println(s5.compareTo(s6));  //比长度

String案列演示

package com.commonclass;

/*
* 需求：
*   已知String str = "this is a text";
*   1.将str中的单词单独取出来
*   2.将str中的text替换为practice
*   3.在text前面插入一个easy
*   4.将每个单词的首字母改为大写
* */
public class Demo5 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独取出来
        String[] arr = str.split(" ");
        for (String string: arr) {
            System.out.println(string);
        }
        //2.将str中的text替换为practice
        System.out.println(str.replace("text","practice"));
        //3.在text前面插入一个easy
        System.out.println(str.replace("text","easy text"));
        //4.将每个单词的首字母改为大写
        for(int i = 0; i < arr.length; i++){
            char first = arr[i].charAt(0);  //获取到数组元素的首字母
            char upperfirst = Character.toUpperCase(first);  //将数组元素的首字母转为大写

            String news = upperfirst+arr[i].substring(1);  //将数组元素首字母与其后续拼接在一起
            System.out.println(news);
            //This
            //Is
            //A
            //Text
        }
    }
}

可变字符串

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

package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别：1.效率比String高；2.比String节省内存
* */
public class Demo6 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append();追加
        sb.append("java世界第一秀");
        System.out.println(sb.toString());  //java世界第一秀
        sb.append("java真香");
        System.out.println(sb.toString());  //java世界第一秀java真香
        sb.append("java不错");
        System.out.println(sb.toString());  //java世界第一秀java真香java不错
        //2.insert();添加
        sb.insert(0, "我在最前面");
        System.out.println(sb.toString());  //我在最前面java世界第一秀java真香java不错
        //3.replace();替换
        sb.replace(0, 4, "hello");  //遵循左包含原则，eg：[20,30);
        System.out.println(sb.toString());  // hello面java世界第一秀java真香java不错
        //4.delete();删除
        sb.delete(0, sb.length());  //输出为空
        System.out.println(sb.toString());
        System.out.println(sb.length());  //0
    }
}

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

package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别：1.效率比String高；2.比String节省内存
* */
public class Demo6 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        //1.append();追加
        sb.append("java世界第一秀");
        System.out.println(sb.toString());  //java世界第一秀
        sb.append("java真香");
        System.out.println(sb.toString());  //java世界第一秀java真香
        sb.append("java不错");
        System.out.println(sb.toString());  //java世界第一秀java真香java不错
        //2.insert();添加
        sb.insert(0, "我在最前面");
        System.out.println(sb.toString());  //我在最前面java世界第一秀java真香java不错
        //3.replace();替换
        sb.replace(0, 4, "hello");  //遵循左包含原则，eg：[20,30);
        System.out.println(sb.toString());  // hello面java世界第一秀java真香java不错
        //4.delete();删除
        sb.delete(0, sb.length());  //输出为空
        System.out.println(sb.toString());
        System.out.println(sb.length());  //0
    }
}

验证StringBuilder效率高于String

package com.commonclass;
/*
*    验证StringBuilder效率高于String
* */
public class Demo7 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String string = "";
        for (int i = 0; i < 99999; i++) {
            string += i;
        }
        System.out.println(string);
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));  //用时：34695

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("用时：" + (end2 - start));  //用时：31
    }
}

BigDecimal类

double、float类型存储的是近似值！此时对于精度运算有需求的，需要借助BigDecimal

public class Demo8 {
    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
    }
}

• 位置：java.math包中。
• 作用：精确计算浮点数。
• 创建方式：BigDecimal bd = new BigDecimal(“1.0”);
• 方法：
  • BigDecimal add(BigDecimal bd) 加
  • BigDecimal subtract(BigDecimal bd) 减
  • BigDecimal multiply(BigDecimal bd) 乘
  • BigDecimal divide(BigDecimal bd) 除
• 除法：divide (BigDecimal bd, int scal, RoundingMode mode)
• 参数scal：指定精确到小数点后几位。
• 参数mode：
  • 指定小数部分的取舍模式，通常采用四舍五入的模式。
  • 取值为BigDecimal.ROUND_HALF_UP。

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

//除法
//double result = (1.4 - 0.5) / 0.9;
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("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
System.out.println(r5);  //6.67

Date类

• Date类表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendat类中的方法所取代。
• 时间单位
  • 1秒 = 1000毫秒
  • 1毫秒 = 1000微秒
  • 1微秒 = 1000纳秒

package com.commonclass;

import java.util.Date;

public class Demo9 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());  //2021-2-27 14:35:51

        //昨天
        Date date2 = new Date(date1.getTime() - (24 * 60 * 60 * 1000));
        System.out.println(date2.toLocaleString());  //2021-2-26 14:35:51

        //2.方法 after、before
        boolean b1 = date1.after(date2);
        System.out.println(b1);  //true
        boolean b2 = date1.before(date2);
        System.out.println(b2);  //false

        //比较compareTo();
        int d = date2.compareTo(date1);
        System.out.println(d);  //-1
        //比较是否相等equals();
        boolean b3 = date1.equals(date2);
        System.out.println(b3);  //false
    }
}

Calendar类

• 所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。

  该类还提供了用于在包外部实现具体日历系统的其他字段和方法。 这些字段和方法定义为protected 。

  与其他区域设置敏感的类一样， Calendar提供了一种类方法getInstance ，用于获取此类型的一般有用的对象。 Calendar的getInstance方法返回一个Calendar对象，其日历字段已使用当前日期和时间进行初始化：

  • Calendar rightNow = Calendar.getInstance();

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

• 构造方法

  • protected Calendar(); 由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如：年、月、日等
void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

package com.commonclass;

import java.util.Calendar;

public class Demo10 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月，月份从0-11
        int month = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH); //Date
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  //HOUR12小时制，HOUR_OF_DAY24小时制
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);

        System.out.println(year+"年" +(month+1)+"月" +day+"日 "+hour+":"+minute+":"+second);

        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 6);   //改变此月份的某一日子
        //calendar2.set(Calendar.DAY_OF_MONTH, 30);  此时月份改为3月2日，因为2021年的2月只有28天
        System.out.println(calendar2.getTime().toLocaleString());

        //4.add方法修改时间
        calendar2.add(Calendar.HOUR, -1);  //减去一个小时
        System.out.println(calendar2.getTime().toLocaleString());

        //5.补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
• 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
• 常用的时间模式字母

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	367

package com.commonclass;

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

public class Demo11 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象 y年 M月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date = new Date();
        //3.格式化date (把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //4.解析 (把字符串转成日期)
        Date date2 = sdf.parse("1998/09/01");
        System.out.println(date2);
    }
}

System类

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

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit (int status);	推出JVM，如果参数是0表示正常推出JVM，非0表示异常推出JVM

package com.commonclass;

import java.util.Arrays;

public class Demo12 {
    public static void main(String[] args) {
        //1.arraycopy：数组的复制
        //src：源数组
        //srcPos：从那个位置开始复制0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int arr[] = {13, 15, 18, 25, 36, 78, 92, 100};
        int[] dest = new int[8];
        System.arraycopy(arr, 0, dest, 0, arr.length);
        for (int i = 0; i < dest.length; i++){
            System.out.println(dest[i]);
        }
        //Arrays.copyOf(original, newLength)

        //2.System.currentTimeMillis()可用于计时
        long start = System.currentTimeMillis();
        for (int i = -999999; i < 999999; i++){
            for (int j = -999999; j < 999999; j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end - start));

        //3.static void gc();
        Student s1 = new Student("wangge", 25);
        Student s2 = new Student("sange", 25);

        new Student("haiyan", 25);
        new Student("haiwa", 25);
        new Student("haiwang", 25);

        System.gc();  //告诉垃圾回收器回收

        //4.退出JVM
        System.exit(0);
        System.out.println("程序结束了.......");
    }
}

总结

• 内部类：
  • 在一个类的内部再定义一个完整的类。
  • 成员内部类、静态内部类、局部内部类、匿名内部类。
• Object类
  • 所有类的直接或间接父类，可以存储任何对象。
• 包装类：
  • 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
• String类
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal：
  • 可精确计算浮点数
• Date
  • 特定时间
• Calendar
  • 日历
• SimpleDateFormat
  • 格式化时间
• System
  • 系统类