二十六、Java语言之二维数组

/*
一、二维数组：
    1.二维数组是一个特殊的以为数组
    2.特殊的一维数组，特殊在这个一维数组中每个元素都是一个一维数组

 */
二、初始化二维数组：

//静态初始化二维数组：

public class Test01 {

    public static void main(String[] args){

        //静态初始化二维数组
        int[][] a={
                {1,2,3},
                {22,33,44},
                {1},
                {100,99},
        };
        //以上这个数组有多少个一维数组
        System.out.println(a.length);

        //获取第一个一维数组
        System.out.println(a[0][0]);
        //获取最后一个数组的最后一个元素
        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();
        }
    }
}

//动态初始化二维数组：

public class Test02 {

    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;
        //遍历
        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();
        }
    }
}

另一种方式：

public class Test03 {

    public static void main(String[] args) {

        m1(new int[][]{{1,2,3},{22,33,44,9},{100,99,0}});
    }
    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();
        }
    }
}

例子：
模拟栈的方式实现：
Stack

import org.omg.CORBA.OBJ_ADAPTER;

public class Stack {
    //使用数组存储数据
    //栈可以存储多个引用类型元素
    Object[] elements;

    //指向栈顶元素上方的一个帧
    int index;

    //栈默认初始化容量是5
    //Constructor
    Stack(){
        this(5);
    }
    Stack(int max){
        elements=new Object[max];
    }

    //提供一个对外的压栈方法
    public void push(Object element) throws StackException{
        /*elements[index] =element;
        index++;*/
        if(index==elements.length){
            throw new StackException("栈已满！");
        }
        elements[index++]=element;

    }
    //提供一个对外的弹栈方法
    public Object pop() throws StackException{
        /*--index;
        return elements[index];*/
        if(index==0){
            throw new StackException("栈已空！");
        }
        return elements[--index];
    }

}

自定义异常

public class StackException extends Exception{

    public StackException(){}
    public StackException(String msg){
        super(msg);
    }
}

测试程序

public class StackTest {
    public static void main(String[] args){

        Stack s=new Stack();

        //压栈
        User u1=new User("Jack",10);
        User u2=new User("TOM",11);
        User u3=new User("Nacy",12);
        User u4=new User("Lucy",13);
        User u5=new User("Mark",14);
        //处理异常
        try{
            s.push(u1);
            s.push(u2);
            s.push(u3);
            s.push(u4);
            s.push(u5);
            s.push(u5);
        }catch(StackException e){
            System.out.println(e.getMessage());}

        //弹栈
        try{
            System.out.println(s.pop());
            System.out.println(s.pop());
            System.out.println(s.pop());
            System.out.println(s.pop());
            System.out.println(s.pop());
            System.out.println(s.pop());
            System.out.println(s.pop());
        }catch (StackException e){
            System.out.println(e.getMessage());
        }

    }

}
class User{
    String name;
    int age;
    User(String name,int age){
        this.name=name;
        this.age=age;
    }

    //重写toString方法
    public String toString(){
        return "User[name="+name+",age="+age+"]";
    }
}

测试结果：

栈已满！
User[name=Mark,age=14]
User[name=Lucy,age=13]
User[name=Nacy,age=12]
User[name=TOM,age=11]
User[name=Jack,age=10]
栈已空！