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);
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() {
...
}
ThreadLocal
// 使用完之后一定要记得remove, 否则会内存泄露
ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
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);
线程编排
// 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();
}
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());
杂项 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");
}
反射
/**
* 利用反射动态加载依赖库
* java9及以上版本可用
* @param jar jar文件
*/
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
MethodHandle addURL = lookup.unreflect(method);
URL url = jar.toURI().toURL();
URLClassLoader urlClassLoader = new URLClassLoader(new URL[] {url});
addURL.invoke(urlClassLoader, url);
//java8
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(classLoader, url);
util工具类
-
ArrayDeque
提供 resizable-array 并实现 Deque 接 -
Arrays
包含一个静态工厂,允许将数组视为列表 -
Collections
包含对集合进行操作或返回集合的静态方法 -
Date
表示特定的时间瞬间,精度为毫秒 -
Dictionary
是任何类的抽象父类,例如 Hashtable,它将键映射到值 -
EnumMap
一个专门用于枚举键的 Map 实现 -
EnumSet
一个专门用于枚举键的 Set 实现 -
Formatter
提供对布局对齐和对齐、数字、字符串和日期/时间数据的常用格式以及特定于语言环境的输出的支持 -
SecureRandom
实例用于生成安全的伪随机数流 -
UUID
表示一个不可变的通用唯一标识符 -
Vector
实现了一个可增长的对象数组 -
LocalDate
表示没有时区的日期,只包含年月日,不可变并且线程安全的,java8 及以上版本可用 -
LocalTime
表示没有时区的时间,只包含时分秒,不可变并且线程安全的,java8 及以上版本可用 -
LocalDateTime
表示没有时区的日期时间,同时包含年月日时分秒,不可变并且线程安全的,java8 及以上版本可用
IO流
// 输入流转输出流
byte[] inputContent = "test".getBytes();
try (InputStream inputStream = new ByteArrayInputStream(inputContent);
OutputStream outputStream = new ByteArrayOutputStream()) {
byte[] buffer = new byte[1024];
int len;
while ((len = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
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
Stream 流
// 统计词频
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(1);
list.add(3);
list.add(2);
list.add(2);
list.add(2);
Map<Integer, Long> frequencyMap = list.stream().collect(Collectors.groupingBy(x -> x, Collectors.counting()));
// 1: 2
// 2: 3
// 3: 1
说明
该备忘单是针对Java初学者的速成课程,有助于复习Java语言的基本语法。入门,为开发人员分享快速参考备忘单。