二十五、Java基础之一维数组

/*
一、一维数组：特点
    1.数组是一种引用类型
    2.数组是一种简单的数据结构，线性结构
    3.数组是一个容器，可以用来存储其他元素，数组是可以存储数据类型的元素
    4.数组分类：一维数组，二维。。。。多维
    5.数组中存储的元素类型是统一的
    6.数组长度不可改变，数组一旦创建长度不可改变

二、介绍

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

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

三、数组初始化的两种方式

初始化一维数组两种方式：
    1.静态初始化

    2.动态初始化

1.静态初始化
例1：

public class ArrayTest01 {

    public static void main(String[] args){

        //申明一个一维数组，用来存储list类型
        int[] a1={100,200,300};//这种方式呗称作初始化一维数组

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

        //String类型的数组
        String[] s1={"AA","BB","CC","DD"};

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

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

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

例2：

public class ArrayTest02 {

    public static void main(String[] args){

        //静态初始化一个int类型的一维数组
        int[] a1={10,12,31,44,13};
        //去得第一个元素
        System.out.println("第一个元素是："+a1[0]);
        System.out.println("最后一个元素是："+a1[4]);
        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("----------------------");
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
        }

    }
}

2.动态数组初始化

/*
动态初始化数组
    1.动态初始化一维数组，会在堆中内存中分配这个数组，并且数组中每个元素都采用
    默认值：
    byte，short，int，long，0
    float,double 0.0
    boolean false
    cahr \u0000
 */

public class ArrayTest03 {

    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]=100;
        a1[1]=200;
        a1[2]=120;
        a1[3]=102;

        //引用类型的数组
        Object[] obj=new Object[3];
        for(int index=0;index<obj.length;index++){

            Object o=obj[index];
            //.toString();//注意空指针异常，因为引用类型的数组默认值是null
            System.out.println(o/*o.toString()*/);
            //分析System.out.println(o.toString())与System.out.println(o)
            /*
            public void println(Object x) {
                String s = String.valueOf(x);
                synchronized (this) {
                print(s);
                newLine();

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

 

/*
四、什么时候使用动态初始化，什么时候使用静态初始化？
    1.无论是动态初始化还是静态初始化，最终的内存分布都是一阿姨那个的
    2.如果在创建的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化方式，
    3.如果在创建数组的时候们无法预料到数组中存储什么数据，只是先开辟空间，则
    使用动态初始化的方式

 */

public class Test04 {

    public static void main(String[] args){


        //以下两种方式都是可以的
        int[] a1={1,2,3};
        //C++
        int a2[]={5,6,7};
        int a3[]=new int[4];

    }
}

 

五、深入一维数组

1.Aniaml  Dog  Cat  Test

public class Test05 {

    public static void main(String[] args){

        //创建一个数组，既能存储Dog和Cat
        Animal[] a1=new Animal[4];


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

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

        //需求：遍历数组，去除每个对象，如果是Dog执行eat方法，如果是Cat执行move方法
        for(int i=0;i<a1.length;i++){
            Animal aa1=a1[i];

            //强制类型转换，向下转型
            if(aa1 instanceof Cat){
                Cat c=(Cat)aa1;
                c.move();
            }else if (aa1 instanceof Dog){
                Dog d=(Dog)aa1;
                d.eat();
            }
        }


    }
}

class Animal {}

class Dog extends Animal{

    public void eat(){
        System.out.println("狗在吃！");
    }
}

class Cat extends Animal{

    public void move(){
        System.out.println("猫在移动");
    }
}

 

/*
2.方法调用时候，也可以这样传递一个数组

 */

public class Test06 {

    public static void main(String[] args){
        //第一种方式：
        int[] a={12,13,14,15};
        m1(a);

     //第二种方式：
        m1(new int[]{111,333,444});
    }

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


}

/*
六、关于main方法中的参数列表String[] args
    1.String[] args是专门用来接收命令行参数的
    2.例如：java Test07 abc ccc fff
        JVM在调用Test07 main方法之前。先“abc ccc fff”这个字符以空格的方式
        分割，然后存储在String数组中

 */

public class Test07 {

    //main方法中的String[] 数组的设计主要是用来接收命令行参数的
    public static void main(String[] args){

        /*
        System.out.println("String类型数组中元素的个数"+args.length);
        */

        //需求说明：运行该软件的时候必须提供用户名和密码
        //格式：java Test07 username password
        //如果用户没有提供足够的参数，则退出系统

        if(args.length!=2){
            System.out.println("想要登录成功系统，许需要按照此格式：java Test07 username password");
        }
        String username=args[0];
        String password=args[1];

        //java中比较字符串是否相等，必须使用equals
        //String类型是SUN提供，已经equals重写了，比较的是内容
        if("admin".equals(username) && "123".equals(password)){
        //下面这种方式统一出现空指针，username空的时候，会报空指针
        //if(username.equals("admin") && password.equals("123")){
            System.out.println("登录成功！欢迎["+username+"]回来");
        }else{
            System.out.println("登录失败！");
        }
    }
}