java中数组总结

java中数组总结

package com.company.array;
/*
* 数组：
*   1、数组是一种引用类型
*
*   2、数组是一种简单的数据结构，线性的结构
*
*   3、数组是一个容器，可以用来存储其他元素
*   数组可以存储任意数据类型的元素
*
*   4、数组分为：一维数组，二维数组，三维数组，多维数组...
*
*   5、数组中存储的元素类型是统一的
*
*   6、数组长度不可改变，数组一旦创建长度是不可变的
*
*   7、数组拿首元素的内存地址作为数组对象的内存地址
* */
public class ArrayTest01 {
    public static void main(String[] args){

        // 声明一个一维数组，用来存储int类型
        int[] a1 = {100, 200, 300, 400}; //这种方式称作“静态初始化一维数组”

        // boolean类型数组
        boolean[] b1 = {true, false, true};

        // String类型数组
        String[] strs = {"ac", "ad", "fvd"};

        // byte数组
        byte[] b2 = {1,2,3};

        // char类型数组
        char[] c1 = {'a', 'b', 'c'};

        // Onject数组
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object o4 = new Object();
        Object[] o = {o1, o2, o3, o4};
    }
}

package com.company.array;
/*
    数组中存储元素的类型是统一的，每一个元素在内存中所占的空间大小是相同的，
    知道数组的首元素的内存地址，要查找的元素只要知道下标就可以快速计算除偏移量，
    通过首元素内存地址加上偏移量快速计算出查找元素的内存地址，通过内存地址快速
    定位该元素，所以数组查找元素的效率很高。

    随意的对数组进行增删元素，当增加元素的时候，为了保证数组中元素在空间存储上
    是有序的，所以被添加元素位置后面的所有元素都要向后移动。删除元素也是，后面
    所有的元素要向前移动，所以数组的增删元素效率很低。

    初始化一维数组有两种方式：
        1.静态初始化
        2.动态初始化
            动态初始化一维数组，会先在堆内存中分配这个数组，并且数组中每一个
        元素都采用默认值：
            byte、short、int、long  0
            float、double    0.0
            boolean     false
            char        \u0000
            引用         null


    什么时候使用动态初始化，什么时候使用静态初始化？

        1、无论是动态初始化还是静态初始化，最终的内存分布都是一样的

        2、如果在创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化方式。
        如果在创建数组的时候，无法预测到数组中存储什么数据，只是先开辟空间，则使用动态初始化方式。

 */
public class ArrayTest02 {
    public static void main(String[] args) {
        // 静态初始化一个int类型的一维数组
        int[] a1 = {10, 21, 31};

        // 获取元素
        System.out.println("第一个元素：" + a1[0]);
        System.out.println("第二个元素：" + a1[1]);
        System.out.println("第三个元素：" + a1[2]);

        // 取得个数
        System.out.println("数组中元素的个数是" + a1.length);

        // 遍历一维数组
        for(int i=0; i<a1.length; i++){
            System.out.println(a1[i]);
        }


        // 动态初始化一维数组
        // 动态声明一个int类型的数组，最多可以存储4个元素
        int[] a2 = new int[4];

        // 遍历
        for(int i=0; i<a2.length; i++){
            System.out.println(a2[i]);
        }

        // 引用类型的数组
        Object[] objs = new Object[3];

        // 遍历引用类型
        for(int index=0; index<objs.length; index++){
            System.out.println(objs[index]);

            // 下面这句话会报空指针异常
            //System.out.println(objs[index].toString());

            /*
            【注意】
                System.out.println();里面如果是一个引用类型的话会默认输出 引用.toString();
                但是查看System.out.println()源码：
                 public void println(Object x) {
                    String s = String.valueOf(x);
                    synchronized(this) {
                        this.print(s);
                        this.newLine();
                     }
                 }

                 public static String valueOf(Object obj) {
                    return obj == null ? "null" : obj.toString();
                }

                会发现：当引用为null的话，System.out.println() 会输出 null
                      当引用不是null的话，System.out.println() 会输出 引用.toString()
             */
        }
        
    }
}

package com.company.array;
/*
    深入一维数组
*/
public class ArrayTest03 {
    public static void main(String[] args) {

        // 创建一个数组，这个数组既可以存储Dog，也能存储Cat
        Animal[] as = new Animal[4];

        // 给数组每个元素赋值
        Animal a1 = new Animal();
        Dog d1 = new Dog();
        Cat c1 = new Cat();
        Cat c2 = new Cat();

        as[0] = a1;
        as[1] = d1;
        as[2] = c1;
        as[3] = c2;

        // 需求：遍历数组，取出每个对象，如果是Dog执行eat方法，如果是Cat执行move方法
        for(int i=0; i<as.length; i++){
            Animal a = as[i];
            System.out.println(a);
            // 强制类型转换（向下转型）
            if(a instanceof Cat){
                Cat c = (Cat)a;
                c.move();
            }else if(a instanceof Dog){
                Dog d = (Dog)a;
                d.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");
    }

package com.company.array;
/*
    方法调用的时候，也可以这样传递一个数组
 */
public class ArrayTest04 {
    public static void main(String[] args) {

        // 第一种方法
        int[] a = {1,2,3,4,5};
        m1(a);

        // 第二种方
        m1(new int[] {4,5,7,8,1,2,54});
    }

    public static void m1(int[] a){
        for(int i=0; i<a.length; i++){
            System.out.println(a[i]);
        }
    }
}

package com.company.array;
/*
    关于main方法中的参数列表 String[] args
        1、String[] args是专门用来接收命令行参数的。
        2、例如： java ArrayTest05 abc aaa bbb
            JVM 在调用ArrayTest05类的main方法之前，
          先将“abc aaa bbb”这个字符串以“空格”的方式分割，然后存储在String数组中。
 */
public class ArrayTest05 {

    // main方法中的String[]数组的设计主要是用来接收命令行参数的。
    public static void main(String[] args) {
        System.out.println("String类型的数组中元素的个数是：" + args.length);

        //需求说明：运行该软件的时候必须提供用户名和密码
        //格式： java ArrayTest05 username password
        //用户没有提供足够的参数，则退出系统。
        if(args.length != 2){
            System.out.println("想要使用该系统，必须这样输入：java ArrayTest07 username password");
            return ;
        }

        // 参数提供正确，如果用户名是admin，密码是123则登录成功
        String username = args[0];
        String password = args[1];

        // java中比较字符串是否相等，必须使用equals方法
        // String类型是SUN提供，以及equals重写了。比较的是内容
        if("admin".equals(username) && "123".equals(password)){   // 尽量使用这种方式，这种方式可以避免空指针异常
        //if(username.equals("admin") && password.equals("123")){
            System.out.println("登录成功，欢迎[ " + username + "]回来");
        }else{
            System.out.println("登录失败");
        }
    }
    
}

package com.company.array;
/*
    关于数组的拷贝：

    JDK中提供的方法，直接调用就可以了
    System.arraycopy(源数组, 源数据的开始下标, 目标数组, 目标数组的开始下标, 拷贝的长度);

 */
public class ArrayTest06 {
    public static void main(String[] args) {

        int[] src = {2, 3, 4, 5, 6, 7, 8, 9, 10};

        int[] dest = {10, 11, 12, 13, 14, 15, 16, 17, 18};

        // 把src中的4、5、6拷贝到dest数组从13开始
        System.arraycopy(src, 3, dest, 3, 3);
        for(int i=0; i<dest.length; i++){
            System.out.println(dest[i]);
        }

    }
}

package com.company.array;
/*
   二维数组特点：
       1、二维数组是一个特殊的一维数组。
       2、特殊的一维数组，特殊在这个一维数组中每一个元素都是“一维数组”。

    三维数组以此类推。


 */
public class ArrayTest07 {
    public static void main(String[] args) {

        // 静态初始化二维数组
        int[][] a = {
                {1,2,3},
                {23,57},
                {0},
                {19,78,24,87}
        };

        // 二维数组的动态初始化
        // 3个一维数组，每个一维数组中有4个元素
        int[][] b = new int[3][4];

        // 以上这个数组有多少个一维数组
        System.out.println(a.length);

        // 获取第一个一维数组
        int[] a0 = a[0];
        int a00 = a0[0];
        System.out.println(a00);

        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.println(a[i][j]);
            }
        }
    }
}

综合性案例

package com.company.array;
/*
    使用数组模拟栈

    栈：后进先出
 */
public class ArrayToStack {

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

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

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

    }

    // 栈应该对外提供一个压栈方法
    public void push(Object element) throws StackOperationException{
        /*
        elements[index] = element;
        index++;
       */

        // 合成一句
        if(index == elements.length){
            throw new StackOperationException("栈已经满了！");
        }
        elements[index++] = element;
        // elements[index++] 相当于elements[xx=index++] 先index赋值后index++
    }
    // 栈应该对外提供一个弹栈方法
    public Object pop() throws StackOperationException{
        /*
        index--;
        return elements[index];
        */

        // 合成一句
        if(index == 0){
            throw new StackOperationException("栈已经为空！");
        }
        return elements[--index];
        // elements[--index] 相当于elements[xx=--index] 先--index后index赋值
    }
}

package com.company.array;

public class StackOperationException extends Exception{

    public StackOperationException(){}

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

package com.company.array;

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

        ArrayToStack s = new ArrayToStack();

        User u1 = new User("zhangsan",20);
        User u2 = new User("lisi",21);
        User u3 = new User("tom",24);
        User u4 = new User("jack",26);
        User u5 = new User("tony",25);

        try{
            s.push(u1);
            s.push(u2);
            s.push(u3);
            s.push(u4);
            s.push(u5);

            s.push(u5);

        }catch(StackOperationException e){
            System.out.println(e.getMessage());
        }

        try{
            // 弹栈
            System.out.println(s.pop()); // 弹出的引用类型，直接调用toString方法
            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(StackOperationException e){
            e.printStackTrace();
        }
    }
}