数组的一些简单例子

• • 一、 Java数组的定义方式
  • 二、 打印数组的每个元素
  • 三、 数组、方法、引用
  • 四、 数组作为返回值

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

public class Test {
    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);
    }
}

//模拟  System.out.println(Arrays.toString(array));
public class Test {
    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;
        }
}

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

public class Test {
    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;
    }
}

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

情况二：

public class Test {
    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};
    }
}

输出结果：

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

public class Test {
    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;
        //这个引用不指向任何对象

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

//数组作为返回值
//破坏了原数组
public class Test1 {
    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;
        }
    }
}

//数组作为返回值
// 返回一个新的数组
public class Test1 {
    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;
    }
}