java学习初探八之数组一维数组、二维数组

一、一维数组
1.数组
（1）数组是一种引用类型。
（2）数组是一种简单的数据结构，线性的结构。
（3）数组是一个容器，可以用来存储其他元素。
数组是可以存储任意数据类型的元素。
（4）数组分为：一维数组、二维数组、三维数组、多维数组。
（5）数组中存储的元素类型是统一的。
（6）数组长度不可改变，数组一旦创建，长度是不可改变的，固定的。
数组优点：查找效率高。因为数组中的存储元素的类型是统一的，每个元素在内存中所占的空间大小是相同的，知道数组的首元素的内存地址，要查找的元素只要知道下标就可以快速的计算出偏移量，通过首元素内存地址加上偏移量快速计算出要查找元素的内存地址，通过内存地址快速定位该元素，所以数组查找元素的效率高。
缺点：随机的增删元素效率比较低。因为当增加元素的时候，为了保证数组中元素在空间存储上是有序的，所以被添加元素位置后面的所有元素都要向后移动。删除元素也是，后面所有的元素向前移动，所以数组的增删效率很低。
2.一维数组数组静态初始化

public class ArrayTest01 {
    public static void main(String[] args) {
        // 声明一个一维数组，用来存储int类型
        int[] a1={100,200,150,300 };//静态初始化一维数组
        //boolean类型数组
        boolean[] a2={true,false,false};
        //string类型数组
        String[] str={"AB","CD","EF"};
        //object数组
        Object[] obj={'a','b','c'};
        Object o1=new Object();
        Object o2=new Object();
        Object o3=new Object();
        Object[] objs={o1,o2,o3};
    }
}

下图是数组内存分析

一维数组初始化:静态和动态

public class ArrayTest02 {
    public static void main(String[] args) {
        // 静态初始化一个int类型的一维数组
        int [] a1={10,20,30};
        //以下方式声明也可以
        //int a1[]={10,20,30};
        System.out.println("第一个元素："+a1[0]);
        System.out.println("最后一个元素："+a1[a1.length-1]);
        System.out.println("数组中元素的个数："+a1.length);  
        //遍历一维数组
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
        }
        //将第二个元素修改为100
        a1[1]=100;
        System.out.println("重新赋值后的元素："+a1[1]);
        //动态声明一个int类型的数组，最多可以存储4个元素
        int [] b=new int[4];

    }
}

2.动态初始化一维数组详解

/*
 * 1.动态初始化一维数组，会现在堆内存中分配这个数组，并且数组中每个元素都采用默认值。
 *  byte,short,int,long 0
 *  float double 0.0
 *  boolean false
 *  char \0000
 *  引用 null
 * 2.无论动态初始化还是静态初始化，最终在内存的分别都是一样的。
 * 3.如果在创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化
 *  如果在创建数组的时候，无法预测数组中存储什么数据，只是先开辟空间，这个时候采用动态初始化
 * 
 */
public class ArrayTest04 {
    public static void main(String[] args) {
        //动态声明一个int类型的数组，最多可以存储4个元素
        int [] a1=new int[4];
        //遍历
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
        }
        //赋值
        a1[0]=21;
        a1[1]=22;
        a1[2]=23;
        a1[3]=24;
        //遍历
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
            }   
        //引用类型的数组
        Object[] objs=new Object[3];
        objs[0]=1;
        for(int index=0;index<objs.length;index++){
            Object o=objs[index];
            System.out.println(o);  
        }
        }   
}

3.深入一维数组

import javax.management.InstanceAlreadyExistsException;

/*
 * 深入一维数组
 */
public class ArrayTest05 {

    public static void main(String[] args) {
        //创建一个数组，也可以存储dog，也可以存储cat
        Animal[] animals=new Animal[4];
        //给数组每个元素赋值
        Dog dog1=new Dog();
        Dog dog2=new Dog();
        Cat cat1=new Cat();
        Cat cat2=new Cat();

        animals[0]=dog1;
        animals[1]=dog2;
        animals[2]=cat1;
        animals[3]=cat2;

        //需求：遍历数组，取出每个对象，如果是cat执行move。如果是dog，执行eat
        for(int i=0;i<animals.length;i++){
            System.out.println(animals[i]);
            //强制类型转换，向下转型
            if(animals[i] instanceof Cat){
                Cat cat=(Cat)animals[i];
                cat.move();
            }
            if(animals[i] instanceof Dog){
                Dog dog=(Dog)animals[i];
                dog.eat();
            }   
        }   
    }

}
class Animal{

}
class Dog extends Animal{
    public void eat(){
        System.out.println("Dog eat");
    }
}
class Cat extends Animal{
    public void move() {
        System.out.println("Cat move");
    }
}

4.main 方法的 String[] args
（1）方法传递数组方式

/*
 * 方法调用的时候，也可以这样传递一个数组
 */
public class ArrayTest06 {
public static void main(String[] args) {
    //第一种方式
    int[] a={1,2,3,4,5,6};
    m1(a);
    //第二种方式
    m1(new int[]{111,2,3,4,5,6});
}
public static void m1(int[] a){
    for(int i=0;i<a.length;i++){
        System.out.println(a[i]);
    }
}
}

（2）String[] args
String[] args是专门用来接收命令行参数的
例如 java ArrayTest07 abc def aaa
JVM在调用ArrayTest07类的main方法前，先将“abc def aaa”以空格的方式分割，然后存储在string数组中。
main方法中String[] args的设计主要是用来接收命令行参数的

/*
 * 方法调用的时候，也可以这样传递一个数组
 */
public class ArrayTest06 {
public static void main(String[] args) {
    System.out.println("String类型数组中元素的个数是："+args.length);//0
    for(int i=0;i<args.length;i++){
        System.out.println(args[i]);
    }
    //需求，运行该软件的时候必须提供用户名和密码
    //格式：java ArrayTest07 username password
    if(args.length!=2){
        System.out.println("若使用该系统，必须这样输入：格式：java ArrayTest07 username password");
        return;
    }
    //参数提供正确，如果用户名是admin,密码是123
    if("admin".equals(args[0])&&"123".equals(args[1])){//这种方式可以避免空指针异常
        System.out.println("登录成功");
    }
    else{
        System.out.println("登录失败");
    }
}
}

5.数组的拷贝和扩容

package com.array;
import javax.crypto.spec.DESedeKeySpec;
public class ArrayStudy01 {
    public static void main(String[] args) {
        //参数分别为源数组，源数组开始下标,目标数组，目标数组下标，长度
        //System.arraycopy(src, srcPos, dest, destPos, length);
        int [] src= {2,3,4,5,6,7,8};
        int [] dest= {10,11,12,13,14,15,16};
        //拷贝
        System.arraycopy(src, 2, dest, 3, 3);
        //遍历
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);//输出结果：10 11 12 4 5 6 16
        }
    }
}

二、二维数组
（1）二维数组是一个特殊的一维数组
（2）特殊的一维数组，特殊在这个一维数组中每一个元素都是“一维数组”
二维数组静态初始化：

package com.array;

public class ArrayStudy02 {
public static void main(String[] args) {
    //静态初始化二维数组
    int[][]a = {
            {1,2,3},
            {45,34},
            {0},
            {10,23,85,99}
            };
    //以上这个数组有多少个一维数组
    System.out.println(a.length+"个一维数组");
    //获取第一个一维数组
    int[] a0=a[0];
    int a00=a0[0];
    System.out.println(a00);//1
    //获取第一个一维数组中的第一个元素
    System.out.println(a[0][0]);//1
    //获取最后一个一维数组中最后一个元素
    System.out.println(a[a.length-1][a[a.length-1].length-1]);
    //遍历二维数组
    for(int i=0;i<a.length;i++) {//纵向循环在外 行
        for(int j=0;j<a[i].length;j++) {//列
            System.out.print(a[i][j]+" ");
        }
        System.out.println();
    }
}
}
输出结果：
1 2 3 
45 34 
0 
10 23 85 99 

二维数组动态初始化：

package com.array;

public class ArrayStudy03 {

    public static void main(String[] args) {
        //3个一维数组
        //每个一维数组中有4个元素
        //动态初始化二维数组
        int [][] a=new int[3][4];
        //遍历
        for(int i=0;i<a.length;i++) {
            for(int j=0;j<a[i].length;j++) {
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
        //赋值
        a[1][2]=100;

    }

}

package com.array;

public class ArrayStudy04 {

    public static void main(String[] args) {
        m1(new int[][] {{1,2,3},{4,5},{6,7,8,9}});

    }
    public static void m1(int[][]a) {
        for(int i=0;i<a.length;i++) {
            for(int j=0;j<a[i].length;j++) {
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }   
    }
}
//输出结果
1 2 3 
4 5 
6 7 8 9