java-Arrays - 技术栈

一、Arrays的概述

Arrays是操作数组的工具类

二、Arrays的常用方法

Arrays的常用方法基本上都被static静态修饰，因此在使用这些方法时，可以直接通过类名调用

1.toString

语法： Arrays.toString(数组)

用于将数组的元素转换为一个字符串，元素之间用逗号分隔，所有元素用[]包括。

注意：Arrays 类的 toString 方法来拼接或获取任何类型数组的字符串表示，包括基本数据类型数组和对象数组。对于对象数组，如果对象本身重写了 toString 方法，那么这些方法的实现将被用于生成字符串表示。

该方法可以用来展示数组的元素（因为如果直接输出数组名则输出的是数组的地址）

java 复制代码

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {
        // 1.Arrays.toString(数组) 将数组变成字符串
        int [] arr1=new int[]{1,2,3};
        String s1=Arrays.toString(arr1);
        System.out.println(s1);// [1, 2, 3]

        char [] arr2=new char[]{'a','b','c'};
        String s2=Arrays.toString(arr2);
        System.out.println(s2);// [a, b, c]

        String [] arr3=new String[]{"aaa","bbb","ccc"};
        String s3=Arrays.toString(arr3);
        System.out.println(s3);// [aaa, bbb, ccc]
        
        // Student类重写了toString方法 它的输出是"Student{name = " + name + ", age = " + age + "}"
        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr4=new Student[]{student1,student2,student3};
        String s4=Arrays.toString(arr4);
        System.out.println(s4);// [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}]

    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

2.binarySearch

语法： Arrays.binarySearch(数组，元素)；

返回查找元素的索引前提是传入的数组必须是升序的

注意：

如果该元素存在则返回他在数组中的索引值

如果该元素不存在则返回 -插入值-1

插入值是根据从小到大的顺序该元素如果在数组中存在它的索引值

java 复制代码

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.binarySearch(数组,元素) 返回元素在数组中的索引
        int [] arr1=new int[]{1,2,3,4,5,6,7,8,9,10};
        int index1=Arrays.binarySearch(arr1,4);
        int index2=Arrays.binarySearch(arr1,10);
        int index3=Arrays.binarySearch(arr1,-1);
        System.out.println(index1);// 3  元素值为4在数组中的索引为3
        System.out.println(index2);// 9  元素值为10在数组中的索引为9
        System.out.println(index3);// -11 元素值在数组中不存在的索引为-插入值-1
        // 元素-1如果在数组(已经按照升序排列)存在 那么它的位置应该在0索引处 这就是它的插入值 再减一 得到它的索引
    }
}

3.copyOf

语法： Arrays.copyOf(老数组，新数组的长度)；

如果新数组的长度小于老数组的长度则会部分拷贝（从左往右拷贝）

如果新数组的长度等于老数组的长度则会完全拷贝

如果新数组的长度大于老数组的长度不仅会完全拷贝而且多余的部分通过该数组元素数据类型的默认值来填充

组合数据类型的默认值为null

java 复制代码

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOf(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        int [] arr1=Arrays.copyOf(arr,2);
        int [] arr2=Arrays.copyOf(arr,4);
        int [] arr3=Arrays.copyOf(arr,8);
        // 如果直接输出数组名 则结果是数组的地址
        // 如果想要输出数组的元素 则可以通过Arrays.toString()
        System.out.println(arr1);// [I@4eec7777
        System.out.println(arr2);// [I@3b07d329
        System.out.println(arr3);// [I@41629346
        System.out.println(Arrays.toString(arr1));// [7, 8]
        System.out.println(Arrays.toString(arr2));// [7, 8, 9, 10]
        System.out.println(Arrays.toString(arr3));// [7, 8, 9, 10, 0, 0, 0, 0]

        String [] arr_1=new String[]{"AAA","BBB","CCC"};
        String [] arr4=Arrays.copyOf(arr_1,2);
        String [] arr5=Arrays.copyOf(arr_1,3);
        String [] arr6=Arrays.copyOf(arr_1,5);

        System.out.println(Arrays.toString(arr4));// [AAA, BBB]
        System.out.println(Arrays.toString(arr5));// [AAA, BBB, CCC]
        System.out.println(Arrays.toString(arr6));// [AAA, BBB, CCC, null, null]

        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr7=new Student[]{student1,student2,student3};
        Student [] arr8=Arrays.copyOf(arr7,4);
        System.out.println(Arrays.toString(arr8));
        // [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}, null]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

4.copyOfRange

语法： Arrays.copyOfRange(开始索引，结束索引)；

从开始索引拷贝到结束索引，包括开始索引，但是不包括结束索引

java 复制代码

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOfRange(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        // 从索引0拷贝到索引3 不包括索引3
        int [] arr1=Arrays.copyOfRange(arr,0,3);
        System.out.println(Arrays.toString(arr1));// [7, 8, 9]

        String [] arr_1=new String[]{"AAA","BBB","CCC","DDD"};
        // 从索引1拷贝到索引3 不包括索引3
        String [] arr2=Arrays.copyOfRange(arr_1,1,3);
        System.out.println(Arrays.toString(arr2));// [BBB, CCC]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr_1_1=new Student[]{student1,student2,student3};
        // 从索引0拷贝到索引1 不包括索引1
        Student [] arr3=Arrays.copyOfRange(arr_1_1,0,1);
        System.out.println(Arrays.toString(arr3));
        // [Student{name = zhangsan, age = 20}]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

5.fill

语法： Arrays.fill(数组，新数据)；

用新数据填充数组的每一个元素，注意：是直接在原数组中进行覆盖

java 复制代码

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.fill(数组,新数据)
        int [] arr=new int[]{7,8,9,10};
        Arrays.fill(arr,100);
        System.out.println(Arrays.toString(arr));// [100, 100, 100, 100]

        String [] arr1=new String[]{"AAA","BBB","CCC","DDD"};
        Arrays.fill(arr1,"ppp");
        System.out.println(Arrays.toString(arr1));// [ppp, ppp, ppp, ppp]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr2=new Student[]{student1,student2,student3};
        Arrays.fill(arr2,student3);
        System.out.println(Arrays.toString(arr2));
        // [Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

6.sort

语法1： Arrays.sort(数组)；

对数组进行排序默认是升序排序注意：是直接在原数组中进行排序

**补充：**字符串之间的比较是基于它们每个字符的Unicode值进行的。

java 复制代码

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组)
        int [] arr=new int[]{100,20,89,1,-10,65};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]

        String [] arr1=new String[]{"i","like","pen","and"};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));// [and, i, like, pen]
        
    }
}

语法2： Arrays.sort(数组，排序规则)；

Arrays.sort(数组, (o1,o2)->o2-o1);

是降序排序其中o1,o2可以换成任何变量名

总结：如果是(o1,o2)->o2-o1则是降序如果是(o1,o2)->o1-o2则是升序

根据排序规则对数组进行排序只能给引用数据类型排序如果要给基本数据类型排序则需要将基本数据类型转化为对应的包装类

java 复制代码

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

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组,排序规则)
        Integer [] arr=new Integer[]{100,20,89,1,-10,65};
        /*
           这个降序是通过Comparator接口实现的 方法的参数是接口
           当我们要调用方法时 需要传入该接口的实现类
           Comparator接口的compare方法:
           该方法是用来排序的 需要传入两个参数 Integer o1 Integer o2
           规定数组的0索引为有序序列 0索引以后为无序序列
           o1表示从无序序列中遍历得到的每一个元素
           o2表示从有序序列的元素
           返回值为正 表示当前插入的元素小于有序序列的元素 放在后面
           返回值为负 表示当前插入的元素大于有序序列的元素 放在前面
        */
        // 未通过lamdba表达式简化
        Arrays.sort(arr,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1,Integer o2){
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));// [100, 89, 65, 20, 1, -10]
        
        // 通过lamdba表达式简化
        Arrays.sort(arr, (o1,o2)->o2-o1);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]
    }
}