一、Java 模块

System 类

// Object src: 原数组
// srcPos: 从元数据的起始位置开始
// Object dest: 目标数组
// destPos: 目标数组的开始起始位置
// length: 要copy的数组的长度
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

String 模块

// 将字符串分割成n部分
String s = "a1 9 2 3 1";
String[] ss = s.split(" ", n); //n=2时，ss=["a1", "9 2 3 1"]
// 比较两个字符串的大小：0表示全等；-1：小于；1：大于
int ans = s1.compareTo(s2); 
// 替换指定位置的子串（String 只能替换全部）
sb.replace(j, j+len, ts[i]);

Map 模块

computeIfAbsent 方法

// 方法定义
default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
    ...
}

我们看一下在 java8 之前是然后和从 map 中根据 key 获取 value 的

Object val = map.get("key");
if (val == null) {
    val = new Object();
    map.put("key", val);
}

在 java8 之后，上面的操作可以简化为一行，若 key 对应的 value 为空，会将第 2 个参数的返回值存入并作为结果返回。

Object val = map.computeIfAbsent("key", k -> new Object());

compute 方法

// 新方式
for (int a : A) m.compute(a, (k,v) -> v == null ? 1 : v+1);

forEach 方法

// 创建一个Map
Map<String, Object> m = new HashMap<>();
m.put("name", "xxx");
m.put("email", "xxx.qq.com");

// 传统的Map迭代方式
for (Map.Entry<String, Object> entry : m.entrySet()) {
    System.out.println(entry.getKey() + "：" + entry.getValue());
}

// JDK8的迭代方式
m.forEach((key, value) -> {
    System.out.println(key + "：" + value);
});

List 的 forEach 也有：https://blog.csdn.net/qq_26718271/article/details/70257049

细节遍历键值对推荐使用以下方法

for (Map.Entry<Integer, LinkedList<Integer>> e : m.entrySet()) {
    Collections.sort(e.getValue());
}

TreeMap

增

public V put(K key, V value) 添加一对键值对
public void putAll(Map<? extends K, ? extends V> map) 添加一个map的所有键值对

删

`public V remove(Object key) 删除对应的键值对
public void clear() 删除所有元素

查

public K higherKey(K key) 返回key严格大于指定key的最小键
public Map.Entry<K,V> higherEntry(K key) 返回key严格大于指定key的最小键值对
public K ceilingKey(K key) 返回map中键值不小于参数key的最小键值
public Map.Entry<K,V> ceilingEntry(K key) 返回map中键值不小于参数key的最小键值对应的键值对，如果没有则返回null
public K floorKey(K key) 返回Map中不大于指定key的最大key值
public Map.Entry<K,V> floorEntry(K key) 返回Map中不大于指定key的最大key值所对应的键值对
public K lowerKey(K key) 返回key严格小于指定值的最大键
public Map.Entry<K,V> lowerEntry(K key) 返回key严格小于指定值的最大键值对
public K firstKey() 返回第一个key
public Map.Entry<K,V> firstEntry() 返回第一个键值对
public K lastKey() 返回最后一个key
public Map.Entry<K,V> lastEntry() 返回最后一组键值对
public boolean containsValue(Object value) 判断是否含有某一value
public NavigableMap<K, V> descendingMap() 返回一个降序排列的Map
public NavigableSet<K> descendingKeySet() 返回一个降序排列的由键名组成的Set
public SortedMap<K,V> headMap(K toKey) 返回key小于指定key的排序好的Map
public NavigableMap<K,V> headMap(K toKey, boolean inclusive) 返回key小于或小于等于指定key的排序好的Map
public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回key在指定范围内的子Map
public SortedMap<K,V> subMap(K fromKey, K toKey) 返回key在指定范围内的子Map
public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) 返回key小于或小于等于指定key的排序好的Map
public SortedMap<K,V> tailMap(K fromKey) 返回key大于指定key的排序好的Map

改

public V replace(K key, V value) 修改一对键值对
public boolean replace(K key, V oldValue, V newValue) 如果键值对的原值为指定值，则修改，否则不修改
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) 按照指定函数运算修改所有键值对

其他

public Object clone() 克隆TreeMap
public Comparator<? super K> comparator() 返回该TreeMap的比较器

Arrays 模块

常用方法

// 排序数组；x=0顺序不变；x<0升序；x>0升序
Arrays.sort(A, (a1, a2) -> { return x; }
// 复制子数组
Arrays.copyOfRange(src, 0, 2);
// 比较两个数字是否全等
Arrays.equals(arr1, arr2)
// 快速添加List到List<List<E>>中
path.add(Arrays.asList(x, y));

二分查找

Arrays.binarySearch(object[], object key);
Arrays.binarySearch(object[], int fromIndex, int endIndex, object key);
如果数组中存在该元素，则会返回该元素在数组中的下标
如果数组中不存在该元素，则会返回 -(插入点 + 1)

void text() {
    int[] A = {1, 20, 30, 40, 50};
    int res1 = Arrays.binarySearch(A, 25); //-(2+1)
    int res2 = Arrays.binarySearch(A, -2); //-(0+1)
    int res3 = Arrays.binarySearch(A, 55); //-(5+1)
}

stream 流

// 累加数组arr中的所有值，类似C++的accumulate()
int tot = Arrays.stream(arr);

Collections 模块

// 返回空列表
Collections.emptyList();
// 返回单一元素的列表
Collections.singletonList(0);

C++ 模块

最近用迷上了 C++，简单总结一下常用的语法

1. lambda 表达式排序

sort(B.begin(), B.end(), [&](int a, int b){
    if (A[a] == A[b])
        return a < b;
    return A[a] < A[b];
});

Q：[] 里写 = 和写 & 有什么区别？

[&v]：v 是引用的对象

列表	含义
[]	空捕获列表
[n1, &n2, n3, &n4…]	以逗号为分隔的捕获列表，显示捕获
[&]	隐式捕获，lambda 中使用的变量全部采用引用捕获
[=]	隐式捕获，lambda 中使用的变量全部采用值捕获
[&, n1, n2]	混和捕获，n1和n2值捕获，其余为引用捕获
[=, &n1, &n2]	混和捕获，n1和n2引用捕获，其余为值捕获

2. 工具模块

vector

//push_back()右值时就会调用构造函数和转移构造函数，性能不如只需要构造一次的c++11 的 emplace_back，参考：https://blog.csdn.net/p942005405/article/details/84764104
G[u].emplace_back(v, w);

priority_queue

自定义排序：https://blog.csdn.net/liu2012huan/article/details/52932494

string

// 替换子串
str.replace(start_pos, old_value.length(), new_value);

map

// 第三维用于指定key的排序类型
map<int, int, greater<int>> m;
map<int, int, less<int>> m;

// 简便的遍历方法
for (auto& [k, v] : m) {...}

// 二分查找
 // 返回一个迭代器，指向键值>= key的第一个元素。
 iterator lower_bound( const key_type &key )
// 返回一个迭代器，指向键值 > key的第一个元素
 iterator upper_bound(const key_type &key):

set

// 自定义变量名
typedef multiset<int>::iterator msit;

其他

// 三元组
typedef tuple<int,int,int> tp;

常用函数

// 字母加数字
isalnum
isalpha
isdigit

来源：oschina

链接：https://my.oschina.net/u/4178666/blog/4335170

标签

Entry

【总结】Java、C++ 常用写法