526互联

JavaSE--数组以及Arrays工具类

发布时间 2023-08-15 11:24:10作者: 洛小依ovo

一、数组

1、数组概述

  数组是一种引用数据类型，数组的父类是Object

  数组因为是引用类型，所以在堆内存中存放

2、数组的分类：

  一维数组、二维数组、三维数组、多维数组...（一维数组较常用）

3、数组的长度

  a）数组一旦创建，java中规定，长度不可变

  b）获取数组长度：所有数组对象都有length属性，用来获取数组中的元素的个数

  c）数组中每个元素都是有下标的，下标都从0开始，以1递增。最有一个元素的下标是 length - 1

4、数组中存放的数据

  a）数组实际上是一个容器，可以同时容纳多个元素

  b）数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”数据。数组当中如果存储的是java对象的话，实际上存储的是对象的引用

  c）Java中的数组要求数组中元素的类型统一。例如：int类型数组只能存放int类型，Student类型数组只能存储Student对象

5、数组的内存地址

  a）数组在内存方面存储的时候，数组中的元素的内存地址是连续的，（存储的每一个元素都有规则的挨着排列）

  b）数组中首元素（第一个元素）的内存地址作为整个数组的内存地址

6、数组这种数据结构的优点：

  查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。

  • 每一个元素的内存地址在空间存储上是连续的。
  • 每一个元素类型相同，所以占用空间大小一样。
  • 知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的

7、数组这种数据结构的缺点：

  • 由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
  • 数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存空间。

 

二、一维数组

1、一维数组语法格式

int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;

2、一维数组的初始化

// 两种方式：静态初始化、动态初始化
// 静态初始化
int[] array = {100,200,500};
// 动态初始化
// 初始化一个5个长度的int类型数组，每个元素默认值0
int[] array = new int[5]; // 这里的5表示数组的元素个数。   
// 初始化6个长度的String类型数组，每个元素默认值null
String[] names = new String[6];

3、访问一维数组中的元素以及遍历

public class ArrayTest01 {
    public static void main(String[] args) {
        // 声明一个int类型的数组，使用静态初始化的方式
        int[] a = {1, 100, 10, 20, 55, 689};

        // 所有的数组对象都有length属性
        System.out.println("数组中元素的个数" + a.length);

        // 数组中每一个元素都有下标
        // 通过下标对数组中的元素进行存和取。
        // 取（读）
        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);
        System.out.println("最后一个元素 = " + a[a.length - 1]);

        // 存（改）
        // 把第一个元素修改为111
        a[0] = 111;
        // 把最后一个元素修改为0
        a[a.length - 1] = 0;

        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);

        // 一维数组遍历
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]); // i是从0到5，是下标
        }

        // 下标越界了  异常
        //System.out.println(a[6]); //ArrayIndexOutOfBoundsException

        // 从最后一个元素遍历到第1个元素
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.println("逆序输出-->" + a[i]);
        }
    }
}

4、动态初始化方式创建数组

public class ArrayTest02 {
    public static void main(String[] args) {
        // 声明/定义一个数组，采用动态初始化的方式创建
        int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
        // 遍历数组
        for (int i = 0; i < a.length; i++) {
            System.out.println(i + "的元素："+ a[i]);
        }
        // 后期赋值
        a[0] = 1;
        a[1] = 100;
        a[2] = 111;
        a[3] = 222; // 注意下标别越界
        for (int i = 0; i < a.length; i++) {
            System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
        }

        // 初始化一个Object类型的数组，采用动态初始化方式
        Object[] objs = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
        for (int i = 0; i < objs.length; i++) {
            System.out.println(objs[i]);
        }

    }
}

 5、静态初始化与动态初始化什么时候使用

  •     当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式
  •     当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间

6、方法参数中直接传递一个静态数组

public class ArrayTest05{
    public static void main(String[] args) {
        // 静态初始化一维数组
        int[] a = {1,2,3};
        printArray(a);
        
        // 传递一个静态初始化一维数组，语法必须这样
        printArray(new int[]{1,2,3});

    }
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

 7、main方法中“String[] args”

  JVM调用main方法的时候，会自动传一个String数组过来，例如dos命令中这样运行程序：java ArrayTest05 abc def xyz，那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中，所以main方法上面的String[] args数组主要是用来接收用户输入参数的

  idea中在run选项卡中，可以编辑参数

// "abc".equal不容易出现空指针异常，哪怕name和pass为空
// name.equal("abc")如果name为null，则会出现空指针异常，不太好
if("abc".equal(name) && "123".equal(pass)){
    
}

 8、数组中存放引用数据类型

public class ArrayTest07 {
    public static void main(String[] args) {
        Animal[] animals = {new Animal(), new Animal()};

        for (int i = 0; i < animals.length; i++) {
            animals[i].move();
        }

        // 创建子类
        Animal[] anis = {new Cat(), new Bird()};
        for (int i = 0; i < anis.length; i++){
            // 调用子对象特有方法，需要向下转型
            if(anis[i] instanceof Cat){
                Cat cat = (Cat)anis[i];
                cat.catchMouse();
            }else if(anis[i] instanceof Bird){
                Bird bird = (Bird)anis[i];
                bird.sing();
            }
        }
    }
}

class Animal{
    public void move(){
        System.out.println("Animal move...");
    }
}

// Cat是子类
class Cat extends Animal {
    public void move(){
        System.out.println("猫在走猫步！");
    }
    // 特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

// Bird子类
class Bird extends Animal {
    public void move(){
        System.out.println("Bird Fly!!!");
    }
    // 特有的方法
    public void sing(){
        System.out.println("鸟儿在歌唱！！！");
    }
}

 9、一维数组的扩容

  先新建一个大容量数组，然后将小容量的数组中的元素拷贝到大容量中，使用System.arraycopy(5个参数);

  注意：数组扩容效率较低，所以尽可能不要使用，使用数组提前预估数组长度

public class ArrayTest08 {
    public static void main(String[] args) {
        // java中数组拷贝的方法arraycopy
        //System.arraycopy(5个参数);

        // 拷贝源（从这个数组中拷贝）
        int[] src = {1, 11, 22, 3, 4};

        // 拷贝目标（拷贝到这个目标数组上）
        int[] dest = new int[20]; // 动态初始化一个长度为20的数组，每一个元素默认值0

        // 调用JDK System类中的arraycopy方法，来完成数组的拷贝
        //System.arraycopy(src, 1, dest, 3, 2);
        // 拷贝全部元素
        System.arraycopy(src, 0, dest, 0, src.length);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        // 拷贝引用数据被雷
        Object[] objs = {new Object(), new Object(), new Object()};
        Object[] newObjs = new Object[5];
        // 这里拷贝的时候是拷贝对象的地址
        System.arraycopy(objs, 0, newObjs, 0, objs.length);
        for (int i = 0; i < newObjs.length; i++) {
            System.out.println(newObjs[i]);
        }
    }
}

 

三、二维数组

1、关于二维数组

  二维数组其实就是一个特殊的一维数组，特殊在在这个一维数组当中的每一个元素都是一个一维数组

2、二维数组静态初始化

public class ArrayTest10{
    public static void main(String[] args){
        int[][] a = {
            {1,3},
            {20,30,10},
            {0}
        };
        System.out.println(a.length);// 3
        System.out.println(a[0].length);// 2
        System.out.println(a[1].length);// 3
        System.out.println(a[2].length);// 1
    }
}

3、二维数组元素的读和改

public class ArrayTest10 {
    public static void main(String[] args) {
        // 二维数组
        int[][] a = {
                {34,4,65},
                {100,200,39,111},
                {0}
        };
        // 读
        System.out.println(a[0][0]);
        System.out.println(a[1][2]);
        System.out.println(a[2][0]);

        // 改
        a[2][0] = 11111;
        System.out.println(a[2][0]);

    }
}

 4、二维数组的遍历

public class ArrayTest11 {
    public static void main(String[] args) {
        // 二维数组
        String[][] array = {
                {"mysql", "java", "c++", "python", "c#"},
                {"张三", "李四", "王五"},
                {"lucy", "jack", "rose"}
        };

        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            System.out.println();// 换行
        }
    }
}

5、二维数组动态初始化

public class ArrayTest12 {
    public static void main(String[] args) {
        // 动态初始化
        int[][] array = new int[3][4];

        // 静态初始化
        int[][] a = {{1,2,3,4},{4,5,6,76},{1,23,4}};
        printArray(a);
        // 传递一个静态初始化的二维数组
        printArray(new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}});
    }

    public static void printArray(int[][] array){
        // 遍历二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

三、数组工具类

  SUN公司提供的数组工具类java.util.Arrays。其中方法都是静态的，直接用类名调用就行

1、给数组排序

int[] arr = {52,74,12,0,3,96};
Arrays.sort(arr);
for(int i = 0;i< arr.length,i++){
    System.out.println(arr[i]);
}

2、二分法查找

int[] arr = {5,8,12,15,23,55};
int index = Arrays.binarySearch(arr,15);
System.out.println(index == -1 ? "该元素不存在" : "该元素的下标是" + index);