java

IDEA破解：https://www.52pojie.cn/thread-1062067-1-1.html

变量类型

java是跨平台的语言，所以不论在什么系统中同一类型的变量在内存中所占空间都是相同的

整型：
int-4字节，short-2字节，long-8字节，byte-1字节
byte只是大小约束并不是字节(最大127)
进制：0开头-8进制，0x-16进制

浮点型：
float-4字节（带后缀1.2F），double-8字节（小数默认为double类型，无需后缀）
> System.out.println(0.12345678912345678*100);
> 12.345678912345678
可以看出精度是有损失的

高精度：
如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger、BigDecimal，这两个类可以处理包含任意长度数字序列的数值，和python中的int一样。

字符型：
char-2字节，必须是单引号，双引号是String类型
Java 中 char 无论中英文数字都占用2字节，是因为 Java 中使用 Unicode 字符，所有字符均以2个字节存储。
最小的uincode编码u0000，最大uffff

对于数值类型的基本类型的取值范围，无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了：
Integer.SIZE
Integer.MIN_VALUE
Integer.MAX_VALUE
Byte/Short/Long/Float/Double/Character

类型转换：低到高直接赋值，高到低必须使用强制类型转换
低 ------------------------------------> 高

byte,short,char—> int —> long—> float —> double
其他类型转字符串：obj.toString()
char可以被转换为int
char a = ‘a’; int b = a; b为97

参考：https://www.jianshu.com/p/fd560bc39adb

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形

Java 为每一个内置数据类型提供了对应的包装类

整型：Integer、Long、Byte、Double、Float、Short

字符型：Character、String

StringBuffer 和 StringBuilder

可以更改的字符串

StringBuffer是线程安全的，StringBuilder不是线程安全的；StringBuilder更快，但要求线程安全则要使用StringBuffer

方法：append()，insert()，reverse()，delete()，replace()

数组

dataType[] arrayName;

多维dataType[][]

# 如果是char类型的数组，将数组中的字符拼接成字符串
new String(chars, 0, len);

时间类型

import java.util.*;

Date date = new Date()

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

ft.format(date)

方法：

Arrays.binarySearch(list,3)    # 根据元素查找索引,如果有多个返回第一个的索引

Arrays.copyOfRange(list, 0 , list.length);    # 切片

Arrays.toString(list)    # 数组转字符串

哈希

# 创建

HashMap<Integer,Integer> map = new HashMap();

# 是否包含键/值

map.containsKey(key);

map.containsValue(value);

# 通过键获取值

value = map.get(key);

# 在哈希表中插入键值对

map.put(key,value);

运算符

/ 如果是两个整型则为整除，有一个浮点型结果为浮点型

++ -- 更改原值

位运算：& | ~ ^异或

逻辑运算：&& || ！

<< 左移补0，>>右移：正数则高位补0，负数则高位补1

>>> 不区分正负数，高位均补0

优先级：算数运算>比较运算>逻辑运算，不用记，加括号就完事了

循环/条件

while(){}

do{}while()

for(int x = 10; x < 20; x++) {}

Java5 引入了一种主要用于数组的增强型 for 循环

int [] numbers = {10, 20, 30, 40, 50};

for(int x : numbers){}

if(){}

else if(){}

else{}

switch(I=1){case 1:xxx; case2:yyy; default:zzz}

case 语句中的值的数据类型必须与变量的数据类型相同；

当变量的值与 case 语句的值相等时，此case 语句开始执行，直到 break 语句出现才会跳出 switch 语句；

switch 语句可以包含一个 default 分支，efault 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

通常每个case都有break跳出；

如果进去的case中没有break，则会执行此case之后的所有case中，直到遇到第一个break为止；

如果没有匹配到任何case，有default，则会直接执行default

正则

其他语言中表示转义字符，java \ 表示转义字符

java.util.regex

Pattern 类、Matcher 类

Pattern pattern = Pattern.compile("bad");
String d = "abadf231afcz";
Matcher matcher = pattern.matcher(d);
Boolean ret = matcher.find();
if(ret){
System.out.println(matcher.group(0));
}

仅作判断：boolean isMatch = Pattern.matches(pattern, content);

替换

String str="China12345America678922England";
str.replaceAll("\d+", " "); China America England

控制台输入

从控制台读取内容，read()读取一个字符，返回的是整型；readilne()读取一个字符串

# InputStreamReader字节型，需要套一层BufferedReader字符型
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("输入字符, 按下 'q' 键退出。");
// 读取字符
do {
c = (char) br.read();
System.out.println(c);
} while (c != 'q');

另外一种：

Scanner scan = new Scanner(System.in);
# 使用 hasNext 与 hasNextLine 判断是否还有输入的数据
if(scan.hasNext()){
    # next遇到空格结束读取，即以空格为结束符
    String str1 = scan.next();
    # nextLine以回车为结束符
    String str2 = scan.nextLine();
    System.out.println("输入的数据为：" + str1);
}
scan.close();

目录操作File

创建：

String dirname = "/home/user/java";
File d = new File(dirname);
# 创建目录，已经存在返回false
Boolean status = d.mkdir()
# 创建文件夹，和它的所有父文件夹，即不存在全创建一个出来
d.mkdirs()

读取：

String dirname = "/home/user/java";
File d = new File(dirname);
# 判断是否是一个文件夹
Boolean status = d.isDirectory();
# 此文件夹下的所有子文件夹和文件字符串
String[] s = d.list();
# 此文件夹下的所有子文件夹和文件的File对象
File[] f = d.listFiles();

删除：

String dirname = "/home/user/java";
File d = new File(dirname);
d.delete();

文件读取

字节流-FileInputStream

InputStream f = new FileInputStream("C:/java/hello");

f.read(int I)，I表示要读取的字节数，返回整型；如果到结尾则返回-1

字节流-FileOutputStream

OutputStream f = new FileOutputStream("C:/java/hello")

f.write(int x)

字符流-OutputStreamWriter，字节流无法写入字符/字符串，只接收整型，而且即使写进去也是二进制，而不是以字符串写进去，只适合图片等内容

所以可以通过套一层OutputStreamWriter(f, “utf-8”)来解决，使写入字符

byte[] bWrite = { 11, 21, 3, 40, 5 };
OutputStream f = new FileOutputStream("test.txt");
OutputStreamWriter writer = new OutputStreamWriter(f, "UTF-8");
for (int x = 0; x < bWrite.length; x++) {
writer.append(Integer.toString(bWrite[x])); // writes the bytes
}
writer.close();
f.close();

读取也是类似，不过ir读取出来的依然是整型，所以要借助StringBuffer

InputStream is = new FileInputStream("test.txt");
InputStreamReader ir = new InputStreamReader(is, "utf-8");
char[] chars = new char[10];
# 将读取的内容存到数组中
ir.read(chars)

StringBuffer sb = new StringBuffer();
# 如果流不是空的则继续读取
while (ir.ready()) {
sb.append((char) ir.read());
// 转成char加到StringBuffer对象中
}
System.out.println(sb.toString());

继承/抽象/接口/多态

必须重写抽象方法；

抽象方法只是声明方法，没有方法体；

接口中的成员变量只能是 public static final 类型的

导包

如果a.java中package com.day

则路径应该是：环境变量中的导包路径/com/day/a.java

socket

客户端

String host = "127.0.0.1";
int port = 5500;
Socket client = new Socket(host, port);
Writer writer = new OutputStreamWriter(client.getOutputStream());
Scanner in = new Scanner(System.in);
writer.write(in.nextLine());
writer.flush();
writer.close();
client.close();
in.close();

服务端

ServerSocket server = new ServerSocket(5500);
Socket socket = server.accept();
int len;
StringBuilder builder = new StringBuilder();
InputStreamReader reader = new InputStreamReader(socket.getInputStream());
char chars[] = new char[10];
while ((len=reader.read(chars)) != -1){
    builder.append(new String(chars, 0, len));
}
System.out.println("收到来自客户端的信息： " + builder);
reader.close();
socket.close();
server.close();

selector

打jar包

参考：https://www.cnblogs.com/mq0036/p/8566427.html