数组

数组

描述

数组是 相同类型数据 的 有序 集合

 

特点：

1.  一旦创建，长度不变

2.  所有数据必须类型相同

 

创建数组的方式

1. int[] a = new int[ 5];

2. int [] a = new int[5]; //多一个空格

3. int a[] = new int[5]; //[] 放在变量后面

4. int[] a = new int[5]{1,2,3,4,5}; //创建对象并初始化数组

这种要注意： 

package com.mark.java.array;

public class A {

    public static void main(String[] args) {
        //正确
        int a[] = new int[]{1,2,3};
        
        //错误,这是错误的，创建对象和赋值必须在一个语句中完成
        int b[] = new int[3];
        b = {1,2,3};
    }
    
}

5. int[] a = {1,2,3,4,5}; //直接初始化数组。

6. 变量a 是存再 栈中的，new int[5] 数据是存在堆中的。

初始化

数组在创建的时候就是对数组进行了初始化。

而在int= a;此时并没有进行初始化。在编译时会报错。

二维数组

二位数组可以看成是数据的数组。

比如说 int arr[] = new int[8]; 这个数组指的是在 堆中创建一个连续的空间8，每个空间里放的是一个个的int 类型数据。

二维数组  int arr2[] [] =  new int[8][]; 这个二维数组指的是在堆中创建一个空间为8的空间，每个空间里放的是一个一维的数组，在每个一维数组中放的是具体的int类型数据。

package com.mark.java.array;

public class TwoArray {
    public static void main(String[] args) {
        //创建
        int arr[][] = new int[3][];
        //数组中存储数组
        arr[0] = new int[5];
        arr[1] = new int[2];
        arr[2] = new int[3];

        //赋值
        arr[0][0] = 0;
        arr[0][1] = 1;
        arr[0][2] = 2;
        arr[0][3] = 3;
        arr[0][4] = 4;

        arr[1][0] = 5;
        arr[1][1] = 6;

        arr[2][0] = 7;
        arr[2][1] = 8;
        arr[2][2] = 9;

        for (int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

这种方法就比较清楚

1. 直观arr1是一个长度为3的数组

2. 这个数组里的每个值 都是一个数组。分别是{1，2} {4，5，6}  {7，8，9，0}

3. 所以二维数据可以看作是数组的 数组。

int[][] arr1 = new int[][]{{1,2},{4,5,6},{7,8,9,0}};

 

数组的复制 java.lang.System

 //数组的复制
        int[] a = new int[]{1,2,3,4,5};
        int[] b = new int[3];
        //从数组a的0位置开始，复制到b数组，从b数组的0位置开始，复制length长度。
        System.arraycopy(a,0,b,2,1);

        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+"\t");
        }

操作数组的类 arrays

asList  数组转list

toString ：soString

copyOf: 复制数组，本质还是System.arrayCopy

fill : 将指定值 放入数据的每个位置。相当于初始化数据

equals：比较

sort：排序

 

package com.mark.java.array;

import java.util.Arrays;
import java.util.List;

public class A {

    public static void main(String[] args) {
        //正确
        int a1[] = new int[]{1,2,3};

        //错误,这是错误的，创建对象和赋值必须在一个语句中完成
        int b1[] = new int[3];
//        b = {1,2,3};

        //数组的复制
        int[] a = new int[]{1,2,3,4,5};
        int[] b = new int[3];
        //从数组a的0位置开始，复制到b数组，从b数组的0位置开始，复制length长度。
        System.arraycopy(a,0,b,2,1);

        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+"\t");
        }
        System.out.println();
        //arrays
        int arr[] = new int[]{4,9,6,3,6,7};

        //toString
        String string = Arrays.toString(arr);
        System.out.println(string);

        //排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        //转list
        List<int[]> ints = Arrays.asList(arr);

        //复制数组,实质还是调用了System.arraycope方法
        int[] ints1 = Arrays.copyOf(arr, 2 * arr.length);
        System.out.println(Arrays.toString(ints1));

        //equals
        int m[] = new int[]{1,2,3};
        int n[] = new int[]{1,2,3};
        boolean equals = Arrays.equals(m, n);
        System.out.println(equals);

        //fill,将指定的int值（5），分配到数组c中的每个位置上
        int[] c = new int[5];
        Arrays.fill(c,5);
        System.out.println(Arrays.toString(c));

        
    }

}

程序的入口，main方法

import java.util.Arrays;

public class B {
    public static void main(String[] args) {
        String string = Arrays.toString(args);
        System.out.println(string);
    }
}

运行程序： java B 1 2 3

输出[1 2 3]

通过命令行来传递参数。

这里出现一个报错，在执行 java B 的命令时，

java 找不到或无法加载主类，我这里没注意的问题是 ： java类中不能有package，package com.mark.java.array;类似这中的。

• 这应该是有三种原因：

1、java文件中没有"main"方法；

2、java文件中使用了包名；

3、执行命名所在的路径不对；