Java 备忘清单

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

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

查看: Strings

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

查看: Loops

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

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

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

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

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

String s1 = "QuickRef";
String s2 = new String("QuickRef");
s1 == s2                     // false
s1.equals(s2)                // true
// intern 方法获得字符串常量池中的惟一引用
s1 == s2.intern()            // 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

int[] a1;
int[] a2 = {1, 2, 3};
int[] a3 = new int[]{1, 2, 3};
int[] a4 = new int[3];
a4[0] = 1;
a4[1] = 2;
a4[2] = 3; // 正常赋值
a4[3] = 4; // 会出现索引越界异常 ArrayIndexOutOfBoundsException

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

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

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

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

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

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) {}

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

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

用于循环数组或列表

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

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);
}
// 输出: 0124

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

public class Dog {
  private String name;

  // 构造方法无无返回值，方法名与类名相同
  // 一个类可以有多个构造方法
  // Java 默认提供一个无参构造方法（只有在没有显式定义任何构造方法时）
  public Dog() {
  }

  public Dog(String name) {
    this.name = name;
  }
}

public class Dog {
  // 成员变量
  private String name;

  // 类变量
  // 多对象将会共享同一个类变量
  static int val = 10;

  public void Say() {
    // 局部变量
    String sentence = "hello";
    System.out.println(sentence);
  }
}

Dog myDog = new Dog(); // 调用无参构造函数
Dog myDog2 = new Dog("aaa"); // 调用对应参数列表的构造函数

// 调用方法
myDog.Say();

抽象类不能被实例化为对象，因此，抽象类必须被继承才能够使用 抽象类使用abstract 关键字进行修饰

public abstract class Animal {
  String name;

  public Animal(String name) {
    this.name = name;
  }
}

public class Dog extends Animal {
  public Dog(String name) {
    super(name);
  }
}

使用abstract 关键字修饰的方法是抽象方法 抽象方法必须包含在抽象类中 子类必须重写父类中的所有抽象方法，除非子类也是抽象类

public abstract class Animal {
  String name;

  public Animal(String name) {
    this.name = name;
  }

  public abstract void say();
}

public class Dog extends Animal {
  public Dog(String name) {
    super(name);
  }

  public void say(){
    System.out.println("Dog");
  }

}

• corePoolSize: 核心线程数
• maximumPoolSize: 最大线程数
• keepAliveTime: 线程空闲时间
• TimeUnit: 线程空闲时间单位
• 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(obj) {
   ...
}

// 实例方法同步
public synchronized void methodName() {
   ...
}

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

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

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

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

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

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

// 文件输入流 （注意：需要手动关闭或使用 try-with-resources）
InputStream inputStream
  = new FileInputStream("input.txt");

// 文件输出流 （注意：需要手动关闭或使用 try-with-resources）
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);

标准输入流

InputStream standardInputStream
      = System.in;

标准输出流

PrintStream standardOutputStream
      = System.out;

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

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

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

Comparator<Integer> comparator = Math::max;

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

BinaryOperator<Integer> maxOperator = Math::max;
int result = maxOperator.apply(1, 2);
// 返回 2

String str = "HELLO";
Supplier<String> lowerCaseSupplier = str::toLowerCase;
String lowerCase = lowerCaseSupplier.get();
// 返回 "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";

Supplier<String> lowerCaseSupplier = someStr::toLowerCase;
String lowerCase = lowerCaseSupplier.get();
// 返回 "hello"

SomeClass someObject = new SomeClass();

Supplier<Integer> methodSupplier = someObject::staticMethod;
int result = methodSupplier.get();
// 调用静态方法

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

查看: Regex in java

// 我是单行注释！

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

try {
  // something
} catch (Exception e) {
  // 建议使用日志框架记录异常
  logger.error("发生异常", e);
  // 或者至少使用标准错误流
  // e.printStackTrace();
} finally {
  System.out.println("总是执行");
}

// 计算出现频率
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

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

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