Arrays

Arrays:用来操作数组的一个工具类

Arrays类提供的常见方法:

|----------------------------------------------------------------------|------------------|
| 方法名 | 说明 |
| public static String toString(类型[ ] arr) | 返回数组的内容 |
| public static int[] copyOfRange(类型[ ] arr,起始索引,结束索引) | 拷贝数组(指定范围) |
| public static copyOf(类型[ ]arr,int newLethon) | 拷贝数组 |
| public static setAll(double [ ]arr,intToDoubleFuncation generator) | 把数组中的原数据改为新数据 |
| public static void sort (类型[ ]arr) | 对数组进行排序(默认是升序排序) |

复制代码
import java.util.Arrays;
import java.util.function.IntToDoubleFunction;

public class Test1 {
    public static void main(String[] args) {
        int []arr1={11,22,33};
        //public static String toString(类型[ ] arr):	返回数组的内容
        System.out.println(Arrays.toString(arr1));
        //public static int[] copyOfRange(类型[ ] arr,起始索引,结束索引):	拷贝数组(指定范围)包前不包后
        int [] arr3=Arrays.copyOfRange(arr1,0,1);
        System.out.println(Arrays.toString(arr3));
        //public static copyOf(类型[ ]arr,int newLethon):	拷贝数组
        int [] arr4=Arrays.copyOf(arr1,3);
        System.out.println(Arrays.toString(arr4));
        //public static setAll(double [ ]arr,intToDoubleFuncation generator):把数组中的原数据改为新数据
        double[]arr2={99.8,66.8,33.9};
        Arrays.setAll(arr2, new IntToDoubleFunction() {
                    @Override
                    public double applyAsDouble(int value) {
                        return arr2[value]*0.68;
                    }
                }
        );
        System.out.println(Arrays.toString(arr2));
        //public static void sort (类型[ ]arr):	对数组进行排序(默认是升序排序)
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
    }
}

如果数组中存储的是对象,该怎么排序?

|-----|-----------------------------------------------------------------------------------------------------------------------------------|
| 方式一 | 让该对象的类实现Comparable(比较规则)接口,然后重写CompareTo方法,自己来制定比较规则 |
| 方式二 | 使用下面这个sort方法,创建Comparator比较器接口的匿名内部类对象,然后自己制定规则 public static <T>void sort (T[ ]arr,Comparator<?super T >c)对数组进行排序(支持自定义规则) |

复制代码
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;
    }
//这个方法是用来给sort方法内部进行比较的
    //制定比较规则
    //this(比较者) o(被比较者)谁调这个方法谁就是比较者
    @Override
    public int compareTo(Student o) {
        //约定1:如果左边对象  大于  右边对象  返回正整数
        //约定2:如果左边对象  小于  右边对象  返回负整数
        //约定2:如果左边对象  等于  右边对象  返回0
        //按照年龄排序
        //更简便的一种方法
        //return this.age-o.age;//升序
        //return o.age-this.age;//降序
        if (this.age>o.age) {
            return 1;
        }else if (this.age<o.age){
            return -1;
        }
        return 0;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
}

import java.util.Arrays;
import java.util.Comparator;

public class Test2 {
    public static void main(String[] args) {
        //目标:掌握如何对数组中的对象进行排序
       Student []Students=new Student[4];
       Students[0]=new Student("楚北捷",1.88,28);
       Students[1]=new Student("周翊然",1.83,24);
       Students[2]=new Student("于和伟",1.86,48);
       Students[3]=new Student("肖战",1.87,31);
       //public static void sort (类型【】arr):对数组进行排序
        Arrays.sort(Students);
        System.out.println(Arrays.toString(Students));
        //方式二	使用下面这个sort方法,创建Comparator比较器接口的匿名内部类对象,然后自己制定规则public static <T>void sort (T[ ]arr,Comparator<?super T >c)对数组进行排序(支持自定义规则)
        Arrays.sort(Students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                /*
                制定比较规则:     左边对象o1;右边对象o2
                //约定1:如果左边对象  大于  右边对象  返回正整数
                //约定2:如果左边对象  小于  右边对象  返回负整数
                //约定2:如果左边对象  等于  右边对象  返回0
                if (o1.getHeight()> o2.getHeight()) {
                    return 1;
                }else if (o1.getHeight()< o2.getHeight()){
                        return -1;
                }
                return 0;//升序

                 */
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });
    }
}
相关推荐
薰衣草233315 分钟前
hot100练习-11
算法·leetcode
地平线开发者40 分钟前
征程 6 | 工具链如何支持 Matmul/Conv 双 int16 输入量化?
人工智能·算法·自动驾驶
甄心爱学习44 分钟前
数值计算-线性方程组的迭代解法
算法
stolentime1 小时前
SCP2025T2:P14254 分割(divide) 题解
算法·图论·组合计数·洛谷scp2025
Q741_1471 小时前
C++ 面试基础考点 模拟题 力扣 38. 外观数列 题解 每日一题
c++·算法·leetcode·面试·模拟
W_chuanqi1 小时前
RDEx:一种效果驱动的混合单目标优化器,自适应选择与融合多种算子与策略
人工智能·算法·机器学习·性能优化
L_09072 小时前
【Algorithm】二分查找算法
c++·算法·leetcode
靠近彗星2 小时前
3.3栈与队列的应用
数据结构·算法
Han.miracle6 小时前
数据结构——二叉树的从前序与中序遍历序列构造二叉树
java·数据结构·学习·算法·leetcode
mit6.8248 小时前
前后缀分解
算法