Java 备忘清单

该备忘单是针对 Java 初学者的速成课程，有助于复习 Java 语言的基本语法。

入门

Hello.java

public class Hello {
  // 主要方法
  public static void main(String[] args)
  {
    // 输出: Hello, world!
    System.out.println("Hello, world!");
  }
}

编译和运行

$ javac Hello.java
$ java Hello
Hello, world!

变量 Variables

int num = 5;
float floatNum = 5.99f;
char letter = 'D';
boolean bool = true;
String site = "jaywcjlove.github.io";

原始数据类型

数据类型	大小	默认	范围
`byte`	1 byte	0	-128 ^to^ 127
`short`	2 byte	0	-2^15^ ^to^ 2^15^-1
`int`	4 byte	0	-2^31^ ^to^ 2^31^-1
`long`	8 byte	0	-2^63^ ^to^ 2^63^-1
`float`	4 byte	0.0f	N/A
`double`	8 byte	0.0d	N/A
`char`	2 byte	\u0000	0 ^to^ 65535
`boolean`	N/A	false	true / false

字符串 Strings

String first = "John";
String last = "Doe";
String name = first + " " + last;
System.out.println(name);

查看: Strings

循环 Loops

String word = "QuickRef";
for (char c: word.toCharArray()) {
  System.out.print(c + "-");
}
// 输出: Q-u-i-c-k-R-e-f-

查看: Loops

数组 Arrays

char[] chars = new char[10];
chars[0] = 'a'
chars[1] = 'b'
String[] letters = {"A", "B", "C"};
int[] mylist = {100, 200};
boolean[] answers = {true, false};

查看: Arrays

交换变量 Swap

int a = 1;
int b = 2;
System.out.println(a + " " + b); // 1 2
int temp = a;
a = b;
b = temp;
System.out.println(a + " " + b); // 2 1

类型转换 Type Casting

// Widening
// byte<short<int<long<float<double
int i = 10;
long l = i;               // 10
// Narrowing
double d = 10.02;
long l = (long)d;         // 10
String.valueOf(10);       // "10"
Integer.parseInt("10");   // 10
Double.parseDouble("10"); // 10.0

条件语句 Conditionals

int j = 10;
if (j == 10) {
  System.out.println("I get printed");
} else if (j > 10) {
  System.out.println("I don't");
} else {
  System.out.println("I also don't");
}

查看: [Conditionals](#条件语句 Conditionals)

用户输入

Scanner in = new Scanner(System.in);
String str = in.nextLine();
System.out.println(str);
int num = in.nextInt();
System.out.println(num);

Java 字符串

基本的

String str1 = "value";
String str2 = new String("value");
String str3 = String.valueOf(123);

字符串连接

String s = 3 + "str" + 3;     // 3str3
String s = 3 + 3 + "str";     // 6str
String s = "3" + 3 + "str";   // 33str
String s = "3" + "3" + "23";  // 3323
String s = "" + 3 + 3 + "23"; // 3323
String s = 3 + 3 + 23;        // 29

字符串生成器

StringBuilder sb = new StringBuilder(10);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
|   |   |   |   |   |   |   |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.append("Reference");

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| R | e | f | e | r | e | n | c | e |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.delete(3, 9);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| R | e | f |   |   |   |   |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.insert(0, "My ");

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y |   | R | e | f |   |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.append("!");

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y |   | R | e | f | ! |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

比较

String s1 = new String("QuickRef");
String s2 = new String("QuickRef");
s1 == s2          // false
s1.equals(s2)     // true
"AB".equalsIgnoreCase("ab")  // true

操纵

String str = "Abcd";
str.toUpperCase();     // ABCD
str.toLowerCase();     // abcd
str.concat("#");       // Abcd#
str.replace("b", "-"); // A-cd
"  abc ".trim();       // abc
"ab".toCharArray();    // {'a', 'b'}

信息

String str = "abcd";
str.charAt(2);       // c
str.indexOf("a")     // 0
str.indexOf("z")     // -1
str.length();        // 4
str.toString();      // abcd
str.substring(2);    // cd
str.substring(2,3);  // c
str.contains("c");   // true
str.endsWith("d");   // true
str.startsWith("a"); // true
str.isEmpty();       // false

不可变

String str = "hello";
str.concat("world");
// 输出: hello
System.out.println(str);

String str = "hello";
String concat = str.concat("world");
// 输出: helloworld
System.out.println(concat);

一旦创建就不能修改，任何修改都会创建一个新的String

Java 数组

声明 Declare

int[] a1;
int[] a2 = {1, 2, 3};
int[] a3 = new int[]{1, 2, 3};
int[] a4 = new int[3];
a4[0] = 1;
a4[2] = 2;
a4[3] = 3;

修改 Modify

int[] a = {1, 2, 3};
System.out.println(a[0]); // 1
a[0] = 9;
System.out.println(a[0]); // 9
System.out.println(a.length); // 3

循环 (读 & 写)

int[] arr = {1, 2, 3};
for (int i=0; i < arr.length; i++) {
    arr[i] = arr[i] * 2;
    System.out.print(arr[i] + " ");
}
// 输出: 2 4 6

Loop (Read)

String[] arr = {"a", "b", "c"};
for (int a: arr) {
    System.out.print(a + " ");
}
// 输出: a b c

二维数组 Multidimensional Arrays

int[][] matrix = { {1, 2, 3}, {4, 5} };
int x = matrix[1][0];  // 4
// [[1, 2, 3], [4, 5]]
Arrays.deepToString(matrix)
for (int i = 0; i < a.length; ++i) {
  for(int j = 0; j < a[i].length; ++j) {
    System.out.println(a[i][j]);
  }
}
// 输出: 1 2 3 4 5 6 7

排序 Sort

char[] chars = {'b', 'a', 'c'};
Arrays.sort(chars);
// [a, b, c]
Arrays.toString(chars);

Java 条件语句

运算符

+ (加法运算符(也用于字符串连接))
- (减法运算符)
* (乘法运算符)
/ (分区运算符)
% (余数运算符)
= (简单赋值运算符)
++ (增量运算符；将值增加 1)
-- (递减运算符；将值减 1)
! (逻辑补码运算符；反转布尔值)

== (等于)
!= (不等于)
> (比...更棒)
>= (大于或等于)
< (少于)
<= (小于或等于)

&& 条件与
|| 条件或
?: 三元(if-then-else 语句的简写)

instanceof (将对象与指定类型进行比较)

~ (一元按位补码)
<< (签名左移)
>> (有符号右移)
>>> (无符号右移)
& (按位与)
^ (按位异或)
| (按位包含 OR)

If else

int k = 15;
if (k > 20) {
  System.out.println(1);
} else if (k > 10) {
  System.out.println(2);
} else {
  System.out.println(3);
}

Switch

int month = 3;
String str;
switch (month) {
  case 1:
    str = "January";
    break;
  case 2:
    str = "February";
    break;
  case 3:
    str = "March";
    break;
  default:
    str = "Some other month";
    break;
}
// 输出: Result March
System.out.println("Result " + str);

三元运算符

int a = 10;
int b = 20;
int max = (a > b) ? a : b;
// 输出: 20
System.out.println(max);

逻辑运算符

// 与运算
if (condition1 && condition2) {
  // 如果 condition1 和 condition2 都成立
  // 则执行此处的代码
}

// 或运算
if (condition1 || condition2) {
  // 如果condition1或condition2任意一个成立
  // 则执行此处的代码
}

// 非运算
if (!condition) {
  // 如果条件不成立，则执行此处的代码
}

比较运算

// 等于
if (a == b) {
    // 如果a等于b，则执行此处的代码
}

// 不等于
if (a != b) {
    // 如果a不等于b，则执行此处的代码
}

// 大于、大于等于、小于、小于等于
if (a > b) {}
if (a >= b) {}
if (a < b) {}
if (a <= b) {}

Java 循环

For 循环

for (int i = 0; i < 10; i++) {
  System.out.print(i);
}
// 输出: 0123456789

for (int i = 0,j = 0; i < 3; i++,j--) {
  System.out.print(j + "|" + i + " ");
}
// 输出: 0|0 -1|1 -2|2

增强的 For 循环

int[] numbers = {1,2,3,4,5};
for (int number: numbers) {
  System.out.print(number);
}
// 输出: 12345

用于循环数组或列表

While 循环

int count = 0;
while (count < 5) {
  System.out.print(count);
  count++;
}
// 输出: 01234

Do While 循环

int count = 0;
do {
  System.out.print(count);
  count++;
} while (count < 5);
// 输出: 01234

继续声明

for (int i = 0; i < 5; i++) {
  if (i == 3) {
    continue;
  }
  System.out.print(i);
}
// 输出: 01245

中断语句

for (int i = 0; i < 5; i++) {
  System.out.print(i);
  if (i == 3) {
    break;
  }
}
// 输出: 0123

Java 多线程

创建线程

// 实现Runnable接口
public class RunnableThread implements Runnable {
    @Override
    public void run() {
       // todo something
    }
}

实现Callable接口,T 替换成实际类型

public class CallableTask implements Callable<T> {
    @Override
    public T call() throws Exception {
        // todo something
        return null;
    }
}

继承Thrad类

public class ExtendsThread extends Thread {
    @Override
    public void run() {
       // todo something
    }
}

运行线程

public static void main(String[] args) throws ExecutionException, InterruptedException {
    new Thread(new RunnableThread()).start();
    new ExtendsThread2().start();
    FutureTask<Integer> integerFutureTask = new FutureTask<>(new CallableTask());
    integerFutureTask.run();
}

线程池

corePoolSize: 核心线程数
maximumPoolSize: 最大线程数
keepAliveTime: 线程空闲时间
timeUni: 线程空闲时间单位
workQueue: 线程等待队列
threadFactory: 线程创建工厂
handler: 拒绝策略

ThreadPoolExecutor threadPoolExecutor
  = new ThreadPoolExecutor(
  2, 5,
  5, TimeUnit.SECONDS,
  new ArrayBlockingQueue<>(10),
  new DefaultThreadFactory("pollName"),
  new ThreadPoolExecutor.CallerRunsPolicy()
);

// 内置的线程池, 不推荐生产使用
Executors.newCachedThreadPool();
Executors.newFixedThreadPool(10);
Executors.newScheduledThreadPool(10);
Executors.newSingleThreadExecutor();

synchronized

// 代码块
synchronized(obj) {
   ...
}

// (静态)方法
public synchronized
  (static) void methodName() {
   ...
}

线程编排

// CountDownLatch
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(() -> {
    try {
       ...
    }finally {
       countDownLatch.countDown();
    }
}).start();
countDownLatch.await();

CompletableFuture

CompletableFuture<Void> task1 = CompletableFuture.runAsync(() -> {});
CompletableFuture<Void> task2 = CompletableFuture.runAsync(() -> {});
CompletableFuture<Void> task3 = CompletableFuture.runAsync(() -> {});
CompletableFuture.allOf(task1, task2, task3).get();

Semaphore

Semaphore semaphore = new Semaphore(5);
try {
    semaphore.acquire();
} finally {
    semaphore.release();
}

ThreadLocal

ThreadLocal<Integer> threadLocal
    = new ThreadLocal<>();

使用完之后一定要记得 remove, 否则会内存泄露

threadLocal.set(1);
threadLocal.get();
threadLocal.remove();

线程等待与唤醒

// 需要synchronized修饰的代码块才能使用
wait();
notify();
notifyAll();

// 使用lock的条件唤醒
ReentrantLock lock = new ReentrantLock();
Condition condition= lock.newCondition();
lock.lock();
try{
   // 当前线程唤醒或等待
    condition.await();
    condition.signal();
    condition.signalAll();
} finally {
  lock.unlock
}

// LockSupport,可以先unpark,后续park不会阻塞线程
LockSupport.park(obj);
LockSupport.unpark(thread);

Java 框架搜集

Java 集合

集合	Interface	有序	已排序	线程安全	复制	Nullable
ArrayList	List	Y	N	N	Y	Y
Vector	List	Y	N	Y	Y	Y
LinkedList	List, Deque	Y	N	N	Y	Y
CopyOnWriteArrayList	List	Y	N	Y	Y	Y
HashSet	Set	N	N	N	N	One `null`
LinkedHashSet	Set	Y	N	N	N	One `null`
TreeSet	Set	Y	Y	N	N	N
CopyOnWriteArraySet	Set	Y	N	Y	N	One `null`
ConcurrentSkipListSet	Set	Y	Y	Y	N	N
HashMap	Map	N	N	N	N (key)	One `null` (key)
HashTable	Map	N	N	Y	N (key)	N (key)
LinkedHashMap	Map	Y	N	N	N (key)	One `null` (key)
TreeMap	Map	Y	Y	N	N (key)	N (key)
ConcurrentHashMap	Map	N	N	Y	N (key)	N
ConcurrentSkipListMap	Map	Y	Y	Y	N (key)	N
ArrayDeque	Deque	Y	N	N	Y	N
PriorityQueue	Queue	Y	N	N	Y	N
ConcurrentLinkedQueue	Queue	Y	N	Y	Y	N
ConcurrentLinkedDeque	Deque	Y	N	Y	Y	N
ArrayBlockingQueue	Queue	Y	N	Y	Y	N
LinkedBlockingDeque	Deque	Y	N	Y	Y	N
PriorityBlockingQueue	Queue	Y	N	Y	Y	N

ArrayList

List<Integer> nums = new ArrayList<>();
// 添加
nums.add(2);
nums.add(5);
nums.add(8);
// 检索
System.out.println(nums.get(0));
// 为循环迭代编制索引
for (int i = 0; i < nums.size(); i++) {
    System.out.println(nums.get(i));
}
nums.remove(nums.size() - 1);
nums.remove(0); // 非常慢
for (Integer value : nums) {
    System.out.println(value);
}
// lambda 打印元素
nums.forEach(
  e -> System.out.println(e.toString())
);

HashMap

Map<Integer, String> m = new HashMap<>();
m.put(5, "Five");
m.put(8, "Eight");
m.put(6, "Six");
m.put(4, "Four");
m.put(2, "Two");
// 检索
System.out.println(m.get(6));
// Lambda forEach
m.forEach((key, value) -> {
    String msg = key + ": " + value;
    System.out.println(msg);
});

ConcurrentHashMap

ConcurrentHashMap<Integer, String> m
            = new ConcurrentHashMap<>();
m.put(100, "Hello");
m.put(101, "Geeks");
m.put(102, "Geeks");
// 移除
m.remove(101, "Geeks");

// 如果不存在，就添加，存在就不变更
m.putIfAbsent(103, "Hello");

// 替换
m.replace(101, "Hello", "For");
System.out.println(m);

HashSet

Set<String> set = new HashSet<>();
if (set.isEmpty()) {
    System.out.println("Empty!");
}
set.add("dog");
set.add("cat");
set.add("mouse");
set.add("snake");
set.add("bear");
if (set.contains("cat")) {
    System.out.println("Contains cat");
}
set.remove("cat");
for (String element : set) {
    System.out.println(element);
}
set.forEach(
  e -> System.out.println(e.toString())
);

ArrayDeque

Deque<String> a = new ArrayDeque<>();
// 使用 add()
a.add("Dog");
// 使用 addFirst()
a.addFirst("Cat");
// 使用 addLast()
a.addLast("Horse");
// [Cat, Dog, Horse]
System.out.println(a);
// 访问元素
System.out.println(a.peek());
// 移除元素
System.out.println(a.pop());

Java I/O流

常见的类和操作

字节流

InputStream 字节输入流的抽象基类
FileInputStream 从文件中读取字节的输入流
ByteArrayInputStream 从字节数组中读取字节的输入流
OutputStream 字节输出流的抽象基类
FileOutputStream 向文件中写入字节的输出流
ByteArrayOutputStream 将字节写入到字节数组的输出流

字符流

Reader 字符输入流的抽象基类
FileReader 从文件中读取字符的输入流
BufferedReader 带缓冲区的字符输入流
InputStreamReader 字节流到字符流的桥接器
Writer 字符输出流的抽象基类
FileWriter 向文件中写入字符的输出流
BufferedWriter 带缓冲区的字符输出流
OutputStreamWriter 字符流到字节流的桥接器

对象流

ObjectInputStream 从输入流中读取Java对象的流
ObjectOutputStream 将Java对象写入输出流的流

缓冲流

BufferedInputStream 带缓冲区的字节输入流
BufferedOutputStream 带缓冲区的字节输出流
BufferedReader 带缓冲区的字符输入流
BufferedWriter 带缓冲区的字符输出流

数据流

DataInputStream 从输入流中读取基本数据类型的数据
DataOutputStream 将基本数据类型数据写入输出流

文件类

File 文件和目录路径名的抽象表示
FileReader 从文件中读取字符的输入流
FileWriter 向文件中写入字符的输出流

输入输出异常处理

IOException Java I/O操作中的通用异常
FileNotFoundException 当试图打开指定文件失败时抛出
EOFException 在尝试读取流的末尾时抛出

其他流

PrintStream 打印格式化表示的对象的输出流
PrintWriter 格式化的文本输出流
RandomAccessFile 随机访问文件的类，支持读取和写入操作

字节流

// 文件输入流
InputStream inputStream
  = new FileInputStream("input.txt");

// 文件输出流
OutputStream outputStream
  = new FileOutputStream("output.txt");

// 缓冲字节输入流
InputStream bufferedInputStream
  = new BufferedInputStream(inputStream);

// 缓冲字节输出流
OutputStream bufferedOutputStream
  = new BufferedOutputStream(outputStream);

字符流

// 文件字符输入流
Reader fileReader
  = new FileReader("input.txt");

// 文件字符输出流
Writer fileWriter
  = new FileWriter("output.txt");

// 缓冲字符输入流
Reader bufferedFileReader
  = new BufferedReader(
    new FileReader("input.txt")
  );

// 缓冲字符输出流
Writer bufferedFileWriter
  = new BufferedWriter(
    new FileWriter("output.txt")
  );

数据流

// 数据输入流
DataInputStream dataInputStream
  = new DataInputStream(inputStream);

// 数据输出流
DataOutputStream dataOutputStream
  = new DataOutputStream(outputStream);

对象流

// 对象输入流
ObjectInputStream objectInputStream
  = new ObjectInputStream(inputStream);

// 对象输出流
ObjectOutputStream objectOutputStream
  = new ObjectOutputStream(outputStream);

序列化与反序列化

序列化对象到文件

try (
  ObjectOutputStream objectOutputStream
    = new ObjectOutputStream(new FileOutputStream("object.dat"))
) {
    objectOutputStream.writeObject(object);
}

从文件反序列化对象

try (
  ObjectInputStream objectInputStream
    = new ObjectInputStream(new FileInputStream("object.dat"))
) {
    Object object = objectInputStream.readObject();
}

标准输入输出流

标准输入流

InputStream standardInputStream
      = System.in;

标准输出流

PrintStream standardOutputStream
      = System.out;

基本操作

// 读取字节数据
int byteData = inputStream.read();

// 写入字节数据
outputStream.write(byteData);

// 读取字符数据
int charData = reader.read();

// 写入字符数据
writer.write(charData);

关闭流

// 关闭输入流
inputStream.close();

// 关闭输出流
outputStream.close();

Java Stream 流

创建流

从集合创建流

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream();

从数组创建流

String[] array = {"d", "e", "f"};
Stream<String> streamFromArray = Arrays.stream(array);

创建空流

Stream<String> emptyStream = Stream.empty();

创建无限流

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);

中间操作

// 过滤
Stream<String> filteredStream = list.stream().filter(
  s -> s.startsWith("a")
);

// 映射
Stream<Integer> mappedStream = list.stream().map(String::length);

// 排序
Stream<String> sortedStream = list.stream().sorted();

// 去重
Stream<String> distinctStream = list.stream().distinct();

// 截断
Stream<String> limitedStream = list.stream().limit(2);

// 跳过
Stream<String> skippedStream = list.stream().skip(1);

终端操作

// 聚合操作
Optional<String> anyElement = list.stream().findAny();
Optional<String> firstElement = list.stream().findFirst();
long count = list.stream().count();
Optional<String> maxElement = list.stream()
    .max(Comparator.naturalOrder());
Optional<String> minElement = list.stream()
    .min(Comparator.naturalOrder());

// 检查匹配
boolean anyMatch = list.stream().anyMatch(s -> s.contains("a"));
boolean allMatch = list.stream().allMatch(s -> s.length() == 1);
boolean noneMatch = list.stream().noneMatch(s -> s.contains("z"));

// 归约
Optional<String> reducedString = list.stream()
  .reduce((s1, s2) -> s1 + s2);
String reducedStringWithIdentity = list.stream()
  .reduce("Start:", (s1, s2) -> s1 + s2);

// 收集
List<String> collectedList = list.stream()
    .collect(Collectors.toList());
Set<String> collectedSet = list.stream()
    .collect(Collectors.toSet());
Map<Integer, String> collectedMap = list.stream()
    .collect(
        Collectors.toMap(String::length, Function.identity())
    );

并行流

List<String> list = Arrays.asList("a", "b", "c", "d", "e");
List<String> upperCaseList = list.parallelStream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

反射

这些是使用 Java 反射时常见的操作。使用反射需要注意性能和安全性问题，尽量避免在性能要求高的地方过度使用。

获取 Class 对象

// 通过类名获取Class对象
Class<?> clazz1 = MyClass.class;

// 通过对象获取Class对象
MyClass obj = new MyClass();
Class<?> clazz2 = obj.getClass();

// 通过完整类名字符串获取Class对象
Class<?> clazz3 = Class.forName("com.example.MyClass");

获取类的信息

获取类的名称

String className = clazz.getName();

获取类的修饰符

int modifiers = clazz.getModifiers();

获取类的包信息

Package pkg = clazz.getPackage();

获取类的父类

Class<?> superClass = clazz.getSuperclass();

获取类实现的接口

Class<?>[] interfaces = clazz.getInterfaces();

创建对象实例

// 使用默认构造函数创建对象
MyClass instance = (MyClass) clazz.newInstance();

// 使用带参数的构造函数创建对象
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
MyClass instanceWithArgs = (MyClass) constructor.newInstance("example", 123);

获取和设置字段值

// 获取字段值
Field field = clazz.getDeclaredField("fieldName");
field.setAccessible(true); // 如果字段是私有的，需要设置可访问
Object value = field.get(instance);

// 设置字段值
field.set(instance, newValue);

处理泛型

// 获取泛型信息
Type genericType = field.getGenericType();

调用方法

// 获取方法
Method method = clazz.getDeclaredMethod("methodName", parameterTypes);
method.setAccessible(true); // 如果方法是私有的，需要设置可访问

// 调用方法
Object result = method.invoke(instance, args);

其他常用操作

// 判断是否是数组、枚举、注解等
boolean isArray = clazz.isArray();
boolean isEnum = clazz.isEnum();
boolean isAnnotation = clazz.isAnnotation();

// 获取构造函数、字段、方法等
Constructor<?>[] constructors = clazz.getConstructors();
Field[] fields = clazz.getDeclaredFields();
Method[] methods = clazz.getDeclaredMethods();

处理注解

// 获取注解信息
Annotation annotation = field.getAnnotation(MyAnnotation.class);

方法引用

Java 的 Consumer 接口里的 accept 方法接受参数但不返回值。要让它打印传入的参数，可以这样做：

Consumer<String> test = new Consumer<String>() {
    @Override
    public void accept(String s) {
      System.out.println(s);
    }
  };
test.accept("test");

更简单的，我们可以直接传入Lambda表达式

Consumer<String> test = System.out::println;

方法引用通过方法的名字指向一个方法，使语言构造更简洁，减少冗余代码。

使用方式

引用方法
引用构造方法
引用数组

静态方法引用

Comparator<Integer> comparator = Math::max;

int result = comparator.compare(1, 2);
// 返回 2

实例方法引用

String str = "HELLO";

String lowerCase = str::toLowerCase;
// 返回 "hello"

构造方法引用

Supplier<String> supplier = String::new;

String str = supplier.get();
// 返回一个空字符串

数组构造方法引用

Function<Integer, String[]> function = String[]::new;


String[] array = function.apply(5);
// 返回 5 个空字符串的数组

对象中的方法引用

String someStr = "HELLO";

String lowerCase = someStr::toLowerCase;
// 返回 "hello"

对象中的静态方法引用

SomeClass someObject = new SomeClass();

int result = someObject::staticMethod;
// 调用静态方法

杂项 Misc

访问修饰符

修饰符	Class	Package	Subclass	World
public	Y	Y	Y	Y
protected	Y	Y	Y	N
no modifier	Y	Y	N	N
private	Y	N	N	N

常用表达

String text = "I am learning Java";
// 删除所有空格
text.replaceAll("\\s+", "");
// 拆分字符串
text.split("\\|");
text.split(Pattern.quote("|"));

查看: Regex in java

注释 Comment

// 我是单行注释！

/*
而我是一个
多行注释！
*/
/**
  * 这个
  * 是
  * 文档
  * 注释
 */

关键字

abstract
continue
for
new
switch
assert
default
goto
package
synchronized
boolean
do
if
private
this
break
double
implements
protected
throw
byte
else
import
public
throws
case
enum
instanceof
return
transient
catch
extends
int
short
try
char
final
interface
static
void
class
finally
long
strictfp
volatile
const
float
native
super
while

数学方法

方法	说明
`Math.max(a,b)`	`a` 和 `b` 的最大值
`Math.min(a,b)`	`a` 和 `b` 的最小值
`Math.abs(a)`	绝对值
`Math.sqrt(a)`	`a` 的平方根
`Math.pow(a,b)`	`b` 的幂
`Math.round(a)`	最接近的整数
`Math.sin(ang)`	正弦
`Math.cos(ang)`	`ang` 的余弦
`Math.tan(ang)`	`ang` 的切线
`Math.asin(ang)`	`ang` 的反正弦
`Math.log(a)`	`a` 的自然对数
`Math.toDegrees(rad)`	以度为单位的角度弧度
`Math.toRadians(deg)`	以弧度为单位的角度度

异常 Try/Catch/Finally

try {
  // something
} catch (Exception e) {
  e.printStackTrace();
} finally {
  System.out.println("always printed");
}

util工具类

ArrayDeque: 可调整大小的数组双端队列，实现了Deque接口
Arrays: 提供静态工厂，允许将数组视为列表
Collections: 包含操作集合或返回集合的静态方法
Date: 表示特定时间瞬间，精度为毫秒
Dictionary: 抽象父类，可用于键值对映射，例如Hashtable
EnumMap: 专门用于枚举键的Map实现
EnumSet: 专门用于枚举键的Set实现
Formatter: 提供对布局、对齐、数字、字符串和日期/时间数据的格式化支持，以及特定于语言环境的输出
SecureRandom: 生成安全的伪随机数流的实例
UUID: 表示不可变的通用唯一标识符
Vector: 实现了可增长的对象数组
LocalDate: 表示无时区的日期，仅包含年月日，不可变且线程安全，适用于Java 8及更高版本
LocalTime: 表示无时区的时间，仅包含时分秒，不可变且线程安全，适用于Java 8及更高版本
LocalDateTime: 表示无时区的日期时间，包含年月日时分秒，不可变且线程安全，适用于Java 8及更高版本

Collections 工具类

// 计算出现频率
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
int frequency = Collections
      .frequency(list, 2); // frequency = 2

操纵数据库

JDBC

String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC";
String user = "root";
String password = "123456";
String sql = "SELECT 1 as a, '2' as b";
String preparedSql = "SELECT * FROM t_user WHERE id = ?";

Connection conn = null;
Statement sm = null;
ResultSet rs = null;
try {
  // 1.注册驱动
  Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
  // 驱动找不到
  throw new RuntimeException(e);
}

// 2.建立连接
try (Connection connection = DriverManager.getConnection(url, user, password)) {

  conn = connection;

  // 3.创建Statement对象
  try (Statement statement = connection.createStatement()) {

    sm = statement;

    // 4.执行SQL语句
    try (ResultSet resultSet = statement.executeQuery(sql)) {

      rs = resultSet;

      // 5.处理结果集
      while (resultSet.next()) {
        // 按照列名取值
        System.out.println(resultSet.getLong("a"));
        // 按照索引取值
        System.out.println(resultSet.getString(2));
      }
    }
  }

  // 3.创建PreparedStatement对象
  try (PreparedStatement preparedStatement = connection.prepareStatement(preparedSql)) {

    sm = preparedStatement;

    preparedStatement.setLong(1, 1_000L);
    // 4.执行SQL语句
    try (ResultSet resultSet = preparedStatement.executeQuery()) {

      rs = resultSet;

      // 5.处理结果集
      while (resultSet.next()) {
        System.out.println(resultSet.getLong("id"));
        System.out.println(resultSet.getString(2));
      }
    }
  }
} catch (SQLException e) {
  // 数据库异常
  throw new RuntimeException(e);
} finally {
  // 6.关闭资源
  // 上面的try块里已经自动关闭，否则（JDK 7以前）按照以下顺序关闭
  // 先打开的后关闭，后打开的先关闭
  if (null != rs) {
    try {
      rs.close();
    } catch (SQLException ignored) {
    }
  }

  if (null != sm) {
    try {
      sm.close();
    } catch (SQLException ignored) {
    }
  }

  if (null != conn) {
    try {
      conn.close();
    } catch (SQLException ignored) {
    }
  }

  // 也可以直接工具类， 注意顺序
  IOUtils.close(rs);
  IOUtils.close(sm);
  IOUtils.close(conn);
}

JDBC注册驱动

Class.forName("com.mysql.cj.jdbc.Driver");

DriverManager.registerDriver(new org.postgresql.Driver());

// 支持多个同时注册
System.setProperty("jdbc.drivers", "com.mysql.cj.jdbc.Driver:org.postgresql.Driver");

另见

Java 官网 (oracle.com/cn/java)

Files

java.md

Latest commit

History