Arrays
toString(数组)
public static String toString 将(任意类型的)数组元素拼接为带有格式的字符串
举例
int[] arr1 = {1,4,5,6,7};
System.out.println(Arrays.toString(arr1)); //[1, 4, 5, 6, 7]
equals(数组a, 数组b)
public static boolean equals(类型[ ] a, 类型[ ] b)比较俩个数组是否相同,
如果两个数组引用都为 null,则认为它们是相等的
如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的
细节:俩个数组类型要相同
举例
int[] arr1 = {1,4,5,6,7};
int[] arr2 = {1,4,5,6,8};
System.out.println(Arrays.equals(arr1,arr2));//false
int[] arr1 = {1,4,5,6,7};
int[] arr2 = {1,4,5,6,7};
System.out.println(Arrays.equals(arr1,arr2));//true
binarySearch(数组,查找的元素)
使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。必须在进行此调用之前对数组进行排序(通过 sort(int[]) 方法)。
如果没有对数组进行排序,则结果是不确定的。
如果数组包含多个带有指定值的元素,则无法保证找到的是哪一个。
参数 : a - 要搜索的数组 key - 要搜索的值
返回: 如果它包含在数组中,则返回搜索键的索引;
否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点:即第一个大于此键的元素索引,如果数组中的所有元素都小于指定的键,则为 a.length。
注意,这保证了当且仅当此键被找到时,返回的值将 >= 0。
注: 前提,数组是有序的
举例
数组是有序:
int[] arr1 = {1,4,5,6,7};
int[] arr2 = {1,4,5,6,8};
System.out.println(Arrays.binarySearch(arr1,7)); //4
System.out.println(Arrays.binarySearch(arr1,3)); //-2 (-(插入点-1)-1)-->插入点为1-->在1和4之间
数组是无序: int[] arr1 = {1,3,2,6,5};
System.out.println(Arrays.binarySearch(arr1,5)); //-4 错误索引
idea原码:
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
sort(类型[] a)
public static void sort(Object[] a)—>对数组进行默认升序排序(快速排序)
举例
int[] arr1 = {1,3,2,6,5};
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]
sort(数组,Comparator<? super T> c(规则))
public static void sort(T[] a,Comparator<? super T> c)
利用插入排序+二分查找的方式进行排序的
参数1–>要排序的数组, 参数2–>排序规则 //Comparator<? super T> c: 比较器
细节: 只能给引用数组类型的数组进行排序
如果数组是基本数据类型的,需要变成其对应的包装类
eg.int–>Integer
o1–>表示在无序序列中,遍历得到的每一个元素
o2–>有序序列中的元素
如果 o1 大于 o2 ,比较器返回1。这意味着在排序后的数组中,o1 应该位于 o2 之后。
如果 o1 小于 o2 ,比较器返回-1。这意味着在排序后的数组中, o1 应该位于 o2 之前
如果 o1 等于 o2, 比较器返0。 这意味着 o1 和 o2 的顺序并不重要,它们可以以任何顺序出现
分析(o1-o2):
返回值为正数 : 表示当前要插入的元素是大的,放在后面
返回值为负数 : 表示当前要插入的元素是小的,放在前面
返回值为0 : 表示当前要插入的元素跟现在的元素比是一样的,也会也会放在后面
举例
降序:
Integer[] arr1 = {1,3,2,6,5};
Arrays.sort(arr1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(Arrays.toString(arr1));//[6, 5, 3, 2, 1]
升序:
Integer[] arr1 = {1,3,2,6,5};
Arrays.sort(arr1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]
lambda表达式的升序:
Integer[] arr1 = {1, 3, 2, 6, 5};
Arrays.sort(arr1, (Integer o1, Integer o2) -> {
return o1 - o2;
}
);
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]
copyOf(原数组,新数组的长度)
public static boolean[] copyOf(原数组,新数组的长度)—>拷贝数组
返回一个新的数组
细节:方法的底层会根据第二个参数来创建数组
如果新数组的长度是小于老数组的长度,会部分拷贝
如果新数组的长度是等于老数组的长度,会完全拷贝
如果新数组的长度是大于老数组的长度,会补上默认初始值
举例
int[] arr1 = {1,3,2,6,5};
int[] a = Arrays.copyOf(arr1, 3);
int[] b = Arrays.copyOf(arr1, 5);
int[] c = Arrays.copyOf(arr1, 10);
System.out.println(Arrays.toString(a));//[1, 3, 2]
System.out.println(Arrays.toString(b));//[1, 3, 2, 6, 5]
System.out.println(Arrays.toString(c));//[1, 3, 2, 6, 5, 0, 0, 0, 0, 0]
copyOfRange(原数组,起始索引,结束索引)
public static T[] copyOfRange(原数组,起始索引,结束索引)–>拷贝数组(指定范围)
细节:包头不包尾,包左不包右–>具体看举例
举例
int[] arr1 = {1,3,2,6,5};
int[] a = Arrays.copyOfRange(arr1, 0, 3);
System.out.println(Arrays.toString(a)); //[1, 3, 2] ---> (范围为[0,2]|| [0,3))
fill(数组,元素)
public static void fill(数组,元素) -->填充数组 会覆盖先前的元素
举例:
int[] arr1 = {1,3,2,6,5};
Arrays.fill(arr1,4);
System.out.println(Arrays.toString(arr1));//[4, 4, 4, 4, 4]
引用数据类型使用sort方法
public class GirlFriend {
private String name;
private int age;
private double height;
public GirlFriend() {
}
public GirlFriend(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return height
*/
public double getHeight() {
return height;
}
/**
* 设置
* @param height
*/
public void setHeight(double height) {
this.height = height;
}
public String toString() {
return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";
}
}
import java.util.Arrays;
public class SortText1 {
public static void main(String[] args) {
GirlFriend gf1 = new GirlFriend("小a", 18, 1.68);
GirlFriend gf2 = new GirlFriend("小b", 19, 1.72);
GirlFriend gf3 = new GirlFriend("小c", 19, 1.65);
GirlFriend[] arr = {gf1, gf2, gf3};
Arrays.sort(arr, (GirlFriend o1, GirlFriend o2) -> {
double temp = o1.getAge() - o2.getAge();
temp = temp == 0 ? o1.getHeight() - o2.getHeight() : temp;
temp = temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;
if (temp > 0) {
return 1;
} else if (temp < 0) {
return -1;
} else {
return 0;
}
});
System.out.println(Arrays.toString(arr));
}
}
1.年龄: GirFriend 对象按年龄升序排序
2.身高:如果两个 GirlFriend 对象的年龄相同,那么按身高排序。
3.名字: 如果两个 GirlFriend 对象的年龄和身高都相同,那么按名字的字母顺序排序(ASCII)