Arrays类
Arrays类
java.util.Arrays类包含一些实用的方法用于常见的数组操作，比如排序和查找
-
可以是用sort（快排）或者parallelSort方法对整个数组或者部分数组进行排序
Arrays.sort(Object[] array)
-
对数组元素进行排序 (串行排序)
String[] data = {"1", "4", "3", "2"}; System.out.println(Arrays.toString(data)); // [1, 4, 3, 2] Arrays.sort(data); System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]
Arrays.sort(T[] array, Comparator<? super T> comparator)
-
使用自定义比较器，对数组元素进行排序 (串行排序)
String[] data = {"1", "4", "3", "2"}; System.out.println(Arrays.toString(data)); // [1, 4, 3, 2] // 实现降序排序，返回-1放左边，1放右边，0保持不变 Arrays.sort(data, (str1, str2) -> { if (str1.compareTo(str2) > 0) { return -1; } else { return 1; } }); System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]
Arrays.sort(Object[] array, int fromIndex, int toIndex)
-
对指定范围内的数组元素进行排序 (串行排序)
String[] data = {"1", "4", "3", "2"}; System.out.println(Arrays.toString(data)); // [1, 4, 3, 2] // 对下标[0, 3)的元素进行排序，即对1，4，3进行排序，2保持不变 Arrays.sort(data, 0, 3); System.out.println(Arrays.toString(data)); // [1, 3, 4, 2]
Arrays.parallelSort(T[] array)
注意：其余重载方法与 Arrays.sort() 相同
-
对数组元素进行排序 (并行排序)，当数据规模较大时，会有更好的性能
String[] data = {"1", "4", "3", "2"}; Arrays.parallelSort(data); System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]
-
-
可以采用二分查找（binarySearch方法）在有序数组中查找关键字
Arrays.binarySearch(Object[] array, Object key)
注意：在调用该方法之前，必须先调用 Arrays.sort() 方法进行排序，如果数组没有排序，那么结果是不确定的，此外如果数组中包含多个指定元素，则无法保证将找到哪个元素
- 使用二分法查找数组内指定元素的索引值
- 这里需要先看下 binarySearch() 方法的源码，对了解该方法有很大的帮助
从源码中可以看到
- 当搜索元素是数组元素时，返回该元素的索引值
- 当搜索元素不是数组元素时，返回 - (索引值 + 1)
-
可以使用equals方法检测两个数组是否相等
Arrays.equals(Object[] array1, Object[] array2)
判断两个数组是否相等
- 数组元素为基本数据类型时，依次比较值
- 数组元素为引用数据类型时，依次调用元素的 equals() 方法进行比较
- 即如果两个数组被认为是相等的，则两个数组中应包含相同顺序的相同元素
Integer[] data1 = {1, 2, 3}; Integer[] data2 = {1, 2, 3}; System.out.println(Arrays.equals(data1, data2)); // true -
可以使用fill方法填充整个数组或者部分数组
Arrays.fill(Object[] array, Object obj)
- 用指定元素填充整个数组 (会替换掉数组中原来的元素)
Integer[] data = {1, 2, 3, 4}; Arrays.fill(data, 9); System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)
- 用指定元素填充数组，从起始位置到结束位置，取头不取尾 (会替换掉数组中原来的元素)
Integer[] data = {1, 2, 3, 4}; Arrays.fill(data, 0, 2, 9); System.out.println(Arrays.toString(data)); // [9, 9, 3, 4] -
可以使用toString 方法来返回一个字符串
Arrays.toString(Object[] array)
- 返回数组元素的字符串形式
Integer[] data = {1, 2, 3}; System.out.println(Arrays.toString(data)); // [1, 2, 3]
拓展
一，java.lang.Comparable 接口
Comparable 接口强制了实现类对象列表的排序。其排序称为自然顺序，其 compareTo 方法，称为自然比较法
public interface Comparable<T> {
public int compareTo(T o);
}
如果用this代表当前调用该compareTo方法的对象，obj是方法传入参数
则：
this < obj ---- 返回负数
this = obj ---- 返回 0
this > obj ---- 返回正数
如果一个数组中的对象实现了 Compareable 接口，则对这个数组进行排序非常简单： Arrays.sort(); 如果 List 实现了该接口的话 , 我们就可以调用Collections.sort 或者 Arrays 方法给他们排序。实际上 Java 平台库中的所有值类 (value classes) 都实现了 Compareable 接口。
二，java.util.Comparator 接口
Comparator可以认为是是一个外比较器,一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较
public interface Comparator<T> {
int compare(T o1, T o2);
//省略...........
}
比较逻辑
o1 < o2 ---- 返回负数
o1 = o2 ---- 返回 0
o1 > o2 ---- 返回正数
三，聊聊string中的compareTo方法
String中实现的是Comparable接口来为String对象作出比较逻辑
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence{
//........
}
先看一段示例
/**
* 字符串比较案例
*/
public class StringComparisonDemo {
public static void main(String[] args) {
String foo = "ABC";
// 前面和后面每个字符完全一样，返回 0
String bar01 = "ABC";
System.out.println(foo.compareTo(bar01));
// 前面每个字符完全一样，返回：后面就是字符串长度差
String bar02 = "ABCD";
String bar03 = "ABCDE";
System.out.println(foo.compareTo(bar02)); // -1 (前面相等,foo 长度小 1)
System.out.println(foo.compareTo(bar03)); // -2 (前面相等,foo 长度小 2)
// 前面每个字符不完全一样，返回：出现不一样的字符 ASCII 差
String bar04 = "ABD";
String bar05 = "aABCD";
System.out.println(foo.compareTo(bar04)); // -1 (foo 的 'C' 字符 ASCII 码值为 67，bar04 的 'D' 字符 ASCII 码值为 68。返回 67 - 68 = -1)
System.out.println(foo.compareTo(bar05)); // -32 (foo 的 'A' 字符 ASCII 码值为 65，bar04 的 'a' 字符 ASCII 码值为 97。返回 65 - 97 = -32)
String bysocket01 = "泥瓦匠";
String bysocket02 = "瓦匠";
System.out.println(bysocket01.compareTo(bysocket02));// -2049 （泥 和 瓦的 Unicode 差值）
}
}
结果：
0
-1
-2
-1
-32
-2049
再结合上边示例看看String中对compareTo方法的实现
public int compareTo(String anotherString) {
//len1：当前字符串长度
int len1 = value.length;
//len2：参数字符串长度
int len2 = anotherString.value.length;
//len1和len2两者最小值
int lim = Math.min(len1, len2);
//分别转为字符数组
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
//比较逻辑
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
//字符不同，则返回两字符的ASCII 码的差值
if (c1 != c2) {
return c1 - c2;
}
k++;
}
//相同则返回两字符长度差值
return len1 - len2;
}
所以从上面的源码中可以看到，string中的compareTo逻辑大概可以整理为
- 字符串前面部分的每个字符完全一样，返回：后面两个字符串长度差；
- 字符串前面部分的每个字符存在不一样，返回：出现不一样的字符 ASCII 码的差值。
- 字符串的每个字符完全一样，返回 0；
在String内部还有个静态内部类CaseInsensitiveComparator也实现了该接口
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable{
//.................
}
该重写的接口方法是String对象的大小写不敏感比较方法
public int compare(String s1, String s2) {
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
//转大写
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
//还不一样则转小写
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
//还不一样则：返回不一样字符的ASCII 码的差值。
if (c1 != c2) {
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
注：转载https://blog.csdn.net/weixin_41922289/article/details/90463971
https://blog.csdn.net/Goodbye_Youth/article/details/81003817
