Skip to content

java.md

Latest commit

History

History
1564 lines (1242 loc) · 33.2 KB

java.md

File metadata and controls

1564 lines (1242 loc) · 33.2 KB
Raw

Java 备忘清单

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

入门

Hello.java

publicclassHello {
// 主要方法publicstaticvoidmain(String[] args)
{
// 输出: Hello, world!System.out.println("Hello, world!");
}
}

编译和运行

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

变量 Variables

intnum = 5;
floatfloatNum = 5.99f;
charletter = 'D';
booleanbool = true;
Stringsite = "jaywcjlove.github.io";

原始数据类型

数据类型大小默认范围
byte1 byte0-128 ^to^ 127
short2 byte0-2^15^ ^to^ 2^15^-1
int4 byte0-2^31^ ^to^ 2^31^-1
long8 byte0-2^63^ ^to^ 2^63^-1
float4 byte0.0fN/A
double8 byte0.0dN/A
char2 byte\u00000 ^to^ 65535
booleanN/Afalsetrue / false

字符串 Strings

Stringfirst = "John";
Stringlast = "Doe";
Stringname = first + " " + last;
System.out.println(name);

查看: Strings

循环 Loops

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

查看: Loops

数组 Arrays

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

查看: Arrays

交换变量 Swap

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

类型转换 Type Casting

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

条件语句 Conditionals

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

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

用户输入

Scannerin = newScanner(System.in);
Stringstr = in.nextLine();
System.out.println(str);
intnum = in.nextInt();
System.out.println(num);

Java 字符串

基本的

Stringstr1 = "value";
Stringstr2 = newString("value");
Stringstr3 = String.valueOf(123);

字符串连接

Strings = 3 + "str" + 3; // 3str3Strings = 3 + 3 + "str"; // 6strStrings = "3" + 3 + "str"; // 33strStrings = "3" + "3" + "23"; // 3323Strings = "" + 3 + 3 + "23"; // 3323Strings = 3 + 3 + 23; // 29

字符串生成器

StringBuildersb = newStringBuilder(10);
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| | | | | | | | | |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0123456789
sb.append("Reference");
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| R | e | f | e | r | e | n | c | e |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0123456789
sb.delete(3, 9);
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| R | e | f | | | | | | |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0123456789
sb.insert(0, "My ");
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y | | R | e | f | | | |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0123456789
sb.append("!");
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y | | R | e | f | ! | | |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0123456789

比较

Strings1 = newString("QuickRef");
Strings2 = newString("QuickRef");
s1 == s2// falses1.equals(s2) // true"AB".equalsIgnoreCase("ab") // true

操纵

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

信息

Stringstr = "abcd";
str.charAt(2); // cstr.indexOf("a") // 0str.indexOf("z") // -1str.length(); // 4str.toString(); // abcdstr.substring(2); // cdstr.substring(2,3); // cstr.contains("c"); // truestr.endsWith("d"); // truestr.startsWith("a"); // truestr.isEmpty(); // false

不可变

Stringstr = "hello";
str.concat("world");
// 输出: helloSystem.out.println(str);
Stringstr = "hello";
Stringconcat = str.concat("world");
// 输出: helloworldSystem.out.println(concat);

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

Java 数组

声明 Declare

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

修改 Modify

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

循环 (读 & 写)

int[] arr = {1, 2, 3};
for (inti=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 (inta: arr) {
System.out.print(a + " ");
}
// 输出: a b c

二维数组 Multidimensional Arrays

int[][] matrix = { {1, 2, 3}, {4, 5} };
intx = matrix[1][0]; // 4// [[1, 2, 3], [4, 5]]Arrays.deepToString(matrix)
for (inti = 0; i < a.length; ++i) {
for(intj = 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

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

Switch

intmonth = 3;
Stringstr;
switch (month) {
case1:
str = "January";
break;
case2:
str = "February";
break;
case3:
str = "March";
break;
default:
str = "Some other month";
break;
}
// 输出: Result MarchSystem.out.println("Result " + str);

三元运算符

inta = 10;
intb = 20;
intmax = (a > b) ? a : b;
// 输出: 20System.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 (inti = 0; i < 10; i++) {
System.out.print(i);
}
// 输出: 0123456789
for (inti = 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 (intnumber: numbers) {
System.out.print(number);
}
// 输出: 12345

用于循环数组或列表

While 循环

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

Do While 循环

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

继续声明

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

中断语句

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

Java 多线程

创建线程

// 实现Runnable接口publicclassRunnableThreadimplementsRunnable {
@Overridepublicvoidrun() {
// todo something
}
}

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

publicclassCallableTaskimplementsCallable<T> {
@OverridepublicTcall() throwsException {
// todo somethingreturnnull;
}
}

继承Thrad类

publicclassExtendsThreadextendsThread {
@Overridepublicvoidrun() {
// todo something
}
}

运行线程

publicstaticvoidmain(String[] args) throwsExecutionException, InterruptedException {
newThread(newRunnableThread()).start();
newExtendsThread2().start();
FutureTask<Integer> integerFutureTask = newFutureTask<>(newCallableTask());
integerFutureTask.run();
}

线程池

  • corePoolSize: 核心线程数
  • maximumPoolSize: 最大线程数
  • keepAliveTime: 线程空闲时间
  • timeUni: 线程空闲时间单位
  • workQueue: 线程等待队列
  • threadFactory: 线程创建工厂
  • handler: 拒绝策略
ThreadPoolExecutorthreadPoolExecutor
= newThreadPoolExecutor(
2, 5,
5, TimeUnit.SECONDS,
newArrayBlockingQueue<>(10),
newDefaultThreadFactory("pollName"),
newThreadPoolExecutor.CallerRunsPolicy()
);
// 内置的线程池, 不推荐生产使用Executors.newCachedThreadPool();
Executors.newFixedThreadPool(10);
Executors.newScheduledThreadPool(10);
Executors.newSingleThreadExecutor();

synchronized

// 代码块synchronized(obj) {
...
}
// (静态)方法publicsynchronized
(static) voidmethodName() {
...
}

线程编排

// CountDownLatchCountDownLatchcountDownLatch = newCountDownLatch(2);
newThread(() -> {
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

Semaphoresemaphore = newSemaphore(5);
try {
semaphore.acquire();
} finally {
semaphore.release();
}

ThreadLocal

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

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

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

线程等待与唤醒

// 需要synchronized修饰的代码块才能使用wait();
notify();
notifyAll();
// 使用lock的条件唤醒ReentrantLocklock = newReentrantLock();
Conditioncondition= 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
ArrayListListYNNYY
VectorListYNYYY
LinkedListList, DequeYNNYY
CopyOnWriteArrayListListYNYYY
HashSetSetNNNNOne null
LinkedHashSetSetYNNNOne null
TreeSetSetYYNNN
CopyOnWriteArraySetSetYNYNOne null
ConcurrentSkipListSetSetYYYNN
HashMapMapNNNN (key)One null(key)
HashTableMapNNYN (key)N (key)
LinkedHashMapMapYNNN (key)One null(key)
TreeMapMapYYNN (key)N (key)
ConcurrentHashMapMapNNYN (key)N
ConcurrentSkipListMapMapYYYN (key)N
ArrayDequeDequeYNNYN
PriorityQueueQueueYNNYN
ConcurrentLinkedQueueQueueYNYYN
ConcurrentLinkedDequeDequeYNYYN
ArrayBlockingQueueQueueYNYYN
LinkedBlockingDequeDequeYNYYN
PriorityBlockingQueueQueueYNYYN

ArrayList

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

HashMap

Map<Integer, String> m = newHashMap<>();
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 forEachm.forEach((key, value) -> {
Stringmsg = key + ": " + value;
System.out.println(msg);
});

ConcurrentHashMap

ConcurrentHashMap<Integer, String> m
= newConcurrentHashMap<>();
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 = newHashSet<>();
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 (Stringelement : set) {
System.out.println(element);
}
set.forEach(
e -> System.out.println(e.toString())
);

ArrayDeque

Deque<String> a = newArrayDeque<>();
// 使用 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 随机访问文件的类，支持读取和写入操作

字节流

// 文件输入流InputStreaminputStream
= newFileInputStream("input.txt");
// 文件输出流OutputStreamoutputStream
= newFileOutputStream("output.txt");
// 缓冲字节输入流InputStreambufferedInputStream
= newBufferedInputStream(inputStream);
// 缓冲字节输出流OutputStreambufferedOutputStream
= newBufferedOutputStream(outputStream);

字符流

// 文件字符输入流ReaderfileReader
= newFileReader("input.txt");
// 文件字符输出流WriterfileWriter
= newFileWriter("output.txt");
// 缓冲字符输入流ReaderbufferedFileReader
= newBufferedReader(
newFileReader("input.txt")
);
// 缓冲字符输出流WriterbufferedFileWriter
= newBufferedWriter(
newFileWriter("output.txt")
);

数据流

// 数据输入流DataInputStreamdataInputStream
= newDataInputStream(inputStream);
// 数据输出流DataOutputStreamdataOutputStream
= newDataOutputStream(outputStream);

对象流

// 对象输入流ObjectInputStreamobjectInputStream
= newObjectInputStream(inputStream);
// 对象输出流ObjectOutputStreamobjectOutputStream
= newObjectOutputStream(outputStream);

序列化与反序列化

序列化对象到文件

try (
ObjectOutputStreamobjectOutputStream
= newObjectOutputStream(newFileOutputStream("object.dat"))
) {
objectOutputStream.writeObject(object);
}

从文件反序列化对象

try (
ObjectInputStreamobjectInputStream
= newObjectInputStream(newFileInputStream("object.dat"))
) {
Objectobject = objectInputStream.readObject();
}

标准输入输出流

标准输入流

InputStreamstandardInputStream
= System.in;

标准输出流

PrintStreamstandardOutputStream
= System.out;

基本操作

// 读取字节数据intbyteData = inputStream.read();
// 写入字节数据outputStream.write(byteData);
// 读取字符数据intcharData = 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();
longcount = list.stream().count();
Optional<String> maxElement = list.stream()
.max(Comparator.naturalOrder());
Optional<String> minElement = list.stream()
.min(Comparator.naturalOrder());
// 检查匹配booleananyMatch = list.stream().anyMatch(s -> s.contains("a"));
booleanallMatch = list.stream().allMatch(s -> s.length() == 1);
booleannoneMatch = list.stream().noneMatch(s -> s.contains("z"));
// 归约Optional<String> reducedString = list.stream()
.reduce((s1, s2) -> s1 + s2);
StringreducedStringWithIdentity = 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对象MyClassobj = newMyClass();
Class<?> clazz2 = obj.getClass();
// 通过完整类名字符串获取Class对象Class<?> clazz3 = Class.forName("com.example.MyClass");

获取类的信息

获取类的名称

StringclassName = clazz.getName();

获取类的修饰符

intmodifiers = clazz.getModifiers();

获取类的包信息

Packagepkg = clazz.getPackage();

获取类的父类

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

获取类实现的接口

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

创建对象实例

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

获取和设置字段值

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

处理泛型

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

调用方法

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

其他常用操作

// 判断是否是数组、枚举、注解等booleanisArray = clazz.isArray();
booleanisEnum = clazz.isEnum();
booleanisAnnotation = clazz.isAnnotation();
// 获取构造函数、字段、方法等Constructor<?>[] constructors = clazz.getConstructors();
Field[] fields = clazz.getDeclaredFields();
Method[] methods = clazz.getDeclaredMethods();

处理注解

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

方法引用

方法引用

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

Consumer<String> test = newConsumer<String>() {
@Overridepublicvoidaccept(Strings) {
System.out.println(s);
}
};
test.accept("test");

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

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

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

使用方式

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

静态方法引用

Comparator<Integer> comparator = Math::max;
intresult = comparator.compare(1, 2); // 返回 2

实例方法引用

Stringstr = "HELLO";
StringlowerCase = str::toLowerCase; // 返回 "hello"

构造方法引用

Supplier<String> supplier = String::new;
Stringstr = supplier.get(); // 返回一个空字符串

数组构造方法引用

Function<Integer, String[]> function = String[]::new;
String[] array = function.apply(5); // 返回 5 个空字符串的数组

对象中的方法引用

StringsomeStr = "HELLO";
StringlowerCase = someStr::toLowerCase; // 返回 "hello"

对象中的静态方法引用

SomeClasssomeObject = newSomeClass();
intresult = someObject::staticMethod; // 调用静态方法

杂项 Misc

访问修饰符

修饰符ClassPackageSubclassWorld
publicYYYY
protectedYYYN
no modifierYYNN
privateYNNN

常用表达

Stringtext = "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 (Exceptione) {
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 = newArrayList<>();
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
intfrequency = Collections
.frequency(list, 2); // frequency = 2

另见