int m = 5, n = 10;
// 初始化一个大小为 10 的 int 数组
// 其中的值默认初始化为 0
int[] nums = new int[n];

// 初始化一个 m * n 的二维布尔数组
// 其中的元素默认值初始化为 false
boolean[][] visited = new boolean[m][n];

// 长度
nums.length;

String s1 = "hello world";
// 获取 s1[2] 中的字符
char c = s1.charAt(2);

char[] chars = s1.toCharArray();
chars[1] = 'a';
String s2 = new String(chars);
// output: hallo world
System.out.println(s2);

// 注意，用 equals 方法判断字符串是否相同
if (s1.equals(s2)) {
    // 相同
} else {
    // 不同
}

// 字符串可以用加号拼接
String s3 = s1 + '!';
// output: hello world!
System.out.println(s3);
// 加号拼接不推荐，使用 StringBuilder
StringBuilder sb = new StringBuilder();
for (char c = 'a'; c < 'f'; c ++) {
    sb.append(c);
}
// append 方法支持拼接字符、字符串、数字等类型
sb.append('a').append("hij").append(123);
String res = sb.toString();
// output: abcedfghij123
System.out.println(res);

// 初始化一个储存 String 类型数据的动态数组
ArrayList<String> nums = new ArrayList<>();
// 初始化一个储存 Integer 类型数据的动态数组
ArrayList<Integer> nums = new ArrayList<>();

// 常用的方法：
// 判断数组是否为空
boolean isEmpty();
// 返回数组中元素的个数
int size();
// 返回所有 index 的元素
E get(int index);
// 在数组尾部添加元素 e
boolean add(E e);
// 返回元素的索引值
int indexOf(E e);
// 删除 arraylist 里的单个元素
boolean remove(int index)

// 初始化一个存储 String 类型数据的双链表
LinkedList<String> strings = new LinkedList<>();

// 常用方法：
// 判断链表是否为空
boolean isEmpty();
// 返回链表中元素的个数
int size();
// 判断链表中是否存在元素 o
boolean contains(Object o);
// 在链表尾部添加元素 e
boolean add(E e);
// 在链表头部添加元素 e
void addFirst(E e);
// 删除链表头部第一个元素
E removeFirst();
// 删除链表尾部最后一个元素
E removeLast();

// 初始化，整数映射到字符串的哈希表
HashMap<Integer, String> map = new HashMap<>();
// 字符串映射到数组的哈希表
HashMap<String, int[]> map = new HashMap<>();

// 常用方法： 
// 判断哈希表中是否存在键
boolean containsKey(Object key);
// 获取键 key 对应的值，若 key 不存在，则返回 null
V get(Object key);
// 将 key 和 value 键值对存入哈希表
V put(K key, V value);
// 如果 key 存在，删除 key 并返回对应的值
V remove(Object key);
// 获得 key 的值，如果 key 不存在，返回 defaultValue
V getOrDefault(Object key, V defaultValue);
// 获取哈希表中的所有 key
Set<K> keySet();
// 如果 key 不存在，则将键值对 key 和 value 存入哈希表
// 如果 key 存在，则什么都不做
V putIfAbsent(K key, V value);
// 遍历 HashMap
for (Map.Entry e : h.entrySet()) {
    int val = (int) e.getValue();
}

// 新建一个存储 String 的哈希集合
Set<String> set = new HashSet<>();

// 常用方法：
// 如果 e 不存在，则将 e 添加到哈希集合
boolean add(E e);
// 判断元素 o 是否在哈希集合中
boolean contains(Object o);
// 如果元素 o 存在，则删除元素 o
boolean remove(Object o);

//  新建一个存储 String 的队列
Queue<String> q = new LinkedList<>();

// 常用方法：
// 判断队列是否为空
boolean isEmpty();
// 返回队列中元素的个数
int size();
// 返回队头的元素
E peek();
// 删除并返回队头的元素
E poll();
// 将元素 e 插入队尾
boolean offer(E e);

// 初始化
Stack<Integer> stack = new Stack<>();

// 常用方法：
// 判断堆栈是否为空
boolean isEmpty();
// 返回堆栈中元素的个数
int size();
// 将元素压入栈顶
E push(E item);
// 返回栈顶元素
E peek();
// 删除并返回栈顶元素
E pop();

// 初始化
Deque<Integer> deque = new LinkedList<>();

// 常用方法：
// 判断是否为空
boolean isEmpty();
// 返回元素的个数
int size();
// 添加元素
boolean offerFirst(E e);
boolean offerLast(E e);
// 弹出元素
E pollFirst();
E pollLast();
// 返回两端元素
E peekFirst();
E peekLast();

String[] aArray = new String[5];
String[] bArray = {"a", "a", "a", "a", "a"};
String[] cArray = new String[] {"a", "a", "a", "a", "a"};

String str = "hello world";

StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder(10);
StringBuilder sb3 = new StringBuilder("hello world");

// 添加变量
sb1.append("java");

ArrayList<String> arrList = new ArrayList<>();

// 添加变量
arrList.add("hello");

String[] array = new String[] {"a", "a", "a", "a", "a"};
ArrayList<String> arrList = new ArrayList<String>(Arrays.asList(array));

// 因为要转为数组，所以xian'x
String[] array = new String[arrList.size()];
arrList.toArray(array);
// 转二维数组
List<int[]> list = new ArrayList<>();
array.toArray(new int[list.size()][]);

String str = "hello";
StringBuilder sb = new StringBuilder();
sb.append(str);

String str = sb.toString();

arrList.add(str);

String[] array = new String[arrList.size()];
String str = Arrays.toString(arrList.toArray(array));

String[] array = new String[] {str1, str2};

StringBuilder sb = new StringBuilder();
for (String tmp : array) {
    sb.append(tmp);
}
String str = sb.toString();

StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.length; i ++) {
    sb.append(array[i]);
}

String[] array = new String[] {sb1.toString(), sb2.toString()};

StringBuilder sb = new StringBuilder();
for (String tmp : array) {
    sb.append(tmp);
}

ArrayList<String> arrList = new ArrayList<String>();
arrList.add(sb.toString());

String str3 = "hello world";
char[] ch = str3.toCharArray();

String str4 = String.valueOf(ch);

Arrays.asList(array).contains("hello");

Collections.reverse(Arrays.asList(array));

Set<String> set = new HashSet<String>(Arrays.asList(gArray));

int[] num = {1, 2, 3, 4, 5, 6, 7, 8, 9};
String[] array = Arrays.toString(num);

int[] num1 = {2, 4, 3, 1};
String[] hArray = {"world", "hello", "today", "word"};
Arrays.sort(num1, 1, 3); // 2 | 3 4 | 1
Arrays.sort(num1);
Arrays.sort(hArray);
// 二维数组排序（x第一维从小到大，第二维从大到小）
int[][] nums2 = new int[][] {初始化};
Arrays.sort(nums2, ((o1, o2) -> {
    if (o1[0] < o2[0]) return -1;
    else if (o1[0] > o2[0]) return 1;
    else return Integer.compare(o2[1], o1[1]);
}));

String[] iArray = {"a", "d", "c"};
String[] jArray = Arrays.copyOf(iArray, 4); // [a, b, c, null]
String[] kArray = Arrays.copyOfRange(iArray, 1, 3); // [c, d]

Arrays.equals(array1, array2);

String[] array1 = {"a", "d", "y", "c", "a", "k", "y"};
Set<String> set = new HashSet<String>(Arrays.asList(array1));//  set: [a, c, d, y, k]
String[] array2 = new String[set.size()];
set.toArray(array2);//  array2: [a, c, d, y, k]

Arrays.sort(array);
array[0];

StringBuilder sb = new StringBuilder(str);
sb.deleteCharAt(3);

ArrayList<String> arrList = new ArrayList<String>(Arrays.asList(array));
arrList4.remove(2);