Java速查手册 | JavaManual

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!

原始数据类型

数据类型	大小	默认	范围
`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

类型转换 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

字符串生成器

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 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

运算符

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

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

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

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

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

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);

创建线程

// 实现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修饰的代码块才能使用
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 集合

集合	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()));

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);

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());

修饰符	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

数学方法

方法	说明
`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)`	以弧度为单位的角度度

反射

/**
* 利用反射动态加载依赖库
* 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

	每日额度
游客	999
普通会员	999
黄金月卡	999
钻石季卡	999
至尊年卡	999

入门

Hello.java

变量 Variables

原始数据类型

字符串 Strings

循环 Loops

数组 Arrays

交换变量 Swap

类型转换 Type Casting

条件语句 Conditionals

用户输入

Java 字符串

基本的

字符串连接

字符串生成器

比较

操纵

信息

不可变

Java 数组

声明 Declare

修改 Modify

循环 (读 & 写)

Loop (Read)

二维数组 Multidimensional Arrays

排序 Sort

Java 条件语句

运算符

If else

Switch

三元运算符

Java 循环

For 循环

增强的 For 循环

While 循环

Do While 循环

继续声明

中断语句

Java 多线程

创建线程

线程池

synchronized

ThreadLocal

线程等待与唤醒

线程编排

Java 框架搜集

Java 集合

ArrayList

HashMap

ConcurrentHashMap

HashSet

ArrayDeque

杂项 Misc

访问修饰符

常用表达

注释 Comment

关键字

数学方法

异常 Try/Catch/Finally

反射

util工具类

IO流

Collections 工具类

Stream 流