java 思维导图模板_ProcessOn思维导图、流程图

IO

in/out相对于程序而言的输入(读取)和输出(写出)的过程，根据处理数据单位的不同，分为字节流（二进制文件）和字符流（文本文件）

File文件流

字节流

InputStream(字节流读:从磁盘到程序的过程)

FileInputStream

File file=new File("path") IntputStream in1=new FileInputStream(file)

InputStream in2=new FileInputStream(new File("path"))

InputStream in3=new FileInputStream("path")

BufferedInputStream(缓冲流/高级流)

InputStream in=new BufferedInputStream(new FileInputStream("path"))

OutputStream(字节流写:从程序到磁盘的过程)

FileOutStream

OutputStream out=new FileOutputStream("path"，true)；

BufferedOutputStream(内部缓存区)

OutputStream out=new BufferedOutput(new FileOutputStream("path",true))追加模式

对象流:

增强了缓冲区的功能

ObjectOutputStream

ObjectInputStream

字符流

FileReader

FileWriter

集合

Collection(接口)

List(子接口 extends Collection)

ArrayList(实现类 implements)

1.底层是数组结构

2.有序+有索引+可重复+null

3.适合查询

LinkedList(实现类 implements)

1.底层是链表结构

2.适合增删

Set(子接口 extends Collection)

HashSet(实现类 implements)

1.底层是哈希表结构(实例的默认初始容量是16，加载因子是0.75)

2.维护了一个HashMap

TreeSet

Map(接口常用于存储键值对结构的数据其中键不能重复,值可以重复)

HashMap(实现类)

底层是由数组Node[ ] tab+链表形成

底层存储数据时，本质是像桶里添加数据，默认容量是16，当达到16的0.75阈值后，再增加的数据rehash开辟空间

计算数据的存储位置--哈希算法/HashCode()---hash(key)

这个位置存过数据吗？如果没存过，就当作一个数组的节点直接存入数组中

存过数据(Hash冲突)--形成链表来保管数据

1. key不重复，形成链表节点直接存在链表上

2. key重复，找到链表上以前存在的value并覆盖

3. 为了优化链表的查询效率，JDK1.8把数据优化成了树状结构

3.1 如果链表节点>=8,就把节点转为树状节点，提高查询效率

3.2 如果树状的节点数<6,就形成链表结构

TreeMap

多线程

进程正在进行的程序(一个软件的运行需要依赖多个进程)

线程(Thread t=new Thread) 是系统可以调度的最小单位，是进程的实际运作单位(一个进程运行可以依赖多个线程)

多线程编程

MyThread t=new MyThread class MyThread extends Thread

实现Runnable接口

MyRunnable target=new MyRunnable Thread t=new Thread(target) class MyRunnable implements Runnable

并发:多个资源抢占cpu,让cpu干活

并行:多个资源去干活，只不过有多个cpu,没有发生抢占的现象

同步锁synchronized

同步：有排队现象，需要等待--好处是安全，坏处低效

1.把有问题的代码加锁--同步锁

同步是没有钥匙就排队等待状态，把操作共享资源的代码锁起来

2.语法

1.方法上 public synchronized void append()

2.代码块上 synchronized(锁对象)--这个对象可以任意，但是必须是同一对象有问题的代码

异步：不等，抢--好处是高效，坏处是不安全

注解

JDK注解 @Override

元注解

@Target 用在类上，方法上，属性上

@Retention 注解的生命周期：源文件中，class文件中，运行中

自定义注解

反射

JVM通过反射技术来解析.class文件的所有数据

原理

1.通过类的加载器，把java里的类加载进内存，然后通过编译器把java文件编译变成.class文件

2.JVM拿到.class文件，开始解析里面的所有资源，把.class文件封装成Class对象

3.通过Class工具类提供的getXxx(),获取各种资源

用Class工具类的方法

1.getConstructors()--获取所有的

2.getFields()--获取所有的公开的成员变量们

3.getMethods()--获取所有公开的成员方法们

获取Class对象的方法

Class.forName("类的全路径");

两种实现多线程的优缺点

extends Thread

优点:Thread类提供的方法多一些,调用功能更方便

缺点:单继承,和子类之间是强耦合关系,占用唯一继承的权力

implements Runnable

优点:可以多实现，扩展性强

缺点:方法太少,就一个run(),其他方法都得用Thread提供的--Thread.currentThread（）

socket编程

把抽象的数据在网络间传输

Junit(单元测试框架)

可以不用添加main函数,也不用创建一个类的实例就可以执行一个方法

1.方法必须是公共的(public)

2.方法必须是非静态的

3.方法必须是无返回值的

4.方法必须是无参的

常用三个注解:@Test @before @after

每次执行@test标记的方法之前都会执行@before标记的方法

每次执行@test标记的方法之后都会执行@after标记的方法

面向对象

三大核心

封装

隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式

private 被私有化的成员只能在本类中访问，想要修改，对外界提供get/set方法

继承extends

从已有类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力

重写

存在于父子类之间，子类定义的方法与父类定义的方法具有相同的方法名，相同的参数列表和相同的返回值类型

修饰符：范围可以扩大，但不能被缩小:Public>Protected>Default>Private

抛出的异常，范围可以缩小，但不能扩大:ClassNotFoundException-->Exception(大)

多态

多态是同一个行为具有多个不同表现形式或形态的能力

构成条件

要有继承

要有方法重写

父类引用指向子类对象 Animal a=new Dog();方法声明用的父类，方法体用的子类

构造方法

用来完成对象的创建和初始化；当实例化一个对象时，会自动调用构造方法(new触发)

是一个特殊方法(没有返回值的位置；方法名就是类名)

构造代码块

类里方法外的代码块

通常用于抽取构造方法中的共性代码

每次调用构造方法前先调用构造代码块

局部代码块

方法里的代码块

通常用于控制变量的范围，变量范围越小越好

静态代码块

在类加载时就加载，并且只被加载一次，一般用于项目的初始化

方法重载

同一个类中有多个方法具有相同的名字，但这些方法具有不同的参数列表

this和super关键字

this

this当前类的实列对象

this. 表示当前类的；用于区分被同名局部变量覆盖成员变量

没有继承也可以使用

super

super当前类的父类的实列对象

super.当前类的父类的属性和行为；用于区分子类同名方法重写的父类的方法

注意

super调用父类的构造方法，必须在构造方法的第一个

super必须出现在子类的方法或者构造方法中

super和this不能同时调用构造方法

super只能在继承条件中使用

static关键字

静态在JVM中常驻内存；从加载JVM开始到JVM运行结束为止

特点

可以修饰成员变量，成员方法

随着类的加载而加载，优先于对象加载

只加载一次就会一直存在，不在开辟新空间

全局唯一，全局共享

可以直接被类名调用

静态资源不能被重写

static不能和this和super公用，因为有static可能还没有对象

final关键字

final可以修饰类，方法。变量(成员变量和局部变量)

final修饰的方法不能被子类重写

final修饰类，这个类不能被继承

抽象类abstract

可以修饰类和方法

抽象类中可以没有抽象方法(由子类去实现)

如果类中有抽象方法，那么该类一定是一个抽象类

子类继承抽象后，要么还是一个抽象类，要么把所有抽象类重写

抽象类不能被实例化

接口

接口中都是抽象方法

interface关键字创建接口;通过implements让子类去实现

接口是一个特殊的抽象类

接口和类之间可以多实现，接口和接口之间可以多继承

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

异常

int hashCode()--哈希码值可以理解为编号

程序中出现的bug,并封装成一个异类，异常之后的代码不会被执行，非要执行放在finally里(顶级父类Throwable)

异常处理

捕获try...catch..finally 抛出 throw throws

抛出方法声明上加throws Exception 方法里throw Exception

API工具类

Object工具类

String toString()--默认返回对象在内存中的地址值,重写后返回对象的属性值

equals(Object obj)--判断某个对象是否与此对象相等,比地址值就是false

==比较基本类型的值时，比的是数值本身；比较引用类型的值时，比的是地址值

String工具类

public final class String是一个最终的类，不能被继承

底层会创建一个char[]来存放字符串数据，本质是一个数组

一旦被创建，长度不能被改变，而且数组被final了，值不能改，是一个常量

StringBuilder/StringBuffer

用来进行字符串的拼接的优化(append)

StringBuffer

可变长字符串，运行效率慢，线程安全

StringBuilder

可变长字符串，运行效率快，线程不安全

包装类(默认h值null)

把8种基本类型纳入面向对象的知识体系结构，而采用面向对象的方式对8种基本类型进行封装

Byte Short Integer Long Character Float Double Boolen

抽象类Number

是包装类的超类，提供了方法，把包装类变回基本类型

自动拆箱/自动装箱

装箱

把基本类型转换为包装类型 Integer in=Integer.valueOf(5)-----------高效的缓存，如果数据在-127~128之间，相同数据只寸一次

拆箱

把包装类转换成基本类型 int a=in.intValue()

日期类date

类Date表特定的时间，精确到毫秒

日期工具类SimpleDateFormat

把String类型的日期和Date类型的日期互转

String->Date Date parse(String text)

Date->String String format(Date date)

BigDecimal/BigInteger

BigDecimal 用来解决小数运算不准确的问题

BigInteger 用来解决超大的整数运算