数组的一些简单例子

十七ing

已于 2022-06-15 09:56:06 修改

阅读量1.4k

点赞数 1

分类专栏： Java SE 文章标签： java intellij-idea

于 2022-04-22 18:26:15 首次发布

本文链接：https://blog.csdn.net/lfm1010123/article/details/124309290

版权

Java SE 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

数组入门

一、 Java数组的定义方式

程序清单1：

public class Test1 {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = new int[]{1, 2, 3};
        int[] array3 = new int[3];
    }
}

二、打印数组的每个元素

程序清单2：

public class Test2 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        
        //1. for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();

        //2. 增强for循环打印数字元素
        for (int x: array) {
            System.out.print(x + " ");
        }
        System.out.println();
        
        //3. 借助Java操作数组的工具类 Arrays.toString
        //将参数的数组以字符串的形式输出
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
}

程序清单3：

//模拟  System.out.println(Arrays.toString(array));
public class Test3 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println( myToString(array) );
    }
    public static String myToString(int[] array) {
        if (array == null){
            return "null";
        }
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret = ret + array[i];
            if( i != array.length-1 ){
                ret = ret + "," + " ";
            }
        }
        ret = ret + "]";
        return ret;
        }
}

三、数组、方法、引用

数组传参的时候，数组名表示一个引用，引用相当于指针
情况一：

程序清单4：

public class Test4 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        System.out.println(Arrays.toString(array));
        fuc2(array);
        System.out.println(Arrays.toString(array));
    }
    public static void fuc2(int[] array){
        array[0] = 100;
    }
}

分析：
形参拿到了数组的起始内存地址，并对数组第一个元素进行修改
分析一
情况二：

程序清单5：

public class Test5 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        System.out.println( Arrays.toString(array));
        fuc1(array);
        System.out.println( Arrays.toString(array));
    }
    public static void fuc1(int[] array){
        array = new int[] {4,5,6,7,8,9,10};
    }
}

输出结果：

分析：形参拿到了不同的地址，并不影响原来的数组
分析二

程序清单6：

public class Test6 {
    public static void main(String[] args) {
    
        //一个引用不能同时指向多个对象
        int[] array1 = {1, 2, 3};
        int[] array2 = new int[]{1, 2, 3};
        int[] array3 = new int[3];

        int[] array4 = {1,2,3,4,5};
        int[] array5 = array4;
        //这里表示array5这个引用指向了array4这个引用所指向的对象
        //注意：引用只能指向对象

        int[] array6 = null;
        //这个引用不指向任何对象

        //引用一定在栈上吗？不一定
        //如果你定义了一个局部变量，那么一定在栈上
        //如果你定义了实例成员变量，那就不一定在栈上了
    }
}

四、数组作为返回值

程序清单7：

//数组作为返回值
//破坏了原数组
public class Test7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void transform(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }
}

程序清单8：

//数组作为返回值
// 返回一个新的数组
public class Test8 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] ret = transform(arr);
        System.out.println( Arrays.toString(ret) );
    }
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
        return ret;
    }
}

五、数组拷贝

1. Arrays.copyOf( ) 方法

Java 中 Arrays.copyOf( ) 方法的源代码，我们可以看到返回的是一个新的数组。

总结 Arrays.copyOf( ) 方法的格式：

其中 original 代表需要拷贝的数组，newLength 代表新数组的长度

Arrays.copyOf(original, newLength);

程序清单9：

public class Test9 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        int[] copy = Arrays.copyOf(arr, 5);
        System.out.println(Arrays.toString(copy));
        int[] copy2 = Arrays.copyOf(arr,10);
        System.out.println(Arrays.toString(copy2));
    }
}

输出结果：
out

当然，Arrays.copyOf( ) 方法也可以返回给自己原先的数组，但是底层依旧是 new 了一个新的数组。这个操作可以用于顺序表的扩容问题，请看下面代码：

import java.util.Arrays;

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,7,9};
        arr = Arrays.copyOf(arr, arr.length*2);
        System.out.println(Arrays.toString(arr));
    }
}

输出结果：

out

2. Arrays.copyOfRange( ) 方法

Java 中 Arrays.copyOf( ) 方法的源代码，我们可以看到返回的是一个新的数组。

其中 original 代表需要拷贝的数组，from 代表 original 需要拷贝的起始下标，to 代表 original 需要拷贝的终止下标。此外，from 和 to 遵循左闭右开。

Arrays.copyOf(original, from, to);

程序清单10：

public class Test10 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        int[] copy = Arrays.copyOfRange(arr, 1,3);
        System.out.println(Arrays.toString(copy));
        int[] copy2 = Arrays.copyOfRange(arr,1,10);
        System.out.println(Arrays.toString(copy2));
    }
}

输出结果：
out
在上面程序中，我们可以看到此方法有自动扩容现象。

3. arraycopy( ) 方法

在刚刚上面的 Arrays.copyOf( ) 方法和 Arrays.copyOfRange( ) 方法中，我们看到它们的底层调用的都是 arraycopy( ) 方法，下面我们来看一下arraycopy( ) 方法。

这是 Java 中 arraycopy( ) 方法的源代码，我们只能看到传参的是些什么数据，因为它其实是 C / C++ 代码实现的。

arraycopy(src, pos, dest, destpos, length);

src 代表需要拷贝的源头数组
pos 代表 src 数组需要拷贝的起始下标
dest 代表需要拷贝至的目的数组
destpos 代表被拷贝的 dest 数组的起始下标
length 代表需要拷贝的长度

我们可以把 arraycopy( ) 方法想象成一个模板，它既可以拷贝 String 类型的数据，又可以拷贝 int 类型的数据等等，等小伙伴理解到泛型的知识就明白了，现在先理解其可以是一个模板。

程序清单11：

public class Test11 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        int [] copy = new int[5];
        System.arraycopy(arr,0,copy,1,4);
        System.out.println(Arrays.toString(copy));
        System.out.println("--------------------------");
        
        System.out.println(Arrays.toString(arr));
        System.arraycopy(arr,0,arr,1,4);
        System.out.println(Arrays.toString(arr));
        arr[0] = 100;
        System.out.println(Arrays.toString(arr));
    }
}