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 = "oxings.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) ab 的最大值
Math.min(a,b) ab 的最小值
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

另见