华清远见-重庆中心-JAVA高级阶段知识点梳理

1.Object类

1.1Object类的介绍

1. java.lang.Object类是所有类的父类

2.万事万物皆可对象

3.一个类没有使用extends继承某个特定父类，那么他的父类就是Object

4.Object类定义了对象的基本行为，可以被子类使用

package seDay1;

import java.util.Date;

public class TestObject {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj);

        Student stu = new Student("1001", "tom", 20);
        Class aClass = stu.getClass();//getClass()是object中的一个方法
        System.out.println(aClass);//输出class seDay1.Student
        Object tom = new Student("1001", "tom", 20);
        //类.class的到的是类的全名
        if (tom.getClass()==Student.class){
            //强制类型转换
            Student stu1=(Student) tom;
            System.out.println(stu1.getStuName());
        }

        print("hello");
        print(new Date());
        print(stu);
        print(100);
    }

    //写一个方法，带参数，将参数输出
    public static void print(Object o){
        System.out.println(o);
    }
}

1.2 toString

1.Object类中的toString方法，用于返回对象成员变量的字符串。类名+@+16进制整数

2.通常会重写toString方法，返回更有意义的字符串

1.3equals

1.Object类中的equals方法，用于判断对象是否相等，也就是引用地址是否相等

2.重写equals方法后，比较的是值是否相等

注意：
1.在使用字符串时，如果要比较其值是否相同，不要使用==判断，因为==判断的是内存地址；所以在比较字符串是否相同时，要使用String类重写的equals方法进行判断。

2.equals的原理：将两个字符串用字符数组保存，逐个判断字符数组中的每个字符，全部一致 时返回true；在使用equals方法时，通常将已知的非空字符串作为调用者，避免空指针异常。
 

1.4hashCode

1.Object类中的hashCode方法，根据对象的内容，返回一个整数值

2.一般重写了equals方法就会要求重写hashCode方法

package seDay1;

import java.util.Objects;
//重写父类(Object)中的toString、equals、hashCode方法
public class Student {
    private String stuNo;
    private String stuName;
    private int  stuAge;

    public Student() {
    }

    public Student(String stuNo, String stuName, int stuAge) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return stuAge == student.stuAge &&
                Objects.equals(stuNo, student.stuNo) &&
                Objects.equals(stuName, student.stuName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(stuNo, stuName, stuAge);
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNo='" + stuNo + '\'' +
                ", stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }
}

2.String字符串

String是一个类，属于数据类型中的引用类型，Java中一切使用" "引起来的内容，都是这个类的实例，称为字符串对象；字符串在定义后，值不可改变，是一个常量，实际是一个字符数组。

package seDay1;

public class StringDemo1 {
    public static void main(String[] args) {
        //字符串不可变，不是通过new创建出来的字符串都是存在常量池中
        String str1="hello";
        String str2="hello1";
        System.out.println(str1==str2); //false

        String str3="hello";
        System.out.println(str1==str3);//true

        String str4="hello"+"1";//编译的时候，先运算，然后到字符串常量池里去找，如果存在，就把值的地址赋值个str4，如果不存在，就创建一个
        System.out.println(str2==str4); //true

        String str5=str1+"1";
        System.out.println(str5==str2);//false 跟变量做拼接，运行的时候才会拼接字符串，和常量池中的地址不等

        String str6 = new String("hello"); //new了一个对象，"hello"存在堆内存中
        System.out.println(str6==str1);//false
    }
}

1.2String类

如果频繁地将一个String类型变量的值进行更改时，会创建很多字符串对象。效率 低，浪费内存空间。所以在频繁更改字符串时，不要使用String类变量。如果要频繁更改字符串，使用StringBuilde类或StringBuffer类

1.3 如何创建字符串对象

1.2.1使用" "赋值创建

String str = " abc ";

1.2.2通过构造方法创建 

常用构造方法	说明
String()	创建一个空白字符串对象
String(String str)	创建一个指定字符串的字符串对象
String(char[ ]  list)	创建一个指定字符数组的字符串对象
String(byte[ ]  list,String charsetName)	按指定的编码格式创建一个指定数组的字符串对象

使用 " " 赋值的形式创建

//先判断字符串常量池是否存在" ab "，不存在就创建，将其地址保存到str1变量中 
String str1="ab";

//先判断字符串常量池是否存在" ab "，已经存在就不用创建，将其地址保存到str2变量中
String str2="ab";

//+如果两端都是" "定义的字符串，拼接后再判断字符串常量池是否存在，如果不存在就创建，如果存在就将其地址保存到str3变量中
String str2="a" + "b";

System.out.println(str1==str2);//true
System.out.println(str1==str3);//true

使用构造方法String(String str)创建

//这句话执行时的流程
//1.在字符串常量池中寻找"ab",不存在,创建
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str1中
String str1 = new String("ab");


//这句话执行时的流程
//1.在字符串常量池中寻找"ab",存在,直接引用
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str2中
String str2 = new String("ab");


//由于str1和str2是堆中的两个区域，所以结果为false
System.out.println(str1 == str2);//false

使用+拼接""和new出来的字符串对象创建

//在字符串常量池中创建"ab"
String str1 = "ab";


//1.创建StringBuilder对象
//2.在字符串常量池中创建"a"
//3.在字符串常量池中创建"b"
//4.创建String对象
//5.调用StringBuilder的append方法，将"a"和new String("b")拼接
String str2 = "a" + new String("b");//一共创建了"a","b",String,StringBuilder这四个对
象


//两个不同的地址
System.out.println(str1==str2);//false

注意：

1.在使用字符串时，如果要比较其值是否相同，不要使用==判断，因为==判断的是内存地址；所以在比较字符串是否相同时，要使用String类重写的equals方法进行判断。

2.equals的原理：将两个字符串用字符数组保存，逐个判断字符数组中的每个字符，全部一致 时返回true；在使用equals方法时，通常将已知的非空字符串作为调用者，避免空指针异常。

1.4String类中常用的方法

方法名	返回值	作用
length（）	int	得到字符串的长度
toLowerCase（）	String	将字符串转换为小写
toUpperCase（）	String	将字符串转换为大写
trim（）	String	去掉字符串首位所有空格
isEmpty（）	boolean	判断字符串是否为空白字符串
getBytes（）	byte[ ]	将字符串转换为字节数组
toCharArray（）	char[ ]	将字符串转换为字符数组
equalsIgnoreCase（String str）	boolean	忽略大小写判断两个字符串是否相同
equals（String str）	boolean	判断两个字符串是否相同
charArt（int index）	char	得到字符串指定索引上的字符
indexOf（String str）	int	得到指定字符串第一次出现的索引，如果不存在。返回-1
lastIndexOf（String str）	int	得到指定字符串最后一次出现的索引，如果不存在。返回-1
contains（字符序列化）	boolean	判断某个字符串是否在原字符串中出现
concat（String str）	String	将参数字符串拼接到原字符串末尾
starsWith（String str）	boolean	判断是否以指定字符串开头
endsWith（String str）	boolean	判断是否以指定字符串结尾
substring（int begin）	String	从指定索引开始截取字符串至末尾
substring（int begin，int end）	String	截取[ begin ,end)区间的字符串
split(String regex)	String [ ]	按执行字符串或正则表达式切分原字符串。如果指定内 容不再末尾，n个指定字符能得到n+1个子串;如果指定 内容在末尾，n个指定字符能得到n个子串(不包含末尾 的无效字符)
replace(char oldChar,char newChar )	String	将原字符串中的指定字符替换为新字符
String.valueOf(参数)	String	将任意参数转换为字符串。通常用于原始类型转换为字符串
String.formart(String 格 式,Object... obj)	String	根据指定格式转换参数。常用于将浮点数保留小数。如 String.format("%4.2f",10.0/3)表示将计算的结果四舍 五入保留2位小数转换为字符串；如果最终数据所占位 置小于4，原样输出，大于4在最前补充空格

3.正则表达式

3.1正则表达式介绍

1.正则表达式是一个特殊的字符串，是由一些特定的字符串组成的“规则字符串”

2.正则表达式，主要用于对字符串进行匹配，查找，替换等操作

3.正则表达式的规则

可以出现的字符

可以出现的字符简写

 

字符出现的次数

其他规定

 3.2正则表达式在String中的使用

1.split方法把字符串按照指定的分隔符，分割为字符串数组

2.String提供了用于字符串替换的方法

package seDay2;

import java.util.Arrays;

//正则表达式
public class StringDemo {
    public static void main(String[] args) {
        String str = "aa123bb33cc3333dd1122";
        String regex = "[0-9]{1,}";//正则表达式，最少出现一个0~9的数字
        //根据数字进行切割，把连续的字母取出来，保存在一个数组中
        String[] split = str.split(regex);
        System.out.println(Arrays.toString(split));
        //把字符串转为字符数组，然后用-把元素连成字符串
        String str2 = "123456789";
        String str3 = "";
        char[] chars = str2.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            str3 += chars[i] + "-";
        }
        //去掉最后的-
        str3 = str3.substring(0, str3.length() - 1);
        System.out.println(str3);
        //将2023.1.5输出为2023-1-5
        String year = "2023.1.5";
        //根据正则表达式，把匹配成功的全换成"-"
        System.out.println(year.replaceAll("\\.{1,}", "-"));
        //将tom替换成TOM
        String s1 = "djdtomdddtomxxxeretomxxtom";
        System.out.println(s1.replaceAll("tom", "TOM"));
        //敏感词过滤
        String s3="你最近身体好吗，你妈身体好吗，你妹妹身体好吗";
        System.out.println(s3.replaceAll("你妈|你妹", "****"));
    }
}

4.可变字符串StringBuffer & StringBuilder

4.1StringBuilder类

用于表示可变字符串的一个类，是非线程安全的，建议在单线程环境下使用。

4.2StringBuffer类

用于表示可变字符串的一个类，是线程安全的，建议在多线程环境下使用。

StringBuilder和StringBuffer中的方法都一致，只不过StringBuffer中的方法使用了synchoronized关键字修饰，表示是一个同步方法，在多线程环境下不会出现问题。

4.3构造方法

常用构造方法	作用
StringBuilder	创建一个大小为16的字符串数组，表示一个空白字符。类似于String str=" ";
StringBuilder(String str)	创建一个str长度+16的字符数组后，将str添加到其中。类似于String str="初始值";

4.4普通方法

常用方法	作用
append（Object obj）	将任意类型的参数添加到原可变字符串末尾
delete（int start ，int end）	删除[ start ,end)区间内的字符
deleteCharAt( int index )	删除index索引上的字符
insert(int index,Object obj)	在索引index上插入obj
replace(int satrt, int end,String str)	将[ start ,end)区间的字符替换为str
reverse()	反转字符串（顺序颠倒）

注意：

1.以上表格中的方法都是在直接操作同一个字符串对象，每次调用方法后，原字符串都会发生变化

2.StringBuffer和StringBuilder并没有重写equals方法，所以可变字符串的值是否相同时，调用的是 equals中原始的==判断。如果要判断两个可变字符串的值是否相同时，需要将其转换为String后调 用equals判断 

5.可变字符串与String之间的转换

5.1String转换为可变字符串

String str="hello";
//通过构造方法将String"包装"为可变字符串对象
StringBuilder sb = new StringBuilder(str);

5.2可变字符串转换为String（任意类型转换为String )

方法一：String.valueOf(Object obj)方法

StringBuilder sb = new StringBuilder("你好");
//调用静态方法
String str =String.valueOf(of);

方法二：对象.toString();

StringBuilder sb = new StringBuilder("你好");
//调用toString()
String str = sb.toString;

 方法三：

StringBuilder sb = new StringBuilder("你好");
//拼接一个空字符串
String str = sb = " ";

5.3String、StringBuilder和StringBuffer的区别

一、相同点：

1.这三个类都可以表示字符串。都提供了一些操作字符串的方法。

2.这三个类中有相同的方法，如charAt()、indexOf()等

3.这三个类都是被final修饰的类，不能被继承

二、不同点：

1.String定义的字符串是一个常量。可变字符串定义的字符串是一个变量

2.String类中的方法，调用后，不会改变原本字符串的值；可变字符串类中的方法，调用后，会改变原本字符串的值

3.StringBuilder是非线程安全的可变字符串类，StringBuffer是线程安全的可变字符串类，其中的方 法被synchronized修饰

注意：

在频繁操作同一个字符串时，一定要使用可变字符串StringBuidler或StringBuffer类的对象，不能使用 String类的对象。

6.Date类

 用于表示日期时间的类，位于java.util包下

6.1构造方法

常用构造方法	说明
Date（）	创建当前瞬间对应的日期对象
Date（long l）	创建指定瞬间对应的日期对象
Date（int year，int month，int day）	该方法已经过时，创建指定年月日的日期对象（年是1970年起经过的年数，月用0-11表示表示1到10月）

6.2常用方法

常用方法	作用
getTime（）	得到对应Date对象表示的毫秒数
setTime（long l）	设置Date对象的毫秒数
after（Date when）	判断调用日期对象是否在when之后
before（Date when）	判断调用日期对象是否在when之前

7.SimpleDateFormat类

7.1构造方法

常用构造方法	作用
SimpleDateFormat（String pattern）	创建一个指日期模板的格式化日期对象

7.2日期模板

特殊字符	作用
yyyy	年份
MM	月份
dd	日期
HH	24小时
hh	12小时
mm	分钟
ss	秒
E	星期
以上两个字母都可以写成一个	M: 5 , MM: 05
yyyy/MM/dd HH：mm：ss   E	2022年12月3日 20:29:24 星期六

7.3常用方法

常用方法	返回值	作用
format（Date date）	String	将Date对象按日期模板转换为字符串
parse（String str）	Date	将满足日期模板的字符串转换为Date对象

package seDay2;
//Date类、
// 日期模板类：SimpleDateFormat
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        //Date中重写了object中的toString方法，获取的当前系统时间
        System.out.println(date);
        //获取时间毫秒数，从1970,1,1日开始
        System.out.println(date.getTime()/1000/3600/24);
        //设置时间毫秒数
        date.setTime(365l*24*3600*1000);
        //设置指定时间  Date类不方便，需使用Calendar类

        //日期格式化
        SimpleDateFormat sdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        //format(Date)将Date类型转为String类型
        System.out.println(sdate.format(date));

        //parse(String) ，将满足日期格式化的字符串类型的日期转换为Date类型
        String birth="2000-4-14  12:30:00 星期五" ;
        System.out.print