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

数据类型

数组,也是引用数据类型

动态数组

int[] num[] = new int[5],定义长度为5的数组

先定义分配空间，再赋值num[1]=2……

静态数组

int[] i = new int[]{1,2,3,4,5}，先知道了具体元素赋值

int i = {1,2,3,4,5}

二维数组

动态定义： int[][] i = new int[3][5],定义一个3行5列的二维数组

动态定义：int[][] i = new int[3][]

i[0] = new int[2]; i[1] = new int[8]....在定义一位数组长度

静态定义 int[][] num = {{1,2,3,4},{2,3,4,56,7,8},{6,7,8}}

num[0].length为二维数组中第一个一维数组长度，这里为4    num.length为二维数组长度，即有多少个一维数组

类数组

Cat[] cat = new Cat[2],创建2个Cat类的数组

创建好后，每个都要实例化才行，cat[0] = new Cat(),不然指针报错

基本数据类型

整型

整型数据默认为int型，再long以下整型运算默认为int型

4大整型中只有long型有后缀名L/l，且需要协商才可,long a=1L

浮点型

浮点型默认为double型，浮点型运算时哪个类型大转哪各类型

浮点型中float 后缀为f,double 后缀为d

字符型

字符型char，赋值要加''，里面仅能为一个数字，一个英文或一个中文

字符型能转化成int、long、float、double，一般默认转为int

char 能转为其他类型，但其他类型装为char要强转

布尔型

引用数据类型

String字符串类型，""为字符串

类 class

接口 interface

函数/方法

在类里面，访问修饰符返回值类型方法名(参数){方法体}

void不用return，其他都要有相对应的return放回置

方法重载

参数数量不同

数量相同参数类型不同，顺序不同

类

外部类

类实例化

类的实例化 Cat cat = new Cat();

类数组

Cat[] cat = new Cat[2],创建2个Cat类的数组

创建好后，每个都要实例化才行，cat[0] = new Cat(),不然指针报错

类的构造方法

在类实例化时候，会自动调用，可以重载

在子类继承时候，子类的构造方法中会自动调用父类的构造方法 也就是子类实例化，会暗中也实例花了父类，所以先输出费雷狗仔方法，在输出子类

类的属性与方法

static修饰的属性和方法都是属于类的，不实例化即可用

priavte修饰的属性外界不能直接访问，一般用set/get来访问获取 修饰的方法在类中要用this.方法()类访问， private修饰的属性与方法均不可被继承

abstract修饰的方法要通过子类重写才可，abstract不可修饰属性

final修饰的属性需要在定义时候就赋值 final修饰的方法可以继承但不可被重写，属性可以 final意味是最终的不可修改的

类的普通方法都能被重写 类的方法都能重载

代码块

代码块是选育构造方法执行的，需要实例化时候才被执行

静态代码块比代码块先于执行，前者是类创建时候就被执行，后者是实例化时才被执行

运行顺序

静态属性>静态代码块>成员属性(这个包括后面的都是实例化后才执行)>构造快>构造方法

类的继承

子类继承父类，父类的除private外都能继承过去

构造块和构造方法不能继承，但子类实例化时候会暗中实例化父类 会先执行父类的构造块和构造函数再调用子类的

内部类

属性内部类

静态内部类

局部内部类

匿名内部类

抽象类abstract

抽象类是一个模板，共其他类使用

类：abstract可被修饰类，但不能被实例化，只能被继承，为模板作用        继承的类需要重写他的抽象方法，抽象类继承抽象类可选择重写

构造方法：不能修饰构造方法

构造块：不能修饰构造块

属性：不能修饰属性

方法：修饰的方法不能写代码，为模板作用，只能被子类继承重写

继承：1、可以被abstract类继承，继承过去的抽象方法可以选择性重写           2、被普通类继承时，必须重写抽象方法           3、抽象类本身不能实例化

接口interface

接口像是一个特殊的类，但它不是类， 与abstract相似，不能实例化，且是一个十分规范的模板

接口：1、不能实例化，只能被继承，类继承接口用implements，一个类可以继承多个接口           2、接口继承接口，用extens，可以继承多个extends           3、普通类继承接口必须把全部抽象方法重写

构造方法：没有构造方法，接口不是类且不能实例化

构造块：接口没有构造块

属性：属性默认为静态公家属性 public static 和final，只能赋值一次，且一定要有初始值

方法：接口方法默认为public abstratc方法，           在JDK1.8后又static和defaylt修饰的方法

继承：接口可以继承接口，且可同时继承多个           类可以继承多个接口           抽象类继承皆苦可选择性重写抽象方法

包装类

包装类为引用数据类型，是基本数据类型的实例表现，可以说是把基本数据类型 包装成实例，封装成类，可以运用其各种类方法 具体用法看JDK API

Integer

字符串转成int型 parseInt(str)

//向下装箱 Integer integer = 8; //向下拆箱 int i = integer;

Character

以下均为Character里面封装的static类，可以直接用 Character.isDigit(b)

isDigit

isLetter

isLetterOrDigit

isUpperCase

isLowerCase

String

字符串不可变，定义了里面的内容和长度就固定了 只能通过重写定义来获取新字符串

String常用方法

下面均为String里面的函数，需要实例调用 如：String str = "abcdefg";        System.out.println(str.charAt(3));

增

concat末尾追加字符串

删

改

replace

replaceFirst

查

charAt(index)

indexOf(Object)

lastIndexOff最后一个出现的

判断

contain

endsWith判断是否以指定字符串结束 startsWith判断是否已指定字符串开头

isEmpty是否为空

其他作用

split字符串分割返回String[]

substring返回一个该字符串的子字符串 "unhappy".substring(2) returns "happy" "Harbison".substring(3) returns "bison"

toCharArray重点 把字符串里面每个元素换成char[]

toLowerCase toUpperCase

trim删除任何前导和尾导空格

valuesOf非字符串类型转为字符串类型

StringBuffer

可变字符串序列

增

append

删

deleteCharAt(index)

delete(start, end)

改

replace

bs.replace(start, end, str)

查

indexOf

lastIndexOf()

其他功能

substring（index）切片 substring(start, end)

String str2 = "asdqweq$csdf"; StringBuffer bs1 = new StringBuffer(str2); String test = bs1.substring(5); 结果：eq$csdf

reverse反转

toString转成字符串

IO流

字节流

字符流

FileInputStream输入流

FileOutputStream输出流

有缓存区的流

BufferedInputStream缓冲输入流

BufferedOutputStream缓冲输出流

对象流

序列化反序列化 对象的类需要实现Serializable接口

是一个加密和解密过程， 写入类的时候加密， 输出类的时候解密。

类的结构改变了，其加密密码改变，无法解密

不会改变密码 类的密码不变(直接输入密码) 增加private static 修饰的属性 增加private transient 修饰的属性

ObjectInputStream输入流

ObjectOutputStream输出流

内存流

ByteArrayOutputStream输出

ByteArrayInputStream输入

随机访问流

RandomAccessFile

断点续传 可以做迅雷相似的下载

打印流

PrintStream输出

子主题

字符流

字节流读取

FileReader输入

FileWrite输出

缓冲区流

BufferedWrite输出

BufferedReader输入

转换流

InputStreamReader输入

OutputStreamWriter输出

打印流

PrintWriter写入

列表

ArrayList

动态数组 ArrayList list = new ArrayList(); 其实这方法很多和常用类是一样的

优点是查询快 缺点是中间删除和插入需要每个元素移位置

增

add

删

remove

改

set

查

indexOf

LinkedList

双向链表，有点像指针

优点是中间插入和删除快 缺点似查询慢

增删改查和ArrayList一样

Vector(了解)

元老级别的集合,底层是数组,线程安全的集合

Stack(了解)

模拟栈的集合,特点是后进先出(LIFO)，用完即删

CopyOnWriteArrayList

列表在迭代打印时候不能改变其结构 但这个可以，也就是它可以边打印边增删改查 因为输出的是原来的元素，而增删改查是另一份副本，之后副本就会变成正的

集合

集合不可重复，无序

TreeSet

TreeSet源码一定要看

子主题

可自然排序 可通过构造方法传比较器

自然排序 存储进TreeSet的对象类 必须实现Comparable接口

选择器排序 继承Comparator重写compara方法 再放入TreeSet有参构造中

比较规则 返回正数，存储的对象则在右子树， 返回负数，则在左子树，放回0，则不存储 若返回为0，则视为相同去掉一个

HashSet

JDK1.7: hash表(不可变) + 链表 JDK1.8:hash表(可变数组) + 链表 + 红黑树

可存储null对象， 存储自定义对象需要重写hashCode()和equals()

hashSet理论上可以无限长

Queue

先进先出

Collection工具类

可以好好研究怎么用的

ArrayList<Object> obj = new ArrayList<>(); Collections.addAll(obj, 1,2,3,4,5,6,78,9);

字典

key : values key唯一，values可以多个

HashMap

HashMap:底层是 哈希表+红黑树+链表

遍历: keySet    keyValues Set<String> keySet = map.keySet(); Iterator<String> it = set.iterator();

TreeMap

底层是红黑树，和TreeSet一样

自然排序  类继承Comparable接口 选择器     继承Comparator，重写compara

排序是按照Key来的，所以选择器或自然先排序都是给Key

注释

五大元注解

@Target

Target:指定被修饰的注解的生命周期(应用场景)           ElementType.TYPE                    指定被修饰的注解只能修饰类与接口           ElementType.FIELD                   指定被修饰的注解只能修饰全局属性           ElementType.METHOD                  指定被修饰的注解只能修饰非构造的方法           ElementType.PARAMETER               指定被修饰的注解只能修饰方法中的形参           ElementType.CONSTRUCTOR             指定被修饰的注解只能修饰构造方法           ElementType.LOCAL_VARIABLE          指定被修饰的注解只能修饰局部变量           ElementType.ANNOTATION_TYPE         指定被修饰的注解只能修饰注解           ElementType.TYPE_PARAMETER          指定被修饰的注解只能修饰泛型           ElementType.TYPE_USE                指定被修饰的注解不能修饰无返回值的方

@Repeatable

Retention:修饰注解在什么情况下保留       RetentionPolicy.SOURCE              指定被修饰的注解只保留在源代码中       RetentionPolicy.CLASS                 指定被修饰的注解保留在字节码文件中       RetentionPolicy.RUNTIME            指定被修饰的注解在运行时也保留

@Retention

@Document

@Inherited

循环

for（int i=0 ； i<10; i++） for(String str: names)

while

do{}while

用于循环的语句

break终止循环

continue 即可进行下一次循环

return 为结束函数，遇到所有都终止

标记，例如K： break K;可以结束标记为K的循环

运算符

逻辑运算符

逻辑或  |    逻辑与  &   非  ！   异或  ^     短路或||    短路与&&

逻辑与和逻辑或是全全运算 短路与和短路或是只要前面满足就结束

一元运算

++a，先赋值++再输出

a++，先输出再赋值++

二元运算符

+ - * / % ^.....

三目运算

关系表达式？表达式1：表达式2.   为真时输出表达式

赋值运算

子主题

条件判断

if

switch

case  defualt

修饰符

static

static为静态，修饰东西属于类本身，在全为static修饰的类中，该类为工具类

类：类不能被static修饰

构造方法：不能修饰构造方法

构造块：静态构造块时仅次于静态代码块执行，在类生成时，会先执行静态属性，再执行静态代码块

属性：为类的属性，一变全变，可被类直接调用，类创建时候最先执行的

方法：为类的方法，能被继承和修改，没有重写，有重载，可被直接调用

private

private为私有意思，不能被外界直接调用，哪怕实例化也不能调用

类：类不能被private修饰

构造方法：private修饰的构造方法，该类将不能被实例化（也不一定，如果有多个构造方法就也可以）

构造快：private不能修饰构造块

属性：属性为私有属性，外界不能直接调用

方法：为私有方法，需要用this.方法才可调用，不能直接调用

继承：均不可被继承

final

final为最终，不可修改

类：可以被修饰类，为永远不能被继承类

构造方法：不能修饰构造方法

构造块：不能修饰构造块

属性：修饰的属性为不可改属性，再定义之初就要赋值，不能再实例化后赋值

方法：修饰的方法可以继承和重载，但不可被重写

继承：可被继承，但继承的final方法不可被重写

abstract

抽象类时一个模板，供其他类使用

类：可被修饰类，但不能被实例化，只能被继承，为模板作用        继承的类需要重写他的抽象方法

构造方法：不能修饰构造方法

构造块：不能修饰构造块

方法：修饰的方法不能写代码，为模板作用，只能被子类继承重写

继承:1、可以被abstract类继承，继承过去的抽象方法可以选择性重写         2、被普通类继承时，必须重写抽象方法         3、抽象类本身不能实例化

多态

父类对象引用子类对象 多态是同一个行为具有多个不同表现形式或形态的能力。 Animal animal = new Cat(;

类：多态需要有继承关系才可能使用，如Cat继承Animal

构造方法和继承一样，先执行父类的构造方法，再执行子类的

构造快：实例化先执行父类的再执行子类

属性：Animal animal = new Cat(); 用父类的属性           父类属性没定义，子类定义了，还是调用父类的，为null

方法：方法调用子类的方法

异常

Throwable是所有Java程序中错误处理的父类，有两种资类：Error和Exception

try{ }catch(异常类型){}  异常捕抓， 只有catch不抓到对应的异常才会执行，不然直接异常报错

catch(异常类型1 | 异常类型2 | 异常类型3...) 一个catch捕抓多个异常

try{}finally{}    try{}catch(){}finally... finally为一定执行代码，只要try执行了，那么finally就一定执行

throw主动抛出异常 throw new RuntimeException("空指针异常");

throws 声明抛出异常，不会做时候标明让其他人来 public static void method() throws FileNotFoundException {类代码}

异常类重写 public class MyFileException extends FileNotFoundException {     public MyFileException(String str){         //调用父类的有参构造方法         super(str);     } }

迭代器和泛型

迭代器

foreach

for (Object obj:list) {      System.out.println(obj); }

forEach方法（lambda）

list.forEach(item->System.out.println(item)) 只能写一行，这个和上面都是只能输出整体的，不能提取里面元素，不好

iterator

System.out.println("------迭代器--------"); Iterator it = list.iterator(); //hasNext()判断下一个对象是否存在 while(it.hasNext()){     //next()获取指向的元素对象并指向下一个元素     Object obj = it.next();     System.out.println(obj); }

泛型

<>泛型能限定传入的值，让它只能传入指定类型

ArrayList<User> list = new ArrayList();

在传入方法参数，接口继承后面，属性等都可以用泛型 但自己用的不多，后面重点复习

File文件操作

File file = new File("E:\\File")

路径获取

file.getPath()  相对路径

file.getAbsolutePath()绝对路径

可读，可写，隐藏

file.canRead是否可读

file.canWrite可写

file.isHidden是否隐藏

是否存在

file.exists()

是否为文件、目录

file.isFile()是否为文件

file.isDirectory是否为目录

文件字节长度  file.length()

（重点）查看目录下面的内容

listFiles 文件数组 File[] files = file.listFiles();

可toString输出内容 凡是列表，都可以Arrays.toSting(files),

最后一次修改时间

file.lastModified(),返回long型，毫秒

long l = file.lastModified(); System.out.println(l); SimpleDateFormat time = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss"); System.out.println(time.format(l));

输出父母类

file.getParentFile 输出文件的所有上层目录

增

file.createNewFile 创建文件 file.mkdir               创建目录（文件夹） file.mkdirs              创建多个文件夹，推荐这个                                File("File2\\Text\\Test2\\io2.txt");可以把被所有目录都创建

删

file.delete  可删除文件和文件夹

多线程

实现多线程方法

法一：类继承Thread类，重写run方法           实例化类，调用start方法

法二：任务类实现Rannable接口，重写run方法            实例化任务类和Thread类，把任务类传入Thread有参构造中            再调用thread的start方法

法三：线程池

pool.submit(task)，提交任务 pool.shutdown();

单线程池newSingleThreadExecutor ExecutorService pool = Executors.newSingleThreadExecutor();

固定线程池：newFixedThreadPool Executors.newFixedThreadPool(4);4条线程

创建带有缓冲区的线程池 Executors.newCachedThreadPool();

同步锁

等A线程运行完后再运行线程B，保证线程安全 要求方法为静态方法或者同一个对象

一般选取的共同部分 static Object obj = new Object()

synchronized(obj){        同步块          }

Lock锁

实例化锁 static ReentrantLock myLock = new ReentrantLock(boolean) 参数不填为非公平锁，参数填了为公平锁

mylock.lock()         锁上 mylock.unlock()     解所

阻塞

sleep

1、使当前线程休眠 2、为Thread的静态方法，可直接Thread.sleep()使用 3、当线程进入休眠状态，不会释放资源，时间到了自动唤醒

wait

1、当线程在同步去中进入等待状态，释放资源 2、wait来自Object，貌似可以直接在类中直接调用 3、wait()必须要在同步锁中调用， 4、解所notify/notifyAll也是要在同步锁里面用

多线程小知识

setDeamon守护线程

当主线程运行完了，所有线程也关闭

join合并线程

把A线程合并到B线程，前面A、B抢线程，遇到A.join()后， 会把A线程运行完后再运行B

setPriority

1、setPriority(int) 里面的数是1-10 2、实际上只是概率，设置的优先级高，运行它的概率就大

yield礼让

实际上线程运行时cpu决定的，这个效果不好

反射

反射对象获取

Class.forName(具体路径)

用实例化对象.getClass(),  例如user.Class()

类名.class 例如：User.class

获取内容

获取属性

getDeclaredField(String name) 放入属性名，获取属性内容 getDeclaredFields()获取所有属性名

获取具体属性对象后，用set(类，修改值)可修改属性内容

获取类方法

getDeclaredMethod(String name，...参数类型.class)

获取方法后，用invoke(类，...参数)调用方法

获取构造方法

有些类用private修饰构造方法， 这样的话就无法在外面实例化该类 但用反射可以

getDeclaredConstructor获取构造方法

newInstance实例化

获取权限

只要是私有属性、方法等，都要获取它的权限才能使用

setAccessible(true)获取权限

获取名字

getName获取对象名时候，是获取它的总路径 获取其他属性时候，是名字

getSimpleName()获取当前名字

json

什么是json

字典类型的就是json型了 单一类的json{name:'zs',age:18} 适合于单一属性提取

单一对象json

要先实例化json

JSONObject obj = new JSONObject(json)

获取json值

obj.getInt(String key)

obj.getDouble()

obj.getString()

obj.getJSONObject获取Json里面对象，例如下面的score就是一个对象了 "{id:1,name:'zs',score:{javaScore:88.8,mysqlScore:66.6}}"

多对象json

多对象的json [{id:1,name:'zs'},{id:2,name:'ls'},{id:3,name:'ww'}]

要先实例化

JSONArray jsonArray = new JSONArray(json); 获取的是一个列表，可以for循环迭代

获取json值

这个和上面一样了，需要每个迭代出来一个个获取

obj.getInt(String key)

obj.getDouble()

obj.getString()

obj.getJSONObject获取Json里面对象，例如下面的score就是一个对象了 "{id:1,name:'zs',score:{javaScore:88.8,mysqlScore:66.6}}"

类数据封装成json

单对象封装

直接实例化类，再放进new JSONObject(user)

User user = new User(12, "zs"); JSONObject jsonObject = new JSONObject(user); System.out.println(jsonObject.toString());

多对象封装

将实例化好的数据放入ArrayList中 再传入JSONArray(list)

ArrayList<User> list = new ArrayList<>();         list.add(new User(12, "zs"));         list.add(new User(13, "ls"));         list.add(new User(14, "ww"));         list.add(new User(15, "lj")); JSONArray obj = new JSONArray(list); System.out.println(obj.toString());

fastjson

什么是fastjson

是阿里研发的json，可以很大程度简化了json值传入对象操作

单一对象json实现类

JSON.parseObject(json, User.class)

public class Demo01 {     public static void main(String[] args) {         String json = "{name:'zs',age:18}";         User user = JSON.parseObject(json, User.class);         System.out.println(user);     } }

多对象json实现类

JSON.parseArray(json,User.class)

String json1 = "[{id:1,name:'zs'},{id:2,name:'ls'},{id:3,name:'ww'}]"; List<User> users = JSON.parseArray(json1, User.class); System.out.println(users);

类数据封装成json

单对象封装

JSON.toJSONString(user)

多对象封装

也是JSON.toJSONString(list)

String json1 = "[{id:1,name:'zs'},{id:2,name:'ls'},{id:3,name:'ww'}]"; List<User> users = JSON.parseArray(json1, User.class); System.out.println(users);

编程模式

编程模式为一套长期累积规划的设计思想 一共23种，由后面自己补充完整了，非常有必要

创建模式(5)

单例模式

这两种一定要会手写出来

饿汉模式

懒汉模式

工厂模式

Stream流

stream流是高级的迭代器， 可操作迭代出来的东西

要先获取stream流

Stream<User> stream = list.parallelStream();

中间操作

过滤filter

list.stream().filter(user -> user.getMoney()>0).forEach(System.out::println);

限制limit

list.stream().limit(2).forEach(System.out::println);  限制前两个不出

跳过skip

去重distinct

排序sorted

很TM的长，需要用lambda list.stream().sorted((user1,user2)->Integer.compare((int)user1.getMoney(),(int)user2.getMoney())).forEach(System.out::println);

尾部操作

尾部操作，完成后需要get才能使用

最小值min

System.out.println("-----最小值-----"); Optional<User> min = list.stream().min((user1, user2) -> Integer.compare((int) (user1.getMoney()), (int) (user2.getMoney()))); User user = min.get(); System.out.println(user);

最大值max

Optional<User> max = list.stream().max((user1, user2) -> Integer.compare((int) (user1.getMoney()), (int) (user2.getMoney()))); User user1 = max.get(); System.out.println(user1);

lambda

lambda多用于接口实现，实现单一的抽象函数 不能用于抽象类实现，实现过程是简化的匿名内部类

IText1 iText = (参数名) -> 代码 单行代码直接这样

IText1 iText = (参数名) -> {代码} 多行代码用{ }