一维数组与二维数组

一、定义

1、int []array=new int[]{1,2,3,4};//静态初始化，开辟了新的内存
2、int []array1={1,2,3,4};//静态初始化，编译器会根据{}里面的元素确定数组里面元素个数
3、int []array3=new int[10];//动态初始化，需要指定元素个数，只分配了内存，但是没有赋值，里面默认存储默认值

• 数组是一组相同类型元素的集合。
• 数组里面每个元素类型一致。
• 元素在数组里面是连续存储的，数组的空间是连在一起的，每个空间有自己的编号，起始位置的编号为0，即数组的下标。
• 数组的下标范围是0—数组的长度-1，数组长度：array.数组名
• Java里面当分配内存但是没有初始化时，默认都为0 /0.0 ,boolean类型默认为false;如果数组中存储元素类型为引用类型，默认值为null.

二、数组的使用 

1、访问数组里面的内容

int []array=new int[]{1,2,3,4};
System.out.println(array[1]);  //通过下标进行访问数组里面的内容

2、修改数组里面的内容

int []array=new int[]{1,2,3,4};
System.out.println(array[1]);
array[1]=8;      //通过下标找到数组里面的元素，并修改其内容
System.out.println(array[1]);

3、遍历数组

 1、for循环

int []array=new int[]{1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < array.length; i++) {  //可以拿到数组下标
    System.out.print(array[i]+" ");
}

2、for each     //不能拿到数组下标，只能拿到数据元素

for (数组里面每一个变量的类型定义的变量           

：数组名）{

System.out.print(x+" ");

}

例如：

for (int x:
    array ) {
    System.out.print(x+" ");
}

3、Java中有一个工具，专门可以操作数组 ----Arrays

System.out.println(Arrays.toString(array));

三、数组是引用数据类型

（1）

public static void main(String[] args) {
        int a=10;
        int b=30;
        int []array1={1,2,3,4};
    }

分析如下：

 

Array这个引用指向一个对象，局部变量都在栈里面存储，里面放的值都是对象的地址 

（2）

public static void main(String[] args) {
        int []array1={1,2,3,4};
        int []array2={4,5,6,7};
        array1=array2;
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }

 分析：

1.  1个引用不能同时指向多个对象
2. 引用对象赋值：  int [] array =null;代表这个引用不指向任何一个对象，不可对它进行读和写操作

 （3）形参与实参的关系

形参的指向发生改变不会影响实参

public static void fuc1(int arr[]){
        arr=new int[10];  //修改了指向
    }
    public static void fuc2(int arr[]){
        arr[1]=99;        //修改了指向内容
    }
    public static void main(String[] args) {
        int []array1={1,2,3,4};
       
    }

练习：交换a与b的内容

public static void swap(int[]array){
        int tmp=array[0];
        array[0]=array[1];
        array[1]=tmp;
   }
    public static void main(String[] args) {
        int []arr={1,2};
        System.out.println("交换前："+arr[0]+" "+arr[1]);
        swap(arr);
        System.out.println("交换前："+arr[0]+" "+arr[1]);
    }

 注意：

数组是对象，在堆上，引用变量在函数里面是局部变量，函数结束，局部变量里面的值就会被回收

 四、数组的应用

 1、数组转字符串

数组是一种引用数据类型

String ret=Arrays.to String(数组名）；

 int []array=new int[]{1,2,3,4,5,6,7,8,9,10};
​​​​System.out.println(Arrays.toString(array));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 2、数组拷贝

  int []array1={1,2,3,4};
  int []array2=array1;    //不算拷贝，没有开辟一个新的空间

 法1：for循环

 public static void main(String[] args) {
        int[]array={1,2,3,4};
        int[]array1=new int[array.length];  //是最重要的，要先开辟空间，然后再存放数据
        for (int i = 0; i < array.length; i++) {
            array1[i]=array[i];
        }
        System.out.println(Arrays.toString(array1));
    }

法2：整体拷贝 (copyof   、clone）

 public static void main(String[] args) {
        int[]array={1,2,3,4};
        int[]array1=Arrays.copyOf(array,array.length);  //拷贝谁，拷贝多长
        System.out.println(Arrays.toString(array1));
    }

public static void main(String[] args) {
        int[]array={1,2,3,4};
        int[]array1=array.clone();
        System.out.println(Arrays.toString(array1));
    }

3、局部拷贝

public static void main8(String[] args) {
        int[]array={1,2,3,4};
        int[]array1=Arrays.copyOfRange(array,1,3);  //局部拷贝，拷贝的数组，拷贝的起始位置，拷贝的结束位置
        System.out.println(Arrays.toString(array1));    //[2,3]   Java里面用的都是左闭右开
    }

 4、数组扩容成2倍

public static void main(String[] args) {
        int[]array={1,2,3,4};
       int[]array1=Arrays.copyOf(array,2*array.length);  //括容2倍
        System.out.println(Arrays.toString(array1));
    }

练习：

1、给定一个整型数组, 求平均值

 public static double average(int[]array){
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return (double) sum/(double) array.length;
    }
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(average(array));
    }

2、 给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

public static int find(int[]array,int k) {
         for (int i = 0; i < array.length; i++) {
             if (array[i] == k) {
                 return i;
             }
         }
         return -1;
     }
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        int k=3;
        System.out.println(find(array,k));
    }

五、二维数组

1、定义 （二维数组可以省略列）

1、int[][]array1=new int[2][3];
2、int[][]array2=new int[][]{{1,2,3},{4,5,6}};
3、int[][]array3={{1,2,3},{4,5,6}};

2、打印二维数组 

法1：for循环，可以得到下标

for (int i = 0; i < array.length; i++) {  //打印行,行数是一维数组长度
for (int j = 0; j <array[i].length ; j++) {  //打印列,列数一维数组中一个元素的长度

public static void main(String[] args) {
        int[][]array3={{1,2,3},{4,5,6}};
        for (int i = 0; i < 2; i++) {  //打印行
            for (int j = 0; j <3 ; j++) {  //打印列
                System.out.print(array3[i][j]+" ");
            }
            System.out.println();
        }
    }

法2：for each 

 public static void main(String[] args) {
        int[][]array3={{1,2,3},{4,5,6}};
        for (int[]arr:array3) {  //第一次分解，一维数组类型：二维数组数组名
            for (int x:arr) {    //一维数组里面的变量类型：一维数组名
                System.out.println(x+" ");
            }
        }
    }

法3：Arrays.deepToString(数组名)

public static void main(String[] args) {
        int[][]array3={{1,2,3},{4,5,6}};
        System.out.println(Arrays.deepToString(array3));
    }

3、如果未对列进行初始化 ，只能省略写列，会默认为null，因为二维数组是特殊的一维数组，每一行是一个一维数组

public static void main(String[] args) {
    int[][]array1=new int[2][];
    System.out.println(array1[0]);    //null
    System.out.println(array1[1]);    //null
}