Java基础知识点

来到构造器这边，调用 重载的构造器，传入参数 10（默认长度）

存储数据的数组

进入add方法

开发中使用带参构造器 : ArrayList list = new ArrayList(int capacity)

来到构造器这边，给了一个 DEE 给 elementData

存储数据的数组

进入add方法

Arraylist list = new ArrauList(); // 地城Object[] elementData 初始化为{}，并没有创建长度为10的数组

list.add(123); //第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData中
...
后续的添加和扩容操作与 jdk7 无太大差别，基本一致

modCount++ 先不讲，是一个快速失败机制的

elementCount（eC） = 当前元素长度

进入 ensureCapacityHelper
添加之前肯定要确保当前的容量足够，先调用一下保证没问题

第三行是赋值操作，且没问题返回true

add，把形参元素作为整体添加

addAll，把形参元素分别添加

在最后位置插入元素

移除指定index位置的元素，并返回此元素

删除指定元素

设置指定index位置的元素为ele

查询index位置的元素

从index位置开始将eles中的所有元素添加进来

查询当前长度

对应的类一定要重写 equals()和hashCode()方法，以实现对象相等规则

数组+链表的结构

HashMap

在HashSet原有的基础之上，每个维护了两个引用（pre、next）以此来记录前一个数据和后一个数据
类似双向链表，来记录我们的添加顺序

看到没有，其实还是调用 HashMap 那边的put方法

就是相当于把 HashSet 一个数据 存到 HashMap 的 key 位置，
存储的 Value 就是默认的 PRESENT 常量

1.  调用 HashMap 的 put 方法，存储数据

比较两个对象是否相同的标准

比较两个对象是否相同的标准

使用方式

还没开始遍历，你要删

当前指向删过一次了，还要删

HashMap 的 key

LinkedHashMap 的 key

TreeMap 的 key

以此类推

导致：value 所在的类要重写 equals()

在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素

LinkedHashMap.Entry 类继承了 HashMap.Node
但是自己多声明了两个属性，before，after

1. 调用hash()得到key的hash值

这边和HashMap JDK8 那边完全一致，那么不同在哪里呢？
就是第3步，里面有个newNode，这个方法被重写了

调用 putValue()：噩梦来啦哈哈哈哈哈

DEFAULT_INITIAL_CAPACITY

DEFAULT_LOAD_FACTOR

来到HashMap(16, 0.75)

1. 判断当前key是否为null，若是，那也放进去

2. 让当前hash = key的hash值经过一系列算数得到一个值
注意：这个hash值并不是我们在数组中存放的位置

3. 经过indexFor()，得到存放位置i

4. 遍历for，进来细说这部分

5. 若上面判断为false往下走

6. modCount++

7. 调用addEntry 添加key-value

8. 返回空

①处说明

关于情况2和情况3

在不断的添加过程中，会涉及到扩容问题，当超出扩容临界时（且要存放位置非空），则开始扩容。
默认的扩容方式：扩容为原来的2倍，并将所有的数据复制过来

把当前加载因子 赋值为 0.75

然后啥也没做了

实际上这个类 确实 是实现了 Entry

1. 调用hash()得到key的hash值

调用 putValue()：噩梦来啦哈哈哈哈哈

new HashMap()

底层的数组是：Node[]，而非Entry[]

首次调用put()方法时，底层创建长度为16的数组

底层结构

为啥是0.75，这个值是影响着 大概你存到多少数据时 开始准备扩容的
    太大，可能你同一个位置会出现链表太多
    太小，可能你压根没存多少就扩容了 

容量 * 填充因子 =

默认 16 * 0.75 = 12

compareTo()返回0

而不是equals()

compare()返回0

而不是equals()

声明Comparator对象，并重写compare()方法

最后在声明 TreeMap 时，把Comparator对象传参定义就好。
TreeMap map = new TreeMap(com);

实例

涉及到流的部分就不细讲多余操作了，详情细则去IO流那边

若是你在idea中读取properties时，里面有中文，但是读取出来成了乱码

可能是以下没有设置

编译

他调用该构造方法，把传入的 list 存入了他的属性中

那么关键点来了，他这个类里重写了很多 同步方法。（图片只截了部分）
所以才能实现 线程安全

编译

异常

看下这个copy()方法原理

也就是说，你的源集合，里面包含的元素 一定要大于 copy过来的目标集合
不然就报错

创造少了元素

创造多了元素

正确操作

导入了Map，就可以直接Entry

不能向其内部添加数据，除了添加null以外

允许读取数据，取得类型为Object

读取数据

写入数据

只允许泛型为实现Comparable接口的实现类的引用调用

写入数据

读取数据

记得转成char

只写操作，抛异常那些自己注意

对于数据读入可以这么写

输出操作，对应的 File 可以不存在

File对应的硬盘中的 文件是否存在

读取一行

实例

注意

默认缓冲区大小 8192 = 8 * 1024

使用系统默认的字符集

每次读取一个字符，返回int（unicode字符唯一编码）

实例

源码说明

标准的输入流

默认输入设备

标准的输出流

默认输出设备

只写具体步骤，处理异常省略了，自己加。

只写具体步骤，处理异常省略了，自己加。

从而允许把这种二进制流持久地保存在磁盘上

或通过网络将这种二进制流传输到另一个网络节点

因此序列化机制是 JavaEE 平台的基础

1. 需要实现接口 Serializbale

2. 当前类提供一个全局常量：serialVersionUID（序列版本号）

3. 其属性也必须保证是可序列化的（基本数据类型、string本可序列化）

反序列化时，JVM会把传来的字节流中得到serialVersionUID与本地相应实体类的serialVersionUID进行比较

相同

不相同

如上

获取文件记录指针的当前位置

将文件记录指针定位到 pos 位置

文件若不存在，则会出现异常

若文件存在，则不会创建

若写数据过程中发生异常，
“rw”模式则会全部丢失；
“rwd”模式中已被write的数据会被保存到硬盘

用于将多个字符串连成路径

返回指定uri对应的path路径

Future接口

// 1. 实现一个Callable的实现类
class A implement Callable {

    // 2. 实现call()方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        //方法体
        return 返回值
    }
}

public class XXX {
    main(){
         
        // 3. 创建Callable接口实现类的对象
        A a = new A();

        // 4. 将此Callable接口实现类的对象作为传递参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask f = new FutureTask(a);

        // 5. 调用start()，启动线程
        new Thread(f).start();
        
        try {
            
            // 6. 获取Callable中call方法的返回值
            // get()返回值就是 FutureTask构造器参数Callable实现类重写的call()的返回值
            Object xxx = f.get();

        } catch (XXX x) {
            // 略
        }

    }
}

减少了创建新线程的时间

重复利用线程池中线程，不需要每次都创建

corePoolSize

maximumPoolSize

keepAliveTime

...

真正的线程池接口

常见子类

常见方法

返回线程优先值

如

改变线程的优先级

如

多个线程共同操作的变量

比如

多个线程必须要共用一把锁

在继承Thread类创建多线程的方式

在实现Runnable接口创建多线程的方式

一旦执行方法，都可以让线程进入阻塞状态

两个方法声明的位置不同

调用的范围不同

是否释放监视器

如果你就单纯定义不带任何属性的枚举对象，就是这么简单

若不重写toString方法，默认打印属性名

字符串必须是枚举类对象的“名字”

若不是，会出现运行时异常 IllegalArgumentException

interface YYY{
    void AAA();
}

class Xxx implements YYY{
    //1.提供当前枚举类的对象多个对象之间用“，”隔开，末尾对象“；”结束；相同部分声明基本删除   
    x1("XXX1"){
        public void AAA(){ //x1对应方法体 };
    },
    x2("XXX2"){
        public void AAA(){ //x2对应方法体 };
    };   
    ...

    //1.声明Xxx对象的属性
    private final String name;

    //2.私有化类的构造器，并给对象赋值
    private Xxx(String name){
        this.name = name;
    }

    //4.其他诉求：获取枚举类对象的属性、重写toString()
    ...
}

这种情况，value就可省略了

源文件保留

class保留

默认值

运行时保留

可通过反射获取该注释

TYPE_PARAMETER

TYPE_USE

把标有@Inherited注解的自定义的注解标注在类级别上，
子类则可以继承父类级别的注解

4个字节组成

4个 0-255

以点分十进制表示

如

128位（16个字节）

8个 无符号整数，每个整数用4个十六进制位表示

以冒号分十六进制表示

如

公网地址

私有地址

范围：192.168.0.0 - 192.168.255.255

通过ip/域名参数获取到对应的InetAddress对象

参数

实例

得到本地对应的 InetAddress对象

实例

获取InetAddress对象的域名/主机名

获取InetAddress对象的ip地址

Http

Ftp

TeInet

指定源地址和目标地址

加密解密

压缩解压缩

差错控制

流量控制

路由控制

把复杂的成分分解成一些简单的成分，再将他们复合起来

即同层间可以通信、上一层可以调用下一层，而与下一层不发生关系

各层互不影响，利于系统的开发和拓展

客户端

服务端

在socket编程中，任何一方执行close()操作即可产生挥手操作

构造函数

实例

DatagramSocket 和 DatagramPacket 实现了基于UDP协议网络程序

UDP数据报通过数据报套接字DatagramSocket发送和接收，
系统不保证UDP数据报一定能够安全送到目的地，也不确定什么时候可以抵达

DatagramPacket对象封装了UDP数据报，
在数据报中包含了 发送端 的IP地址和端口号 和 接收端 的IP地址和端口号

UDP协议中每个数据报都给出了完整的地址信息，
因此无需建立发送方和接收方的连接，如同发快递一样

发送端

接收端

实例

以cafe开头

没有安全方面的问题

先去用户加载器有没有这个包

再去扩展加载器有没有这个包

再去根加载器有没有这个包

通过反射我们还没有办法获取到方法形参的名的

后来版本有提供（但其实我们用的很有限）

子主题

表示一种参数化类型

参数类型集

表示一种元素类型是参数化类型或者类型变量的数组类型

参数内泛型集

是各种类型变量的公共父接口

代表一种通配符类型表达式

本类的方法

Main

编译运行

编译

被代理类的ClassLoader

obj.getClass().getClassLoader()

被代理类的接口

obj.getClass().getInterfaces()

实现InvocationHandler接口的类的对象

可以使用反射获取代理对象的信息

可以将代理对象返回以进行连续调用

即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法

方法参数

若不使用Lambda

int数组的声明方式

泛型省略声明

前提

Lambda

方法引用

前提

Lambda

方法引用

前提

Lambda

方法引用

前提

原方法

Lambda

方法引用

前提

原方法

Lambda

方法引用

前提

原方法

Lambda

方法引用

前提

原方法

Lambda

方法引用

Supplier<Employee> sup = new Supplier<Employee>() {
    @Override
    public Employee get() {
        return new Employee();
    }
}

Supplier<Employee> sup = () -> new Employee();

Supplier<Employee> sup = Employee :: new;

Function<Integer, Employee> fun = id -> new Employee(id);

Function<Integer, Employee> fun = Employee :: new;

Function<Integer, String, Employee> fun = (id, name) -> new Employee(id, name);

Function<Integer, String, Employee> fun = Employee :: new;

default Stream<E> stream()

default Stream<E> parallelStream()

static <T> Stream<T> stream(T[] array)

可以调用Stream类静态方法of()，
通过显示值创建一个流。
它可以接收任意输了的参数。

public static <T> Stream<T> of(T... values)

实例

public static <T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

public static <T> Stream <T> generate(Supplier<T> s)

可以很大程度提高程序的执行效率

filter(Predicate p)

limit(long maxSize)

skip(long n)

distinct()

map(Function f)

maptoDouble(ToDoubleFunction f)

mapToInt(ToIntFunction f)

mapToLong(ToLongFunction f)

flatMap(Function f)

sorted()

sorted(Comparator com)

allMatch(Predicate p)

anyMatch(Predicate p)

noneMatch(Predicate)

findFirst()

findAny()

count()

max(Comparator c)

min(Comparator c)

forEach(Consumer c)

reduce(T iden, BinaryOperator b)

reduce(BinaryOperator b)

备注

collect(Collectors c)

例一

例二

使用“return 数据”

三码合一

原码

反码

补码

例子1

也叫对象变量、类成员变量

也叫静态变量，是一种比较特殊的实例变量，用static关键字修饰

使用，‘’内部

不使用

基本数据类型中，其余类型不带布尔类型一起玩的

必须保证符号左右两边的变量类型一致

1字节 - 8位

共 32位

除符号位，取反+1

数组的初始化和数组元素的赋值操作 同时进行

int[] ids = new int[]{1, 2, 3, 4,5};

int[] ids = {1, 2, 3, 4,5};

数组的初始化和数组元素的复制操作 分开进行

String[] names = new String[5];

基本数据类型

引用数据类型

存储

存储

常量池

静态域

到数组目前只用到栈和堆

静态初始化

动态初始化

for(int i = 0; i < arr.length; i++) {
    for(int j = 0; j < arr[i].length; j++) {
        sout(arr[i][j]);
    }
}

针对初始化方式一

针对初始化方式二

不同情况的 访问二维数组外层与内层的区别

数组创建操作时，内存分析

直接选择排序

堆排序

冒泡排序

快速排序

直接插入排序

折半插入排序

Shell排序

类的设计

= 成员变量 = filed = 域、字段

直接定义在类的 {} 内

变量的作用域 /
                    / 按照声明位置分类变量

属性赋值的先后顺序

行为 = 成员方法 = 函数 = method

方法的声明

方法的使用

深入一层

又名 构造方法

构造器的定义

构造方法的重载

一个类中，至少会有一个构造器

一个类中，至少会有一个构造器

创建类对象

初始化对象的属性

注意

new出来的

我们都选择省略“this.”

如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式

“this(形参列表)”必须声明在当前构造器的首行

在同一个类种

“两同一不同”

注意

子类也可以定义父类同名不同参来实现重载

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

重写以后，当创建子类对象以后，通过子类对象调用字父类中的同名同参数的方法时，实际执行的是子类重写父类的方法

正常方法调用

虚拟方法调用

看左边

看右边

即向下转型

看左边

是

否

Tip

最终结果：父类转成子类

不相关类转换

静态变量随着类的加载而加载

静态变量的加载要早于对象的创建

由于类只会加载一次，则静态变量再内存中也只会存在一份：存在方法区的静态域中

调用         类变量         实例变量
类              yes                 no
对象           yes                yes

栈

堆

方法区

类变量 vs 实例变量 内存解析

静态方法随着类的加载而加载

调用         静态方法         非静态方法
类              yes                 no
对象           yes                yes

静态方法中，只能调用静态的方法或属性

在静态的方法内，不能使用this关键字、super关键字

关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

非静态方法中，既可以调用非静态方法或属性，也可以调用静态的方法或属性

Math

Arrays

Collections

调用方法时传参赋值

那么只能对他进行调用，不能修改

若子类重写了父类中的所有的抽象方法后，此子类可实例化

若子类没有重写父类（或间接父类）中所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

但是书写时，可以省略不写

但是书写时，可以省略不写

这里虽然把public删除了

但是权限依旧是public，请注意

接口中定义的静态方法，只能通过接口来调用

通过实现类的对象，可以调用接口中的默认方法

如果实现类重写了接口中的默认方法，调用时，仍是调用重写以后的方法

如果子类（或实现类）继承的父类和实现的接口中声明了同名同参的默认方法，
那么子类在没有重写此类方法的情况下，默认调用的是父类中的同名同参数的方法

如果实现类实现了多个接口（无 继承 含同名方法的父类 情况），而这多个接口中定义了同名同参数的默认方法，
那么在实现类没有重写此方法的情况下，报错。--> 接口冲突

解决方式：在实现类中重写此方法

如何在子类（或实现类）的方法中调用父类、接口中被重写的方法

调用父类的方法

调用接口中的默认方法

如

u1s1，final修饰后的类本来就不能被继承

创建 非静态的 内部类实例时

外部类.内部类 bird = new 外部类.内部类(); 是错的，因为非静态，你不能这么调用

比如一个方法，要求你返回指定类对象，
这时候就可以在方法内定义内部类

私有化类的构造器

内部创建类的对象

提供公共的静态方法，返回类的对象

由于静态方法调用，则此对象也必须声明为静态的

私有化类的构造器

声明当前类的对象，没有初始化

提供公共的静态方法，返回类的对象

由于静态方法调用，则此对象也必须声明为静态的

优点

缺点

优点

缺点

Runtime类

数据库连接池

网站的计数器

项目中，读取配置的类

这不是设计模式，就是简单的new罢了

其实可以看作 包含 在 工厂方法模式 里的

广义上

Tip

屏蔽对真实角色的直接访问

通过代理类处理远程方法调用（RMI）

先加载轻量级的代理对象，真正需要再加载真是对象

如

静态代理（静态定义代理类）

动态代理（动态生成代理类）

√JDK自带的动态代理，需要反射等知识

1、职责清晰。 2、高扩展性。 3、智能化。

1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。

2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。

但是某些部分易变，易变部分可以抽象出来，供不同子类实现。

这就是一种模板模式。

FileNotFoundException

Object类中定义的 equals() 和 == 的作用是相同的。

比较两个对象的实体内容是否相同

带地址版

调用方法的字符串 > 被比较字符串

调用方法的字符串 < 被比较字符串

true

false

true

false

true

false

Xxx.parseXxx(str)

String.valueOf(xxx)

xxx + ""

String(char[])

String(char[], int offset, int length)

public char[] toCharArray()

将字符串中的全部字符存放在一个字符数组中

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

将指定索引范围内的字符串存放到数组中

编码的逆过程

看不懂的二进制数据 ---> 看得懂

解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码

String(byte[])

String(byte[], int offset, int length)

String(byte[], String charsetName)

看得懂 ---> 看不懂的二进制数据

public byte[] getBytes()

public byte[] getBytes(String charsetName)

编译

可以看到

创建一个对应当前时间的Date对象

创建指定毫秒数的Date对象

获取自1970年1月1日 00:00:00 GMT 以来此Date对象表示的毫秒数（时间戳）

实例

把此Date对象转换为 以下形式的 String: 
    dow mon dd hh:mm:ss zzz yyyy

显示当前的年、月、日、时、分、秒

日期 -> 文本

文本 -> 日期

默认的模式和语言环境创建对象

该构造方法可以用 参数pattern 指定的格式创建一个对象，该对象调用

格式范例

实例

日期 -> 文本

String format(Date date)

Date parse(String source)

1月是0，以此类推，12月是11

周日是1，以此类推，周六是7

比如当前日期是一年第几天、一个月第几天、一个星期第几天...

比如当前日期是一年第几天、一个月第几天、一个星期第几天...

实例

值改为负数即可

实例

可变性

偏移性

格式化

不是线程安全的，不能处理闰秒...

本地日期

代表IOS格式（yyyy-MM-dd）的日期

本地时间

表示一个时间，非日期

本地日期时间

表示时间+日期，这是最常用的类之一

瞬时（Instant）

概念

常见方法

一个在ISO-8601日历系统时区的日期时间

其中每个时区对应着ID，地区ID都为“{区域}/{城市}”

如

持续时间

用于计算两个“时间”间隔

该类包含了所有的时区信息，一个时区的ID

如

使用时区提供堆当前即时、日期和时间的访问的时钟

日期间隔

用于计算两个“日期”间隔

预定义的标准格式

本地化相关格式

自定义格式

日期 --> 字符串

format(TemporalAccessor t)

字符串 --> 日期

DateTimeFormatter对象.parse(CharSequence text)

将日期调整到“下个工作日”等操作

firstDayOfXxx()

lastDayOfXxx()

nextXxx()