Java

public class Xxxx {
	public static void main(String[] args) {

/**
* meaning
* @param arg1 mean
*/

double[] xxx = new double[8]; // 动态

String[] name = new String[]{"aa", "bb"};
String[] name = {"a", "b"};
String name[] = {"a", "b"};

name.length; // 长度
Arrays.toString(xxx); // 打印数组

// 动态
int[][] arr = new int[][]{ {x,x}, {x, x}};
int[][] arr = new int[2][2]; // 2 可换为变量

//静态
String[][] s = {
	{"a", "b"},
	{"c", "d"},
};

String s = "aaa";

String ss = new String("abc");

char[] chars = {'a', 'b'};
String sss = new String(chars);

byte[] bytes = {97, 98};
String sss = new String(bytes);

s.length(); // 返回大小
s.equals("xxx"); // 判断是否相等
s.substring(0, 2); // 返回[0, 2)子串
s.charAt(index); // 返回索引对应的字符
s.startsWith("xx"); // 以xx开始

// 更高效的字符串拼接
StringBuilder sb = new StringBuilder(); // 可变内容容器
sb.append("xx").append('a'); // 支持链式编程
String s = sb.toString();

c.add("xx");
c.size();
c.remove("aa");
c.isEmpty(); // 是否为空
c.clear(); // 清空集合
c.contains(obj); // 是否存在某个数据

Object[] arr = c.toArray(); // 集合转换成数组
String[] arr2 = c.toArray(String[]::new); // 集合转换成字符数组

Iterator<E> iterator() // 返回集中中迭代器对象，默认指向当前集合第一个元素
Iterator<String> it = xx.iterator();

// 方法
hasNext() // 当前位置是否有元素存在
next() // 获取当前位置元素，同时迭代器对象指向下一个元素处
it.remove(xxx); // 防止并发修改异常

add(index, "xx")
add("xxx")
remove // 返回删除的数据
get
set    // 返回修改前的数据

ArrayList<String> list = new ArrayList<>();

list.add("xxx");// 添加数据
list.get(index); // 取数据
list.size(); // 大小
list.remove(index); // 索引删除
list.remove("xx"); // 直接删除
list.set(index, "xxx"); // 修改
list.subList(start_index, end_index); // 截取

addFirst() // 列表开头插入指定元素
addLast() // 元素追加列表末尾
getFirst() // 第一个元素
getLast() // 最后一个元素
removeFirst() // 删除并返回第一个元素
removeLast() // 删除并返回最后一个元素

// 栈
push(); 
pop();

Set<String> set = new HashSet<>();

set.add("xx");

List<String> list = new ArrayList<>();
Collections.addAll(list, "xx", "bb"); // 可变参数
Collections.shuffle(list); // 打乱顺序
Collections.sort(List<T> list, Comparator<? super T> c) // 排序

public class Son extends Dad {}

@Override
public void xx() {}

this(xxx, xxx, xxx, "xxx");

Animal d = new Dog();
Animal w = new Wolf(); // 子类

import lombok.Data;

@Data
@AllArgsConstructor // 有参构造
@NoArgsConstructor  // 无参构造

public enum A {
    X, Y, Z; // 只能写枚举类的对象名称，且用逗号隔开
    // 均为常量，每个对应一个对象
    ...
}

A a1 = A.X;
// a1.name() 名字
// a1.ordinal() 索引

public abstract class A{
    public substract void func(); // 只能有方法签名，无方法体
}

// 无 static 修饰，属于外部类对象持有
public class Outer {
	public class Inner {
		xx
	}
}

Outer.Inter oi = new Outer().new Inner();

public class Outer {
	public static class Inner {
	}
}

Outer.Inner in = new Outer.Inner();

new Animal(args...){
	@Override
	public void cry() {
	}
};

Arrays.sort(T[] a, Comparator<T> c);

new Comparator<T>() {
	@Override
	public int compare(T o1, T o2) {
		// +: o1 > o2, -: o1 < o2, 0: o1 = o2
		...
	}
}

@FunctionalInterface // 声明函数式接口：只有一个抽象方法的接口
interface Swim {
	void swimming();
}

// lambda 重写swimming了, 进一步呢简化，参数类型也可省略，只有一个参数,()也可省略，一行代码则省略;和return
Swim s = (args) -> {
	xxxx
};
s.swimming(args);

 Arrasy.sort(Students, (o1, o2) -> o1.getAge() - o2.getAge());
 
 // compareByAge(o1, o2)为静态方法
 Arrays.sort(Students, Student::compareByAge);

Student t = new Student();
Arrays.sort(Students, (o1, o2) -> t.compareH(o1, o2));

// 简化
Arrays.sort(Students, t::compareH);

Arrays.sort(names, (o1, o2) -> o1.comparexxx(o2));
// 简化，o1和o2为特定类型String
Arrays.sort(names, String::comparexxx);

// 手工包装
Integer it = Integer.valueOf(100); // 130超过127边界，会new新的对象

// 自动装箱 
Integer it = 100;

// 自动拆箱
int i = it;

int j = 23;
String rs = Integer.toString(j);

// 转换为字符串
String a = j + ""; // 也可

String str = "91";
int i = Integer.parseInt(str);
int i = Integer.valueOf(str); // 均可

Random r = new Random();
r.nextInt(100) + 1; // 1-100

Math.random() // 返回[0, 1)的随机小数

Scanner sc = new Scanner(System.in);
if(sc.hasNext()) {
	String xx = sc.next();
}
sc.close()

long start = System.currentTimeMillis(); // 此刻时间毫秒值

LocalDateTime now = new LocalDateTime.now(); // 可直接输出
now.getYear();
now.getDayOfYear();
// 格式化
DataTimeFormatter dtf = DataTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss EEE a");
String res = dtf.format(now);

// 编码
String name = "fewio";
byte[] bytes = name.getBytes(); // UTF-8编码
Arrays.toString(bytes);

// 解码
String name2 = new String(bytes, "GBK");

Java.lang.Throwable
- Error: 系统级别错误
- Exception: 异常
	- RuntimeException 运行时异常，编译不出错，运行时出错
	- other
	编译时异常，编译报错

public class XException extends Exception { // RuntimeException 运行时异常   
	// 无参有参构造器
	public XException(String message){
		super(message);
	}
}

if(xx){
	throw new XException("wrong info");
}

public class impcla implements interf1, interf2, interf3 {
interfacename xx = new impcla();
xx.func();

ArrayList<String> list = new ArrayList<String>();

public class ArrayList<E> {
	...
}

public class ArrayList<E> { // 大写:ETKV 
	void func(E e){
		xxx;
	}
}

public interface A<E>{
	
}

public class X implements A<E> {
}

public static <T> void test(T t) {
	//定义方法时同时自定义声明的T
}

public static void go(ArrayList<? extends XXX> xx) {
}

List<String> list = new ArrayList<>();
// 过滤并收集
List<String> newlist = list.stream().filter(s -> s.startsWith("xx")).filter(s -> s.length() == 3).collect(Collectors.toList());

Collection<String> list = new ArrayList<>();
Stream<String> s = list.stream();

String[] names = {"a", "b"};
Stream<String> s = Arrays.stream(names);

Stream<String> s1 = Stream.of(names);

s.filter() // 过滤
.sorted() // 排序
.sorted((s1, s2) -> Double.compare(s2. s1)) // 重写规则排序
.limit(2) // 只要前2个
.skip(2) // 跳过前2个
.distinct() // 去重
.map(s -> "加工后: " + (s + 10)).forEach(System.out::println); // 映射为新数据放入流上
.concat(stream1, stream2) // 合并两个流为一个流

.forEach(System.out::println) // 遍历输出
.count() // 统计流中的个数

Otional<Teacher> max = teachers.stream().max((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));
Teacher maxTeacher = max.get(); // 获取薪水最高的老师
Teacher minTeacher = min.get();

List<String> list1 = stream1.collect(Collectors.toList());
Set<String> set1 = stream1.collect(Collectors.toSet());
Object[] array = stream1.toArray();

Map<String, Double> map = stream1.collect(Collectors.toMap(Teacher::getName, Teacher::getSalary));

Set<String> set2 = newHashSet<>();
set2.addAll(list1);

new Function<Type1, Type2>() { xxx }
// 该接口接受一个类型为Type1的输入参数，返回一个类型为Type2的结果

public static void x(int...nums){
    nums.length;
}

try {
	...
} catch (IOException e) {
	e.printStackTrace();
} finally {
	...
	// 无论 try 中程序是否正常执行，最终均会执行finally区，除非JVM终止
}

// try-with-resource 更实用
try(// 只能放置资源对象，用完会自动调用close函数关闭
	InputStream fis = new FileInputStream(srcPath);
	OutputStream fos = new FileOutputStream(destPath);
) {
		xxxx
} catch (Exception e {
		e.printStackTrace();
}

// 返回读取多少字符
Reader fr = new FileReader("xx");

char[] chs = new char[3];
int len;
while((len = fr.read(chs)) != -1){
	String str = new String(chs, 0, len); // 0:offset
}

Writer fw = new FileWriter("xx", true); // true 追加

fw.write('a'); // 写一个字符
fw.write("aa"); // 写一个字符串
fw.write("java".toCharArray()); // 写一个字符数组
fw.write("few", 1, 2); // offset:1, len:2

fw.flush(); // 数据全部写出去

InputStream is = new FIleInputStream("xx");
Reader isr = new InputStreamReader(is, "GBK");

PrintStream ps = new PrintStream("aa");
ps.println(97);
ps.println('a');
ps.println(true); // 打印true

DataOutputStream dos = new DataOutputStream(new FileOutputStream("a"));

dos.writeByte(34);
dos.writeUTF("你好");
dos.writeInt(12323);
dos.writeDouble(9.9);

DataInputStream dis = new DataInputStream(new FileInputStream("aa"));
dis.readByte();
dis.readUTF(); //...

// 创建线程
class zThread extends Thread {
    @Override
    public void run() {
        System.out.println("thread");
    }
}

Thread t1 = new zThread();
t1.start(); // 开启子线程，子线程和主线程同时跑

Thread t = new zThread();
t.setName("aa"); // 设置线程名字
t.getName(); // 获取线程名字
System.out.println(Thread.crrentThread().getName()); // 输出当前线程名字，以区分

Thread.sleep(1000);// 线程休眠1s

// join方法 让调用这个方法的线程先执行完
t.join(); // 插队 让t线程先执行完毕，再执行主线程

synchronized(同步锁) { // 同时执行的线程：同步锁必须是同一对象 （this）
	访问共享资源
}

修饰符 synchronized 返回值类型 方法名称(形参列表) {
	操作共享资源代码
}

private final Lock lk = new ReentrantLock();
lk.lock() // 上锁
lk.unlock() // 解锁 放在finally中

ThreadPoolExecutor(int corePoolSize, // 核心线程数量
	int maximumPoolSize, // 最大线程数量
	long keepAliveTime, // 临时线程的存活时间，空闲多久被消灭
	TimeUnit unit, // 指定临时线程存活的时间单位，秒分时天
	Blocking Queue<Runnable> workQueue, // 线程池任务队列
	ThreadFactory threadFactory, // 线程池的线程工厂，招聘线程的 HR
	RejectedExecutionHandler handler) // 任务拒绝策略：线程都在忙，任务队列也满，新任务来如何处理
	

ExecutorService pool = new ThreadPoolExecutor(xx, xx, xx);

pool.execute(Runnable command); // 执行任务
pool.shutdown(); // 等全部任务执行完关闭线程池
pool.shutdownNow(); // 立刻关闭线程池，停止正在执行的任务

InetAddress ip = InetAddress.getLocalHost(); // 获取本机IP对象
InetAddress ip2 = InetAddress.getByName("www.baidu.com"); // 获取IP对象

ip.getHostName(); // 域名
ip.getHostAddress(); // 优先公网IP
ip2.isReachable(5000); // 判断本机与对方主机是否相通

double a = 0.1;
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.add(b1); // divide
double res = c1.doubleValue();