1.Arrays
用来操作数组的一个工具类。
public class test {
public static void main(String[] args) {
// 示例数组
int[] arr = {5, 3, 8, 1, 2};
double[] doubleArr = {5.5, 3.3, 8.8, 1.1, 2.2};
// 使用toString方法
System.out.println("数组内容: " + Arrays.toString(arr));
// 使用copyOfRange方法,包前不包后
int[] newArr = Arrays.copyOfRange(arr, 1, 4);
System.out.println("拷贝指定范围的数组: " + Arrays.toString(newArr));
// 使用copyOf方法,如果新数组比原数组短,就只复制原数组的部分元素
int[] copiedArr = Arrays.copyOf(arr, 7); // 新数组长度为7
System.out.println("数组拷贝到新长度: " + Arrays.toString(copiedArr));
// 使用setAll方法,可以对数组中的每个元素进行操作,这里将每个元素乘以2
Arrays.setAll(doubleArr, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
return doubleArr[value] * 2 ; // 这里将每个元素乘以2
}
});
System.out.println("数组内容被更改: " + Arrays.toString(doubleArr));
// 使用sort方法
Arrays.sort(arr);
System.out.println("排序后的数组: " + Arrays.toString(arr));
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
(2)如果数组中存储的是对象,应该怎么排次序?
方法一:
test
public class test {
public static void main(String[] args) {
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("紫霞", 163.8, 26);
students[3] = new Student("至尊宝", 167.5, 24);
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
Student 要实现Comparable接口,并重写compareTo方法
package com.lzk.test;
public class Student implements Comparable<Student> {
private String name;
private double height;
private int age;
public Student() {
}
public Student(String name, double height, int age) {
this.name = name;
this.height = height;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Student o) {
// @约定1:认为左边对象 大于 右边对象 请您返回正整数
// @约定2:认为左边对象 小于 右边对象 请您返回负整数
// @约定3:认为左边对象 等于 右边对象 请您一定返回0
// 按照年龄升序排序。
if (this.age > o.age) {
return 1;
} else if (this.age < o.age) {
return -1;
}
return 0;
// 或者可以简写为一行代码:
// return this.age - o.age;
//降序就反过来
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
方法二
学生类,不用再实现接口重写代码
//这里不能做方法一的减法,因为返回是int,提供的是double,强转之后198.1-198.0=0.1=0,也会出错。
public class test {
public static void main(String[] args) {
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("紫霞", 163.8, 26);
students[3] = new Student("至尊宝", 167.5, 24);
// Arrays.sort(students);
// System.out.println(Arrays.toString(students));
//方法二,先写一个数组,再调用一个接口对象
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
if (o1.getHeight() > o2.getHeight()) {
} else if (o1.getHeight() < o2.getHeight()) {
return -1;
}
return 0;
// return Double.compare(o1.getHeight(), o2.getHeight());升序
// return Double.compare(o2.getHeight(), o1.getHeight());降序
}
});
}
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
默认升序规则是:左边对象大于右边对象返回正整数。