D27
ccfcsp代码练习
材料整理
Java中数组复制
这段代码是关于Java中数组复制的示例。这里有两种常见的方法：使用 clone() 方法和 System.arraycopy() 方法。我来解释一下这两种方法的作用和区别：
1. 使用 clone() 方法
int[] a = {2, 4, 2, 9, 1, 3, 6, 5, 65, 56, 4, 5, 6, 5};
int[] b = new int[20];
b = a.clone();
System.out.println(Arrays.toString(b)); // [2, 4, 2, 9, 1, 3, 6, 5, 65, 56, 4, 5, 6, 5]
clone() 方法是 Object 类的一个方法，用于创建并返回一个对象的副本。
在这个例子中，a.clone() 创建了数组 a 的一个副本，并将其赋值给数组 b。
这种方法的优点是简单易用，但缺点是在某些情况下会有性能问题，并且需要类型转换。
2. 使用 System.arraycopy() 方法
int[] a = {2, 4, 2, 9, 1, 3, 6, 5, 65, 56, 4, 5, 6, 5};
int[] b = new int[20];
// 复制数组 a 的前 10 个元素到数组 b 中
System.arraycopy(a, 0, b, 0, 10);
System.out.println(Arrays.toString(b)); // [2, 4, 2, 9, 1, 3, 6, 5, 65, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// 复制整个数组 a 到数组 b 中
System.arraycopy(a, 0, b, 0, a.length);
System.out.println(Arrays.toString(b)); // [2, 4, 2, 9, 1, 3, 6, 5, 65, 56, 4, 5, 6, 5, 0, 0, 0, 0, 0, 0]
System.out.println(b.length); // 20（包括了多余的 0，即等于数组 b 的大小）
System.arraycopy() 是一个静态方法，用于复制数组的一部分到另一个数组中。
它的参数依次是源数组、源数组起始位置、目标数组、目标数组起始位置以及要复制的长度。
这个方法是比 clone() 方法更灵活的选择，因为你可以指定复制的起始位置和长度。
需要注意的是，当源数组的长度大于目标数组的长度时，多余的部分会被自动补零。
总体来说，如果只是简单地复制一个数组，并且不需要额外的操作，clone() 方法是一个很好的选择。但是如果需要更灵活的控制复制的范围，或者性能要求较高时，System.arraycopy() 方法是更好的选择。
四舍五入
在Java中，实现四舍五入有多种方式，下面展示了三种不同的方法：
- 使用String.format方法
System.out.println(String.format("%.0f", 7.0/2)); // 输出4
System.out.println(String.format("%.0f", 7.0/3)); // 输出2
- 使用Math.round方法
System.out.println(Math.round(7.0/2)); // 输出4
System.out.println(Math.round(7.0/3)); // 输出2
- 使用BigDecimal类
import java.math.BigDecimal;
import java.math.RoundingMode;
BigDecimal bd1 = new BigDecimal(7.0/2);
BigDecimal bigDecimal1 = bd1.setScale(0, RoundingMode.HALF_UP); // 保留0位小数，使用常规的四舍五入
System.out.println(bigDecimal1); // 输出4
BigDecimal bd2 = new BigDecimal(7.0/3);
BigDecimal bigDecimal2 = bd2.setScale(0, RoundingMode.HALF_UP);
System.out.println(bigDecimal2); // 输出2
这三种方法都可以实现四舍五入，但要注意它们的用法和适用场景：
String.format: 主要用于格式化字符串，对于简单的四舍五入需求可以使用，但是注意其返回的是一个格式化后的字符串而不是数值。
Math.round: 是Java提供的标准方法，直接返回最接近的长整型值，适合对数值进行简单的四舍五入操作。
BigDecimal: 用于精确的十进制运算和舍入，适合处理对精度要求较高的场景，比如金融计算等。
Arrays类
- Arrays.fill()
Arrays.fill() 方法用于给数组赋值。
示例一：
int[] arr = new int[5];
Arrays.fill(arr, 4);
System.out.println(Arrays.toString(arr)); // [4, 4, 4, 4, 4]
示例二：
int[] arr = new int[5];
Arrays.fill(arr, 2, 4, 6);
System.out.println(Arrays.toString(arr)); // [0, 0, 6, 6, 0]
- Arrays.sort()
Arrays.sort() 方法用于对数组进行排序。
示例一：数字排序
int[] intArray = {4, 1, 3, -23};
Arrays.sort(intArray);
System.out.println(Arrays.toString(intArray));
// [-23, 1, 3, 4]
示例二：字符串排序
String[] strArray = {"z", "a", "C"};
Arrays.sort(strArray);
System.out.println(Arrays.toString(strArray)); // [C, a, z]
示例三：忽略大小写排序
String[] strArray = {"z", "a", "C"};
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strArray)); // [a, C, z]
示例四：反向排序String[] strArray = {“z”, “a”, “C”};
Arrays.sort(strArray, Collections.reverseOrder());
System.out.println(Arrays.toString(strArray)); // [z, a, C]
- Arrays.toString()
Arrays.toString() 方法用于将数组中的内容转换为字符串形式输出。
示例：
int[] arr = {3, 2, 1, 5, 4};
String str = Arrays.toString(arr);
System.out.println(str); // [3, 2, 1, 5, 4]
- Arrays.equals()
Arrays.equals() 方法用于比较两个数组是否相等。
示例：
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(Arrays.equals(arr1, arr2)); // true
- Arrays.binarySearch()
Arrays.binarySearch() 方法用于在排序好的数组中进行二分查找。
示例一：
int[] arr = {10, 20, 30, 40, 50};
System.out.println(Arrays.binarySearch(arr, 30)); // 2
示例二：
int[] arr = {10, 20, 30, 40, 50};
System.out.println(Arrays.binarySearch(arr, 36)); // -4
示例三：指定范围进行查找
int[] arr = {10, 20, 30, 40, 50};
System.out.println(Arrays.binarySearch(arr, 0, 3, 30)); // 2
- Arrays.copyOf() 和 Arrays.copyOfRange()
Arrays.copyOf() 方法用于复制数组的一部分到一个新数组中。
Arrays.copyOfRange() 方法用于复制数组的指定范围到一个新数组中。
示例一：
int[] arr = {10, 20, 30, 40, 50};
int[] arr1 = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(arr1)); // [10, 20, 30]
示例二：
int[] arr = {10, 20, 30, 40, 50};
int[] arr1 = Arrays.copyOfRange(arr, 1, 3);
System.out.println(Arrays.toString(arr1)); // [20, 30]
- 数组容量扩充：Arrays.copyOf()
如果数组容量不够，可以使用 Arrays.copyOf() 进行扩容。
示例：
int[] a = {10, 20, 30, 40, 50};
a = Arrays.copyOf(a, a.length + 1);
System.out.println(Arrays.toString(a)); // [10, 20, 30, 40, 50, 0]
- 数组中的常见异常
ArrayIndexOutOfBoundsException：数组下标越界
int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i <= arr.length; ++i) {
System.out.println(arr[i]);
}
System.out.println(arr[-2]); // 数组下标越界
NullPointerException：空指针异常
int[] arr = {1, 2, 3};
arr = null;
System.out.println(arr[0]); // 空指针异常
进制转换
十进制转其他进制
Integer.toString(k, r)：将十进制数 k 转换为 r 进制的数，返回一个字符串。
int k = 17;
System.out.println(Integer.toBinaryString(k)); // 转二进制
System.out.println(Integer.toOctalString(k)); // 转八进制
System.out.println(Integer.toHexString(k)); // 转十六进制
int r = 2;
System.out.println(Integer.toString(k, r)); // 转 r 进制
r = 8;
System.out.println(Integer.toString(k, r)); // 转 r 进制
r = 16;
System.out.println(Integer.toString(k, r)); // 转 r 进制
其他进制转换为十进制
Integer.parseInt(str, r)：将 r 进制的数字字符串 str 转换为十进制，并返回十进制的数。
System.out.println(Integer.parseInt("10001", 2)); // 输出：17
System.out.println(Integer.parseInt("21", 8)); // 输出：17
System.out.println(Integer.parseInt("11", 16)); // 输出：17
保留小数位数
使用 String.format()
String.format("%.2f", a)：将 a 保留两位小数。
double a = 123.456789;
double b = 123.444444;
String sa = String.format("%.2f", a);
System.out.println(sa); // 输出：123.46
String sb = String.format("%.2f", b);
System.out.println(sb); // 输出：123.44
使用 DecimalFormat 的 format() 方法
DecimalFormat 可以根据指定的格式化模式格式化数字。
double a = 123.456789;
double b = 123.444444;
DecimalFormat dfa = new DecimalFormat("0.00");
System.out.println(dfa.format(a)); // 输出：123.46
DecimalFormat dfb = new DecimalFormat("0.00");
System.out.println(dfb.format(b)); // 输出：123.44
可以通过 # 和 0 指定数字长度。
double a = 123.00;
DecimalFormat dfa = new DecimalFormat("#.##");
System.out.println(dfa.format(a)); // 输出：123
DecimalFormat dfb = new DecimalFormat("0.00");
System.out.println(dfb.format(a)); // 输出：123.00
使用String.format
System.out.println(String.format("%04d", 2)); // 输出0002
System.out.println(String.format("%04d", 12)); // 输出0012
在上面的代码中，"%04d"是格式化字符串的格式说明：
%：表示格式化开始
0：表示使用0来填充空白位置
4：表示总的输出宽度为4个字符
d：表示格式化为十进制整数
因此，"%04d"表示输出一个整数，总宽度为4个字符，不足的位置用0来填充。import
ArrayList
java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 获取元素
String fruit = list.get(2); // Orange
// 删除元素
list.remove(1); // 删除索引为 1 的元素 "Banana"
// 替换元素
list.set(0, "Grapes"); // 将索引为 0 的元素替换为 "Grapes"
// 判断元素是否存在
boolean containsOrange = list.contains("Orange"); // true
// 获取列表大小
int size = list.size(); // 2
// 清空列表
list.clear();
// 遍历列表
for (String item : list) {
System.out.println(item);
}
}
}
HashSet
import java.util.HashSet;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
// 添加元素
set.add("Apple");
set.add("Banana");
set.add("Orange");
// 删除元素
boolean removed = set.remove("Apple"); // true，删除成功
set.remove("Grapes"); // false，集合中不存在 "Grapes"
// 判断元素是否存在
boolean containsOrange = set.contains("Orange");
// true，集合中包含 "Orange"
// 获取集合大小
int size = set.size(); // 2，删除了一个元素后剩余两个元素
// 遍历集合
System.out.println("Using for-each loop:");
for (String fruit : set) {
System.out.println(fruit);
}
System.out.println("Using Iterator:");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
// 清空集合
set.clear(); // 清空集合
boolean empty = set.isEmpty(); // true，集合已经为空
System.out.println("Is the set empty? " + empty);
}
}
Math类（数学、计算相关）
abs(Object o): 返回值为 Object 的绝对值
min(Object a, Object b): 返回两个 Object 的较小值
max(Object a, Object b): 返回两个 Object 的较大值
ceil(double a): 向上取整
floor(double a): 向下取整
pow(double a, double b): 指数计算
sqrt(double a): 平方根
toDegrees(double angrad): 弧度转换为度
toRadians(double angdeg): 度转换为弧度
三角函数：tan, tanh, sin, sinh, cos, cosh, acos, asin, atan
rint(double a): 返回最接近参数的整数
round(double a), round(float a): 四舍五入
floorDiv(Object x, Object y): 返回商的最大 Object 值
floorMod(Object x, Object y): 取模
hypot(double x, double y): 返回两个数的平方和的平方根
Arrays类（数组处理）
sort(Object[] a), sort(Object[] a, int fromIndex, int toIndex): 数组排序
binarySearch(Object[] a, Object key), binarySearch(Object[] a, int fromIndex, int toIndex, Object key): 二分查找
copyOf(Object[] original, int newLength), copyOfRange(Object[] original, int from, int to): 复制数组
equals(Object[] a, Object[] a2): 比较数组是否相等
fill(Object[] a, Object val), fill(Object[] a, int fromIndex, int toIndex, Object val):
填充数组
parallelPrefix(Object[] array, IntBinaryOperator op), parallelPrefix(Object[] array, int fromIndex, int toIndex, IntBinaryOperator op): 并行计算前缀
parallelSort(Object[] a), parallelSort(Object[] a, int fromIndex, int toIndex): 并行排序
toString(Object[] a): 数组转换为字符串表示形式
String类
length(): 返回字符串长度
isEmpty(): 判断是否为空
isBlank(): 判断是否只包含空白字符
charAt(int index): 返回指定索引处的字符
compareTo(String str): 按字典顺序比较字符串
concat(String str): 连接字符串
contains(CharSequence s): 判断是否包含指定的字符序列
equals(Object anObject): 比较字符串是否相等
startsWith(String prefix), startsWith(String prefix, int toffset):
判断是否以指定前缀开头
endsWith(String suffix): 判断是否以指定后缀结尾
replace(char oldChar, char newChar): 替换字符
replaceFirst(String regex, String replacement): 替换第一个匹配到的
split(String regex), split(String regex, int limit): 分割字符串
subSequence(int beginIndex, int endIndex), substring(int beginIndex), substring(int beginIndex, int endIndex): 提取子字符串
toLowerCase(), toUpperCase(), trim(): 大小写转换和去除空白
valueOf(Object obj), valueOf(char[] data, int offset, int count): 转换为字符串
codePointAt(int index): 返回指定索引处的字符（Unicode 码点）
matches(String regex): 判断是否匹配给定的正则表达式
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin): 将指定范围的字符复制到目标字符数组的指定位置
一维前缀和
final int m = (int) 1e5 + 5;
int[] sum = new int[m];
int[] a = new int[m];
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int l, r; // 待求区间[l,r]
l = Scin.nextInt();
r = Scin.nextInt();
System.out.println(sum[r] - sum[l - 1]); // 查询
二维前缀和
final int m = (int) 1e2 + 5;
int[][] s = new int[m][m];
int[][] a = new int[m][m];
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
a[i][j] = i + j;
s[i][j] = s[i - 1][j] + s[i][j - 1] + a[i][j] - s[i - 1][j - 1];
}
}
System.out.println("(2,2)到(4,3)的矩阵和为：");
int x1, x2, y1, y2;
x1 = 2;
y1 = 2;
x2 = 4;
y2 = 3;
System.out.println(s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
一维差分
public static final int m = (int) 1e2 + 5;
public static int[] b = new int[m];
public static int[] a = new int[m];
public static void main(String[] args) throws Exception {
for (int i = 1; i <= 10; i++) {
a[i] = i;
}
for (int i = 1; i <= 10; i++) {
insert(i, i, a[i]);
}
System.out.println("a数组为：");
for (int i = 0; i < 10; i++) {
System.out.print(a[i + 1] + " ");
}
System.out.println();
System.out.println("b数组为：");
for (int i = 1; i <= 10; i++) {
System.out.print(b[i] + " ");
}
System.out.println();
}
public static void insert(int l, int r, int c) {
b[l] += c;
b[r + 1] -= c;
}
二维差分
public static void insert(int x1, int y1, int x2, int y2, int c) {
// 对b数组执行插入操作，等价于对a数组中的(x1,y1)到(x2,y2)之间的元素都加上了c
b[x1][y1] += c;
b[x2 + 1][y1] -= c;
b[x1][y2 + 1] -= c;
b[x2 + 1][y2 + 1] += c;
}