java基础语法-day23进阶数组

最新推荐文章于 2021-09-02 13:29:47 发布

只会写bug的菜鸡

最新推荐文章于 2021-09-02 13:29:47 发布

阅读量219

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/mzj15101229871/article/details/111939150

版权

java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

p543 一维数组概述

/**
 *  1、java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object
 *  2、数组实际上是一个容器，存储多个元素。（数组是一个数据的集合）
 *  3、数组可以存储基本数据类型，也可以存储引用数据类型。
 *  4、数组是引用数据累心给，所以在堆内存中存储
 *  5、数组中如果存储java对象的话，实际上存储的是java对象的引用。
 *  6、数组一旦创建，在Java中规定，长度不可变
 *  
 *
 */

在这里插入图片描述

P544-P546 一维数组内存结构以及优缺点

/**
 *  1、java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object
 *  2、数组实际上是一个容器，存储多个元素。（数组是一个数据的集合）
 *  3、数组可以存储基本数据类型，也可以存储引用数据类型。
 *  4、数组是引用数据累心给，所以在堆内存中存储
 *  5、数组中如果存储java对象的话，实际上存储的是java对象的引用。
 *  6、数组一旦创建，在Java中规定，长度不可变
 *  7、数组分类：一维数组、二维数组、三维数组。
 *  8、所有数组都有length属性用来获取数组长度
 *  9、java中的数组要求元素类型统一。int类型数组只能存储int数据

 *  11、将首元素的内存地址作为整个数组的内存地址（数组的内存地址就是第一个元素的内存地址）
 *  12、每一个元素都有下标，下标从0开始，以1递增，最后一个元素的下标是length-1.数组的下标很重要，存取的时候需要通过下标来进行。
 *  13、数组的优点：
 *         ·查找效率高（原因：1、每一个元素的内存地址在空间存储上是连续的
 *                          2、每一个元素类型相同，所以占用空间大小一样
 *                          3、知道第一个元素的内存地址，知道每一个元素占用的空间大小，
 *                          又知道下标。就可以通过计算得到）
 *  13、数组的优点：
 *         ·查找效率高（原因：1、每一个元素的内存地址在空间存储上是连续的
 *                          2、每一个元素类型相同，所以占用空间大小一样
 *                          3、知道第一个元素的内存地址，知道每一个元素占用的空间大小，
 *                          又知道下标。就可以通过计算得到）
 *  14、数组的缺点：
 *         ·第一：由于要保证空间连续，所以在数组上随机删除或增加元素时，
 *              效率低，因为随即增删会导致后面元素的统一位移操作。
 *         ·第二：数组不能存储大数据量，为什么？
 *              因为在内存空间上很难找到一块特别大的连续的内存空间。
 */

在这里插入图片描述

P547 初始化一维数组

 *  15、定义一个数组：
 *          ·语法格式：
 *               int[] array1;
 *               double[] array2;
 *               boolean[] array3;
 *               ...
 *  16、初始化一个一维数组语法格式：
 *         ·静态初始化：
 *              int[] array = {100,2100,300,4225};
 *         ·动态初始化：
 *              int[] array = new int[5];//初始化一个5个元素的int数组，每个元素默认值为0；
 *              String[] names = new String[6];//初始化一个6个元素的String数组，每个元素的默认值为null
 *

P548 访问一维数组的元素


public class ArrayTest01 {
    public static void main(String[] args) {
        int[] a1 = {1,2,33,45,334,56,23};
        System.out.println("数组中元素的个数："+a1.length);
        System.out.println("数组中第一个元素："+a1[0]);
        System.out.println("数组中第二个元素："+a1[1]);
        System.out.println("数组中第三个元素："+a1[2]);
        System.out.println("最后一个元素是："+a1[a1.length-1]);

        //修改元素
        a1[0] = 111;
        a1[a1.length-1] = 100;
        System.out.println("数组中第一个元素："+a1[0]);
        System.out.println("最后一个元素是："+a1[a1.length-1]);

    }
}

P549 遍历一维数组

在这里插入图片描述

P550 动态初始化一维数组

public class ArrayTest02 {
    public static void main(String[] args) {
       //存储Object，采用静态初始化
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object o4 = new Object();

        Object[] objects = {o1,o2,o3,o4};

        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);

        }

        System.out.println("++++++++++++++++++++++");

        //采用动态初始化。
        Object[] objects1 = new Object[4];
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects1[i]);

        }


    }
}

在这里插入图片描述

P551-p552 方法的参数是数组

public class ArrayTest03 {
    public static void main(String[] args) {
        int[] x = {1,2,3,4};
        printArray(x);//调用方法的时候传递的参数是一个数组

        String[] strs = {"abc","def","xyz"};
        printArray(strs);

        String[] strArray = new String[10];
        printArray(strArray);

        System.out.println("=================");
        printArray(new int[3]);
        printArray(new String[4]);

    }

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

        }

    }
    //构造方法
    public static void printArray(String[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println("String数组中的元素："+array[i]);

        }

    }
}

P553 -P554main方法中的String数组有什么用

public static void main(String[] args) 当中的String数组用来接收用户输入
在这里插入图片描述

public class ArrayTest06 {
    //用户名和密码存储到String args数组中，所以数组的长度为2，
    public static void main(String[] args) {
        if (args.length != 2){
            System.out.println("使用该系统时请输入程序参数，" +
                    "参数包括用户名和密码信息，" +
                    "例如：zhangsan，1234456");
            return;
        }
        //程序执行到此处说明的确提供了用户名和密码
        //接下来就应该判断用户名和密码
        //取出过用户名和密码
        //假设用户名和密码分别是admin和123就是登陆成功
        String username = args[0];
        String password = args[1];

     /*   if (username.equals("admin") && password.equals("123")) {
            System.out.println("登陆成功，欢迎" + args[0] + "回来");
            System.out.println("您可以使用该系统....");

        } else {
            System.out.println("验证错误,用户名不存在或者密码错误！");
        }*/
        //这样写if语句可以避免空指针异常
        if ("admin".equals(username) && "123".equals(password)) {
            System.out.println("登陆成功，欢迎" + args[0] + "回来");
            System.out.println("您可以使用该系统....");

        } else {
            System.out.println("验证错误,用户名不存在或者密码错误！");
        }
    }
}

P555 引用数据类型的数组

public class ArrayTest07 {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1,a2};

        //遍历,Animal类型的数组，每一次循环取出的元素就是Animal类型
        for (int i = 0; i < animals.length; i++) {
           /* Animal a = animals[i];
            a.move();*/
            animals[i].move();
        }
        System.out.println("======================");

        Animal[] ans = new Animal[2];
        ans[0] = new Animal();
//        ans[0] = new Product();//报错
        ans[1] = new Cat();
        for (int i = 0; i < ans.length; i++) {
            ans[i].move();
        }

        System.out.println("======================");

        //创建一个Animal类型的数组，数组中存储Cat和Bird
        Animal[] ans2 = new Animal[3];
        ans2[0] = new Cat();
        ans2[1] = new Bird();
        ans2[2] = new Bird();

        for (int i = 0; i < ans2.length; i++) {
//            ans2[i].move();
            //如果调用Animal的方法是没问题的，
            // 但是如果调用子类的特有方法的话，就需要instanceof来判断
            if(ans2[i] instanceof Cat){
//                ((Cat) ans2[i]).catchMouse();//idea自动会强制转换
                Cat cat = (Cat)ans2[i];
                cat.catchMouse();
            }else if (ans2[i] instanceof Bird){
                Bird bird = (Bird)ans2[i];
                bird.sing();
            }

        }


    }

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

}
class Product{

}
class Cat extends Animal{
    public void move(){
        System.out.println("猫在走猫步！");
    }
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}
class Bird extends Animal{
    public void move(){
        System.out.println("Bird Fly!!!");
    }
    public void sing(){
        System.out.println("鸟儿在歌唱！");
    }
}

P556 -p557 数组的扩容、拷贝

在这里插入图片描述

public class ArrayTest08 {
    public static void main(String[] args) {
        int[] src = new int[5];
        for (int i = 0; i < src.length; i++) {
            src[i] = i;
            System.out.println(src[i]);
        }

        System.out.println("==================");
        //新建一个大数组用来拷贝,只拷贝2个元素
//        int[] a2 = new int[10];
//        System.arraycopy(a,1,a2,5,2);
//        for (int i = 0; i < a2.length; i++) {
//            System.out.println(a2[i]);
//
//        }
        //拷贝src中的所有元素到dest中
        int[] dest  =new int[20];
        System.arraycopy(src,0,dest,0,src.length);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);

        }
        System.out.println("=====================");
        //拷贝引用数据类型
        String[] strs1 = {"hello","world","baidu","jingDong"};
        String[] strs2 = new String[20];
        System.arraycopy(strs1,0,strs2,0,strs1.length);
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);

        }
        System.out.println("=====================");

        Object[] objects = {new Object(),new Object(),new Object()};
        Object[] newObjs = new Object[10];
        System.arraycopy(objects,0,newObjs,0,objects.length);
        for (int i = 0; i < newObjs.length; i++) {
            System.out.println(newObjs[i]);

        }


    }
}

P556 二维数组

在这里插入图片描述

P558-p559 二维数组，二维数组的长度

在这里插入图片描述

P560 二维数组的元素访问

public class ArrayTest11 {
    public static void main(String[] args) {
        int[][] array = new int[3][4];

     /*   for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");

            }
            System.out.println();

        }*/
        //静态初始化
        int[][] a = {
                {1,2,3,4},
                {5,6,7},
                {8,9},

        };

        printArray(a);
        //可以这样写
        printArray(new int[][]{{12,34,56},{67,78,89},{123}});


    }

    public static void printArray(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");

            }
            System.out.println();

        }
    }
}

P563 布置作业使用一位数组存储模拟栈数据结构

在这里插入图片描述

P565-568 回顾数组

在这里插入图片描述

P572-575 实现酒店管理系统（详细代码见本地day23）

在这里插入图片描述
end

只会写bug的菜鸡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础语法-day23进阶数组

p543 一维数组概述/** * 1、java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object * 2、数组实际上是一个容器，存储多个元素。（数组是一个数据的集合） * 3、数组可以存储基本数据类型，也可以存储引用数据类型。 * 4、数组是引用数据累心给，所以在堆内存中存储 * 5、数组中如果存储java对象的话，实际上存储的是java对象的引用。 * 6、数组一旦创建，在Java中规定，长度不可变 * * */P544-P546 一维
复制链接

扫一扫

专栏目录