Java

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[][] 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(),不然指针报错

类实例化

类数组

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

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

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

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

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

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

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

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

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

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

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

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

字符串转成int型
parseInt(str)

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

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

isDigit

isLetter

isLetterOrDigit

isUpperCase

isLowerCase

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非字符串类型转为字符串类型

append

deleteCharAt(index)

delete(start, end)

replace

bs.replace(start, end, str)

indexOf

lastIndexOf()

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

reverse反转

toString转成字符串

FileInputStream输入流

FileOutputStream输出流

BufferedInputStream缓冲输入流

BufferedOutputStream缓冲输出流

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

ObjectInputStream输入流

ObjectOutputStream输出流

ByteArrayOutputStream输出

ByteArrayInputStream输入

RandomAccessFile

PrintStream输出

FileReader输入

FileWrite输出

BufferedWrite输出

BufferedReader输入

InputStreamReader输入

OutputStreamWriter输出

PrintWriter写入

add

remove

set

indexOf

子主题

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

getDeclaredConstructor获取构造方法

newInstance实例化

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

setAccessible(true)获取权限

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

getSimpleName()获取当前名字

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

要先实例化json

获取json值

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

要先实例化

获取json值

单对象封装

多对象封装

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

JSON.parseObject(json, User.class)

JSON.parseArray(json,User.class)

单对象封装

多对象封装

这两种一定要会手写出来

饿汉模式

懒汉模式

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

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

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

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

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