Java

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

动态数组

静态数组

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

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

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

二维数组

类数组

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

整型

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

浮点型

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

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

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

字符型

布尔型

基本数据类型

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

类 class

接口 interface

引用数据类型

数据类型

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

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

参数数量不同

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

方法重载

函数/方法

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

类实例化

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

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

类的构造方法

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

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

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

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

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

类的属性与方法

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

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

代码块

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

运行顺序

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

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

类的继承

外部类

属性内部类

静态内部类

局部内部类

匿名内部类

内部类

类

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

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

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

构造块：不能修饰构造块

属性：不能修饰属性

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

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

抽象类abstract

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

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

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

构造块：接口没有构造块

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

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

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

接口interface

字符串转成int型parseInt(str)

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

Integer

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

isDigit

isLetter

isLetterOrDigit

isUpperCase

isLowerCase

Character

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

包装类

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

下面均为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[]

toLowerCasetoUpperCase

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

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

其他作用

String常用方法

可变字符串序列

append

deleteCharAt(index)

indexOf

lastIndexOf()

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

reverse反转

toString转成字符串

其他功能

StringBuffer

String

FileInputStream输入流

FileOutputStream输出流

字符流

BufferedInputStream缓冲输入流

BufferedOutputStream缓冲输出流

有缓存区的流

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

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

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

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

ObjectInputStream输入流

ObjectOutputStream输出流

对象流

ByteArrayOutputStream输出

ByteArrayInputStream输入

内存流

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

RandomAccessFile

随机访问流

PrintStream输出

打印流

字节流

子主题

FileReader输入

FileWrite输出

字节流读取

BufferedWrite输出

BufferedReader输入

缓冲区流

InputStreamReader输入

OutputStreamWriter输出

转换流

PrintWriter写入

IO流

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

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

add

remove

set

ArrayList

双向链表，有点像指针

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

增删改查和ArrayList一样

LinkedList

Vector(了解)

Stack(了解)

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

CopyOnWriteArrayList

列表

集合不可重复，无序

TreeSet源码一定要看

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

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

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

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

TreeSet

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

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

hashSet理论上可以无限长

HashSet

先进先出

Queue

可以好好研究怎么用的

Collection工具类

集合

key : valueskey唯一，values可以多个

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

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

HashMap

底层是红黑树，和TreeSet一样

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

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

TreeMap

字典

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

@Target

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

@Repeatable

@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

case  defualt

switch

条件判断

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

类：类不能被static修饰

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

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

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

static

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

类：类不能被private修饰

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

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

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

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

继承：均不可被继承

private

final为最终，不可修改

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

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

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

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

final

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

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

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

abstract

修饰符

父类对象引用子类对象多态是同一个行为具有多个不同表现形式或形态的能力。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);    }}

异常

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

foreach

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

forEach方法（lambda）

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

iterator

迭代器

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

ArrayList<User> list = new ArrayList();

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

泛型

迭代器和泛型

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();

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

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  可删除文件和文件夹

File文件操作

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

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

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

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

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

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

法三：线程池

实现多线程方法

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

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

synchronized(obj){       同步块          }

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

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

Lock锁

同步锁

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

sleep

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

wait

阻塞

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

setDeamon守护线程

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

join合并线程

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

setPriority

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

yield礼让

多线程小知识

多线程

Class.forName(具体路径)

类名.class例如：User.class

反射对象获取

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

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

获取属性

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

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

获取类方法

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

getDeclaredConstructor获取构造方法

newInstance实例化

获取构造方法

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

setAccessible(true)获取权限

获取权限

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

getSimpleName()获取当前名字

获取名字

获取内容

反射

什么是json

JSONObject obj = new JSONObject(json)

要先实例化json

obj.getInt(String key)

obj.getDouble()

obj.getString()

obj.getJSONObject获取Json里面对象，例如下面的score就是一个对象了\

获取json值

单一对象json

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

要先实例化

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

多对象json

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

单对象封装

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

多对象封装

类数据封装成json

json

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

什么是fastjson

public class Demo01 {    public static void main(String[] args) {        String json = \

单一对象json实现类

String json1 = \

多对象json实现类

JSON.toJSONString(user)

也是JSON.toJSONString(list)

fastjson

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

这两种一定要会手写出来

饿汉模式

懒汉模式

单例模式

工厂模式

创建模式(5)

编程模式

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

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

要先获取stream流

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

过滤filter

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

限制limit

跳过skip

去重distinct

排序sorted

中间操作

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

System.out.println(\"-----最小值-----\

最小值min

最大值max

尾部操作

Stream流

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

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

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

lambda

Java