java自学笔记(day06),归纳总结自:B站千锋教育

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 fieldsYEARMONTHDAY_OF_MONTHHOUR ,等等,以及用于操纵该日历字段,如获取的日期下个星期。时间上的瞬间可以用毫秒值表示,该值是从1970年1月1日00:00 00:00.000 GMT(Gregorian)的Epoch的偏移量。

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

    与其他区域设置敏感的类一样, Calendar提供了一种类方法getInstance ,用于获取此类型的一般有用的对象。 CalendargetInstance方法返回一个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
    • 系统类
上一篇:百万年薪python之路 -- day06


下一篇:如何学好java-day06