【java】数组

一维数组：

/**
 * 1、java中数组是一种引用数据类型，数组创建之后长度不可变。
 * 2、数组中的元素类型需要统一，如int型数组只能存储int类型。
 * 3、一维数组语法格式：
 *      数据类型[] 数据名；
 *      如：int[] array1;
 *          double[] array2;
 * 4、一维数据初始化方式：
 *      静态初始化：
 *          int[] array = {1,2,3,4};
 *      动态初始化:
 *          int[] array = new int[5];  //这里的5表示数组的元素个数，每个元素默认值为0
 *
 *
 */
public class Test {
    public static void main(String[] args) {
        //静态初始化
        int [] a = {1,33,44,22,55};
        //所有的数组对象都有length属性
        System.out.println("数组中的元素个数："+a.length);//输出5

        //取（读）
        System.out.println("第一个元素："+a[0]);//输出1
        System.out.println("最后一个元素："+a[a.length-1]);//输出55

        //存（改）
        a[0] = 111;
        a[a.length-1] = 123;

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

    }

}

 

/**
 *  数据类型        默认值
 *  byte            0
 *  short           0
 *  int             0
 *  long            0L
 *  float           0.0F
 *  double          0.0
 *  boolean         false
 *  char            \u0000
 *  引用数据类型      null
 */
public class Test02 {
    public static void main(String[] args) {
        //动态初始化
        int[] a = new int[4];
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        for (int i = 0; i < a.length; i++) {
                System.out.println(a[i]);//输出1 2 3 4
        }

        //静态数据传参
        array1(new int[]{2,3,4,5});

        //动态数组传参
        array1(new int[4]);
    }
//方法参数为数组
    public static void array1(int[] a1){
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }
    }
}

继承中的数组：

public class Test03 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        Animal[] ani = {dog,cat};
        for (int i = 0; i < ani.length; i++) {
            //调用子类特有方法，需要向下转型
            if(ani[i] instanceof Dog){
                Dog dogs = (Dog)ani[i];
                dogs.dogrun();
            }else if(ani[i] instanceof Cat){
                Cat cats = (Cat)ani[i];
                cats.catchmouse();
            }

        }

    }
}

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

class Dog extends Animal{
    public void move(){
        System.out.println("移动！");
    }
    public void dogrun(){
        System.out.println("狗跑");
    }
}
class Cat extends Animal{
    public void move(){
        System.out.println("移动！");
    }
    public void catchmouse(){
        System.out.println("猫抓老鼠！");
    }

        }

一维数组拷贝：

/**
 * 一维数据拷贝：
 *      语法：System.arraycopu(拷贝源，拷贝源起始位置，拷贝目标，拷贝至目标起始位置，要拷贝的拷贝源长度)；//五个参数
 */
public class Copy {
    public static void main(String[] args) {
        int[] a = {12,32,42}; //拷贝源
        int[] a1 = new int[10];//拷贝目标
        System.arraycopy(a,0,a1,1,2);//a为拷贝源，0为拷贝源起始位置(即从12开始拷)
                                     //a1为拷贝目标，1为拷贝至目标起始位置(即从a1的1位置开始存放)
                                     //2为拷贝源要拷贝的长度（从1开始计数，这里拷贝12，32）
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }

        String[] str = {"hello","woc","haha"};
        String[] newstr = new String[6];
        System.arraycopy(str,0,newstr,0,str.length);
        for (int i = 0; i < newstr.length; i++) {
            System.out.println(newstr[i]);
        }
    }
}

二维数组：

/**
 * 关于java中的二维数组：
 *  1、二维数组是一个特殊的一维数组，二维数组中每一个元素是一个一维数组。
 *  2、静态初始化：
 *      int[][] array = {{1,2,3},{11,22},{4,3}};
 *
 */
public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化
        int[][] arr = {
                {1,2,3},
                {11,22},
                {4,3}
        };
        //获取长度
        System.out.println(arr.length);//输出3，显示二维数组arr中一维数组个数
        System.out.println(arr[2].length);//输出2，显示二维数组中第三个一维数组中的元素个数，这里{4,3}元素个数为2
        //取
        System.out.println(arr[0][2]);//输出3，取出二维数组中第一个一维数组，并取出一维数组中第3个元素。
        //改
        arr[0][2] = 11111;

        //遍历
        for (int i = 0; i < arr.length; i++) {
            //内层遍历一维数组
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println(); //换行

        }
    }
}

方法中参数为二维数组：

public class ArrayTest01 {
    public static void main(String[] args) {
        //二维数组动态初始化
        //3行4列，3个一维数组，每个一维数组中有4个元素
        //int[][] arry1 = new int[3][4];

        printArray(new int[][]{{12,32},{22,3}}); //传参
    }


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

        }
    }
}