JAVA知识总结【持续更新】

参考原文：
原文链接: link.

标识符

字母、下划线、美元符号、数字，第一个不能是数字、不能是保留字

数据类型

常量

final 数据类型 常量名=值
final double p=12313.123d

变量范围

类体中定义的变量在整个类中有效
成员变量：不加static
静态变量：加上static，可以在这个应用程序中使用、跨类、以类名.静态变量的方式取值
局部变量：方法体中变量，局部变量在方法调用结束后销毁，与成员变量名字相同会覆盖

三元运算符

条件式？值1：值2；
由低到高：byte《short《int《long《float《double
低转高直接赋值：float a=12；
高转低强制：int a=(int)123.5f;

String类

String字符串类成为对象
声明：String str
char只能单个字符。
创建：char
1、String s=new String（" “）
2、Strin s=new String（a，index，length）
3、String s=” "
4、字符数组，String str[]={}

字符串格式化

日期格式化
String.format(" ",date)

正则表达式

reg="[]"

连接字符串

+，将两个字符串直接相连
不同类型与字符串相连，会被转换成字符串

获取字符串长度

str.length()

字符串查找

str.indexof(" substring")，既可以查找字符，又可以查找子字符串的第一次出现的索引
str.lastindexof(“substring”)既可以查找字符，又可以查找子字符串的最后一次出现的索引

获取指定位置的字符

str.charAt( int index)返回索引处的字符
str.substring(int beginindex）返回从开始索引位置到最后位置的子字符串
str.substring(int beginindex,int lastindex)返回从开始索引位置到制定结束索引位置的子字符串，但是不包括结束索引的字符

去除字符串前面和后面的空格

str.trim()

字符串替换

str.replace(char/string old,char/string new)原字符串重复多次出现，则会全部替换，且大小写必须保持一致

判断字符串的结尾

startwidth(String)判断是否以字符串开始
endwidth(String)判断是否以字符串结尾
返回的是布尔型

判断字符串是否相同不能用等于，因为它是判断字符串地址是否相同。

用**str1.equals（str2）比较，具有相同字符和长度时，返回true
用str1.equalsIgnoreCase(str2)**比较，忽略大小写。

按照字典顺序比较compareto()

str1.compareto(str2)，str1在str2之前返回-1，之后返回1，相同返回0

大小写转换

toLowercase()转换成小写
toUppercase()转换成大写

分割字符串

str.split(" ")以什么分割符进行分割，返回的是字符串数组；
str.splt(分割字符,分割次数)

格式化字符串

日期时间字符串格式化：String.format(" ")

频繁修改字符串

StringBuilder str=new StringBuilder("stringbuilder");
str.append("");追加内容
str.insert(5,"word");插入内容到指定索引位置
str.delete(3,5);删除内容从3开始到5结束，不包含最后一个索引
输出需要用到str.toString();

StringBuilder str=new StringBuilder()
str.append()
str.insert()
str.delete()
该类的最后要toString()

数组

先声明：
int arr[];
int arr[][];
为其分配内存空间：
arr=new int[5];
arr=new int[2][4];
声明的同时为其分配内存空间
int arr[]=new int[5];
初始化一维数组：
int arr[]=new int[]{1,2,3,4};
int arr[]={1,2,3,4};
int arr[][]={{1,2},{3,4,}};
数组元素类型[] 名字；
数组元素类型 名字[];
数组名字[]=new int[length];
int 数字名字[]=new int[];
初始化
int 数组名字[]=new int[]{1,2,3,4,5}
二维数组：
数组元素类型[][] 数组名字；
数组元素类型 数组名字[][];
数组名字=new int[][]
初始化
int 数组名字[][]=new int[][]{1,2,3,4,5}
int 数组名[][]={{},{}};
数组长度=数组.length;
数组的长度求解用arr.length;与字符串的不同,str.length();

填充替换数组

Arrays.fill(arr,对象)
Arrays.fill(arr,开始，结束，对象)

数组排序

Arrays.sort(obj);升序

复制数组

copyof（arr，length）复制整个数组到指定长度的数组中
copyrangeof（arr，fromindex，lastindex）不包括最后索引

数组查询

查询之前先排序；
Arrays.binarySearch（arr，obj）
Arrays.binarySearch（arr，fromindex，lastindex，obj）

对象关系

1、依赖

依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。与关联不同的是，Person类里并没有Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。
2、关联

关联(Association）关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。
3、聚合

聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便整体和个体的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。
4、组合

组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活，在一些情况下将负责代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，代表部分的对象在每一个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和整体的生命周期一样。

封装、继承、多态

1、封装

封装就是把对象的属性和行为结合为一个独立的整体，并尽可能多的隐藏对象的内部实现细节。
2、继承

对象用来封装数据和功能，但我们要创建一个新类，然而它又与已存在的类具有部分相同的属性或功能，此时，为了代码复用原则，可以使用继承来实现。

继承通过基类和子类的概念来表达，基类的所有特征和行为都可以与子类共享。也就是说，你可以通过基类呈现核心思想，从基类继承的子类则为核心思想提供不同的实现方式。

有时基类和子类的方法都是一样的，这时你就可以直接用子类的对象代替基类的对象，这种纯替代关系通常叫做替换原则。

有时，子类会添加一些新的方法，此时就是不完美替换。
3、多态

通过将子类对象引用赋给父类对象引用来实现动态方法调用。

List<String> list = new ArrayList<String>();

普通类和抽象类

抽象类不能被实例化；
抽象类可以有抽象方法，只需申明，无须实现；
有抽象方法的类一定是抽象类；
抽象类的子类必须实现抽象类中的所有抽象方法，否则子类仍然是抽象类；
抽象方法不能声明为静态、不能被static、final修饰。

接口和抽象类

（1）接口
接口使用interface修饰；
接口不能实例化；
类可以实现多个接口；
java8之前，接口中的方法都是抽象方法，省略了public abstract。②java8之后；接口中可以定义静态方法，静态方法必须有方法体，普通方法没有方法体，需要被实现；

（2）抽象类
抽象类使用abstract修饰；
抽象类不能被实例化；
抽象类只能单继承；
抽象类中可以包含抽象方法和非抽象方法，非抽象方法需要有方法体；
如果一个类继承了抽象类，①如果实现了所有的抽象方法，子类可以不是抽象类；②如果没有实现所有的抽象方法，子类仍然是抽象类。

成员变量和局部变量

（1）在类中的位置不同

成员变量：类中方法外；

局部变量：方法定义中或者方法声明上；

（2）在内存中的位置不同

成员变量：在堆中

局部变量：在栈中

（3）生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

（4）初始化值不同

成员变量：有默认值

局部变量：没有默认值，必须定义，赋值，然后才能使用

对象的创建和声明周期

对象的创建需要消耗一些资源，尤其是内存资源。

当我们不再需要一个对象时，就要及时清理它，这样占用的资源才能被释放并重复使用。

如果要最大化运行时效率，可以通过栈区（局部变量）来保存对象，或者将对象保存在静态区里，这样在编写程序时就可以明确的知道对象的内存分配和生命周期，这种做法会优先考虑分配和释放内存的速度。但是代价就是牺牲了灵活性，因为你必须在编写代码时就明确对象的数量、生命周期以及类型，但是这种写法的限制性很大。

还有一种方案是在内存池中动态创建对象，这个内存池也就堆。如果使用这个方案，直到运行时你才能知道需要多少对象，以及它们的生命周期和确切的类型是什么。如果需要创建一个新对象，可以直接通过堆来创建。因为堆是在运行时动态管理内存的，所以堆分配内存所花费的时间通常会比栈多一些。栈通常利用汇编指令向下或向上移动栈指针来管理内存，而堆何时分配内存则取决于内存机制的实现方式。

Java只允许动态分配内存，每当要创建一个对象时，都需要使用new来创建一个对象的动态实例。

如果在栈中创建对象，编译器会判断对象存在时间以及负责自动销毁该对象。

如果在堆中创建对象，编译器就无法得知对象的生命周期。

Java支持垃圾回收机制，它会自动找到没用的对象将其销毁。

final 和 static

都可以修饰类、方法、成员变量

static可以修饰类的代码块，final不可以

static不可以修饰方法内局部变量，final可以

static修饰表示静态或全局

static修饰的代码块表示静态代码块，当JVM加载类时，只会被创建一次

static修饰的变量可以重新赋值

static方法中不能用this和super关键字

因为this代表的是调用这个函数的对象的引用，而静态方法是属于类的，不属于对象，静态方法成功加载后， 对象还不一定存在。
this代表对本类对象的引用，指向本类已创建的对象。 super代表对父类对象的引用，指向父类对象。
静态优先于对象存在，方法被static修饰之后，方法先存在，所需的父类引用对象晚于该方法的出
现，也就是super所指向的对象还没出现，当然就会报错。

static方法必须被实现，而不能是抽象的abstract

static方法只能被static方法覆盖

final修饰表示常量、一旦创建不可被修改

final标记的成员变量必须在声明的同时赋值，或在该类的构造方法中赋值，不可重新赋值

final方法不能被子类重写

final类不能被继承，没有子类，final类中的方法默认是final的

final不能用于修饰构造方法

private类型的方法默认是final类型的

final、finally、finalize

final可以修饰类，变量，方法，修饰的类不能被继承，修饰的变量不能重新赋值，修饰的方法不能被重写

finally用于抛异常，finally代码块内语句无论是否发生异常，都会在执行finally，常用于一些流的关闭。

finalize方法用于垃圾回收。

一般情况下不需要我们实现finalize，当对象被回收的时候需要释放一些资源，比如socket链接，在对象初始化时创建，整个生命周期内有效，那么需要实现finalize方法，关闭这个链接。

但是当调用finalize方法后，并不意味着gc会立即回收该对象，所以有可能真正调用的时候，对象又不需要回收了，然后到了真正要回收的时候，因为之前调用过一次，这次又不会调用了，产生问题。所以，不推荐使用finalize方法。

Date

描述：类 Date 表示一个特定的瞬间，精确到毫秒。
构造函数

方法	描述
Date()	分配一个 Date 对象，以表示分配它的时间（精确到毫秒）
Date(long t)	分配一个 Date 对象，表示自从标准基准时间起指定时间的毫秒数

/*本类用于Date的入门*/
public class TestDate1 {
    public static void main(String[] args) {
        //1.利用无参构造创建Date类对象，注意导包：import java.util.Date;
        Date d1= new Date();
        System.out.println(d1);//Thu Sep 23 23:14:59 CST 2021

        //2.利用含参构造创建Date对象
        long t = 1000*60*60;//1000ms*60*60->1min*60->1h
        Date d2 = new Date(t);//从标准基础时间1970-1-1-00:00开始往后数1h
        System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
        //CST是中国时区，所以额外加了8h变成了09:00:00
    }
}

Date的常用方法

/*本类用于Date的常用方法测试*/
public class TestDate2 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date d1 = new Date();
        //2.获取从标准基准时间到现在时间的毫秒值，是一个时间差
        System.out.println(d1.getTime());//1632404114206
        //*1.0是为了变成浮点型，/1000变成秒，/60变成分，/60变成小时，/24变成天，/365变成年
        System.out.println(d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365);//约等于51,从1970到2021

        //3.打印d1就是当前的时间
        System.out.println(d1);//Thu Sep 23 21:39:29 CST 2021
        //4设置一个long值，作为毫秒为单位的时间差
        long t = 1000*60*60;
        d1.setTime(t);
        System.out.println(d1);//打印的就是从标准基准时间经过时间差t的时间
    }
}

SimpleDateFormat

描述：SimpleDateFormat 常用于格式化和解析日期

构造函数
SimpleDateFormat() ：用默认模式的日期格式
SimpleDateFormat(String pattern) ：用给定模式的日期格式

日期转换格式工具类

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

/*本类用作日期类的工具类，一般工具类的要求：
 - 构造方法私有化 & 成员方法静态化*/
public class DateUtils {
    //1.创建一个私有化的构造方法
    private DateUtils(){}

    //2.创建一个将日期转换为字符串的方法
    //参数：日期对象Date  日期转换的格式：format 返回值类型：String
    public static String dateToString(Date date, String format){
        //1.通过传入的日期格式，创建指定的工具类对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        //2.通过工具类对象将字符串转换为对应的日期字符串，并拿到转换后的字符串结果
        String s = sdf.format(date);/*转换*/
        //3.将最终转换的字符串结果返回
        return s;
    }

    //3.创建一个将字符串转换为日期的方法
    //参数：字符串对象String  日期转换的格式：format 返回值类型：Date
    public static Date stringToDate(String s, String format) throws ParseException {
        //1.通过传入的日期格式，创建指定的工具类对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        //2.通过工具类对象将日期对象转换为对应的字符串，并拿到转换后的日期对象
        Date d = sdf.parse(s);/*解析*/
        //3.将最终转换的日期对象作为方法的结果返回
        return d;
    }
}

集合

HashMap

• HashMap集合底层结构是 数组 + 单向链表 + 红黑树。
• HashMap集合中的key、value均可为 null，其中key是无序不可重复的。
• HashMap集合的默认初始化容量是16，默认加载因子是 0.75，扩容之后是原容量的2倍。
• 如果HashMap集合中某个桶中的结点数超过了8，则单向链表结点会被替换成红黑树结点；当桶中的结点数小于6时，会将树形结点转回单向链表结点。只有当哈希表中的元素数量超过64时，才会进行树形化（即转换成红黑树这种结构）。否则只是进行扩容。

HashMap属性

//默认的初始容量为 2^4=16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
 
//最大的容量上限为 2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
 
//默认的加载因子为 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
//变成树型结构的临界值为 8
static final int TREEIFY_THRESHOLD = 8;
 
//恢复链式结构的临界值为 6
static final int UNTREEIFY_THRESHOLD = 6;
 
//当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突
static final int MIN_TREEIFY_CAPACITY = 64;
 
//哈希表
transient Node<K,V>[] table;
 
//哈希表中键值对的个数
transient int size;
 
//哈希表被修改的次数
transient int modCount;
 
//它是通过 capacity*load factor 计算出来的，当 size 到达这个值时，就会进行扩容操作
int threshold;
 
//加载因子
final float loadFactor;

单例设计模式

解决的问题：保证一个类在内存中的对象唯一性。

懒汉式

//懒汉式:延迟加载方式。
class Single2{
    private Single2(){}
private static Single2 s = null;
    public static Single2 getInstance(){
        if(s==null)
            s = new Single2();
        return s;
    }
}

饿汉式

//饿汉式
class Single{
    private Single(){} //私有化构造函数。
private static Single s = new Single(); //创建私有并静态的本类对象。
    public static Single getInstance(){ //定义公有并静态的方法，返回该对象。
        return s;
    }
}

案例

九九乘法表

for循环

for(int i=0;i<=9;i++){
     for (int j=1;j<=i;j++){
        System.out.print(i+"*"+j+"="+i*j+" ");
      }
 System.out.println();
}

do while

int i=9;
do{
    int j=1;
    do{
        System.out.print(i+"*"+j+"="+(i*j)+" "+"\t"); //   "\t"这是Java语言默认的制表符号
        j++;
    }while(j<=i);//大于i之后跳出循环
 
    System.out.println();
    i--;
}while(i>=1);//小于1之后跳出循环