java基础语法（十六）数组

最新推荐文章于 2023-02-23 20:11:43 发布
最新推荐文章于 2023-02-23 20:11:43 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： java 文章标签： 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Apikaqiu/article/details/105443664
版权

数组简介

Array:
1、java语言当中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object.
2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）
3、数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）
5、数组当中如果存储的是"java对象"的话，实际上存储的是对象的"引用（内存地址）"。数组中不能直接存储java对象。
6、数组一旦创建，在java中规定，长度不可变。
7、数组的分类：一维数组、二维数组、三维数组、多维数组…
8、所有的数组对象都有length属性，用来获取数组中元素的个数。
9、java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。
10、数组在内存方面存储的时候，数组中的元素内存地址是连续的.
11、数组中首元素的内存地址作为整个数组对象的内存地址。
12、数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是:length-1
通过下标对数组中元素进行"存取"。
13、数组这种数据结构的优缺点：
优点：查询/查找/检索某个下标上的元素时效率极高，可以说是查询效率最高的一个数据结构。
为什么检索效率高：
(1)、每一个元素的内存地址在空间存储上是连续的。
(2)、每一个元素类型相同，所以占用空间大小一样。
(3)、知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标
上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。
缺点：
(1)、由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低。
因为随机删除或者增加元素会涉及到后面元素统一向前或者向后位移的操作。
(2)、数组不能存储大数据量，为什么？
因为很难在内存空间上找到一块特别大的连续的内存空间。
注意：对于数组中左后一个元素的增删是没有效率影响的。
在这里插入图片描述

一维数组

1、怎么声明/定义一个以一维数组？
语法格式：
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
2、怎么初始化一个一维数组？
包括两种方式：静态初始化一维数组、动态初始化一维数组
静态初始化语法格式：
int[] array = {100,200,300,55};
动态初始化语法格式：
int[] array = new int[5];//这里的5表示数组的元素个数
//初始化一个5个长度的int类型数组，每个元素默认值是0。
String[] names = new String[6];//初始化6个长度的String类型数组，每个元素默认值null。
3、什么时候采用静态初始化方式，什么时候采用动态初始化方式
当创建数组的时候，确定数组中存储哪些具体元素时，采用静态初始化方式。
当创建数组的时候，不确定将来数组中存储哪些数据，采用动态初始化的方式，预先分配内存。

public class Test01 {
    public static void main(String[] args) {
       //声明一个int类型的数组，使用静态初始化的方式
       int[] a1={1,100,10,20,65};
       //所有的数组对象都有length属性  数组对象是数组类型的一个对象，数组元素时数组对象的一个元素
        System.out.println("数组中元素的个数"+a1.length);
       //声明一个int类型的数组，使用动态初始化的方式
        int[] a=new int[5];
        //初始化一个Object类型的数据，采用动态初始化方式
        Object[] obj = new Object[3];//3个长度，动态初始化，所以默认每个元素的值是null
        for(int i = 0;i<obj.length;i++){
            System.out.println(obj[i]);
        }
        //存储object，采用静态初始化
        Object o1 =new Object();
        Object o2 =new Object();
        Object o3 =new Object();
        Object[] objects= {o1,o2,o3};
        for(int i = 0;i<objects.length;i++){
            System.out.println(objects[i]);
        }
public class Test02 {
    public static void main(String[] args) {
        //静态初始化一维数组
        int[] x = {1,2,3,4};
        printArray(x);

        System.out.println("==============");
        //没有这种语法
        //printArray({1,2,3,4});
        //如果直接传一个静态数组的话，语法必须这样写
        printArray(new int[]{1,2,3,4});

        //动态初始化一维数组
        int[] x2 = new int[4];
        printArray(x2);

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

        String[] st = {"abc","haha","hehe"};
        printArray(st);
    }

    //为什么要用静态方法？方便，不需要new对象
    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(array[i]);
        }
    }
}

关于main()方法

main方法上面的"String[] args"有什么用？
谁负责调用main方法（JVM）
JVM调用main方法的时候，会自动传一个String数组过来

public class Test03 {
    //这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来
    public static void main(String[] args) {
        System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是"+args.length);//0
        //这个数组什么时候里面会有值呢？
        //其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数会自动被转换成"String[] args"
        //所以main反复上面的String[] args数组主要是用来接收用户输入参数的。




        //以下这行代码表示了：数组对象创建了，但是数组中没有任何数据。
        String[] strs1 = new String[0];
        String[] strs2 = {};//静态初始化数组，里面没东西
        printLength(strs1);//0
        printLength(strs2);//0
    }

    public static void printLength(String[] args){
        System.out.println(args.length);//0
    }
}

关于一维数组的例子

（1）、 模拟一个系统，假设这个系统要使用，必须输入用户名和密码

public class Test04 {
    //用户名和密码输入到String[] args当中
    public static void main(String[] args) {
        if (args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123");
            return;
        }

        //程序执行到此处说明用户确实提供了用户名和密码
        //接下来应该判断用户名和密码是否正确
        //取出用户名
        String userName = args[0];
        //取出密码
        String password = args[1];

        //假设用户名是admin,密码是123的时候表示登录成功，其他一律失败。
        //判断两个字符串是否相等，需要使用equals方法
        //if(userName.equals("admin") && password.equals("123"))
        if("admin".equals(userName) && "123".equals(password))//这样写可以避免空指针异常
        {
            System.out.println("登陆成功，欢迎[" + userName + "]回来");
            System.out.println("可以继续使用该系统......");
        }
        else {
            System.out.println("验证失败，用户名不存在或者密码错误！");
        }

    }
}

（2）、创建一个Animal类型的数组

public class Test07 {
    public static void main(String[] args) {
        //创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1,a2};

        //对Animal数组进行遍历
        for(int i = 0; i < animals.length; i++){
           /* Animal a = animals[i];
            a.move();*/
           animals[i].move();
        }
        Animal[] ans = new Animal[2];
        //创建一个Animal对象，放到数组的第一个盒子中
        ans[0] = new Animal();
        ans[0].move();//Animal move......

        //Animal数组中可以存放Cat类型的数组，因为Cat是一个Animal.
        //Cat是Animal的子类
        ans[1] = new Cat();

        //创建一个Animal类型的数组，数组当中存储Cat和Bird
        Cat c = new Cat();
        Bird b = new Bird();
        Animal[] anis ={c,b};
        //Animal [] anis = {new Cat(), new Bird()};//该数组中存储了两个对象的内存地址
        for (int i = 0 ; i <anis.length; i++){
            //这个取出来的可能是Cat,也可能是Bird，不过肯定是一个Animal
            //如果调用的方法是父类中存在的方法不需要向下转型。直接使用父类型引用调用即可。
//            Animal an = anis[i];
//            an.move();

            //调用子对象特有方法的话，需要向下转型！！！
            if(anis[i] instanceof Cat){
                Cat cat = (Cat)anis[i];
                cat.catMouse();
            }else if(anis[i] instanceof Bird){
                Bird bird = (Bird)anis[i];
                bird.sing();
            }
        }

    }
}

class Animal{
    public void move(){
        System.out.println("Animal move......");
    }
}
class Cat extends Animal{
    public void move(){
        System.out.println("猫在走猫步！！！");
    }
    //特有方法
    public void catMouse(){
        System.out.println("猫捉老鼠！！！");
    }
}

class Bird extends Animal{
    public void move(){
        System.out.println("Bird fly！！！");
    }
    //特有方法
    public void sing(){
        System.out.println("鸟儿在歌唱！！！");
    }
}

一维数组的扩容

关于一维数组的扩容：
在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
数组满了，需要扩容。
java中对数组扩容：
先创建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
结论：数组扩容效率低，因为涉及到拷贝的问题。
在这里插入图片描述

public class Test08 {
    //java中的数组是怎么进行拷贝的呢？
    public static void main(String[] args) {
        //拷贝源（从这个数组中拷贝）
        int[] src = {1,11,22,3,4};
        //拷贝目标（拷贝到这个目标数组上）
        int[] dest = new int[20];//动态初始化一个长度为20的数组，每一个元素默认值是0

        //调用JDK System类中的arraycopy方法，来完成数组的拷贝。
        System.arraycopy(src,1,dest,3,2);
        /*
			arraycopy()方法用于将一个数组的元素快速拷贝到另一个数组。其中的参数如下
				System.arraycopy(src, srcPos, dest, destPos, length);
				src表示源数组
				srcPos表示源数组中拷贝元素的起始位置。(索引)
				dest表示目标数组
				destPos表示拷贝到目标数组的起始位置
				length表示拷贝元素的个数
		*/
        //遍历目标数组
        for(int i = 0;i<dest.length;i++){
            System.out.println(dest[i]);//0 0 0 11 22 0 ... 0
        }

        int[] dest2 = new int[20];
        System.arraycopy(src,0,dest2,0,src.length);
        //数组当中如果存储的元素是引用，可以拷贝吗？可以
        String[] strs = {"hello","world","study"};
        String[] newStr = new String[5];
        System.arraycopy(strs,0,newStr,0,strs.length);
        for(int i = 0;i<newStr.length;i++){
            System.out.println(newStr[i]);//hello world study null null

        }

        Object[] objs={new Object(),new Object(),new Object()};
        Object[] newobj= new Object[5];
        //这里拷贝的时候拷贝的不是对象，而是拷贝对象的地址
        System.arraycopy(objs,0,newobj,0,objs.length);
        for(int i = 0;i<newobj.length;i++){
            System.out.println(newobj[i]);//java.lang.Object@1c53fd30 java.lang.Object@50cbc42f java.lang.Object@75412c2f null null

        }
    }


}

二维数组

关于java中的二维数组
1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
2、三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素都是一个一维数组。
3、二维数组静态初始化
int[][] array = {{1,1,2},{2,3,4,5,6},{1,3,6,7}};
4、关于二维数组中元素的：读和改
a[二维数组中的一维数组的下标][一维数组中元素的下标]
a[0][0]：表示第1个一维数组中的第1个元素

public class Test09 {
    public static void main(String[] args) {
        //一维数组
        int[] array = {100,200,300};

        //二维数组
        int[][] a = {{100,200,300,800,600},
                {30,20,40,80},
                {6,7,9,1,0}
        };
        System.out.println(a.length);//3
        System.out.println(a[0].length);//5

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


    }
}
/*
动态初始化二维数组

 */
public class Test10 {
    public static void main(String[] args) {
        //3行4列
        //3个一维数组，每个一维数组当中有4个元素。
        int[][] array = new int[3][4];

        int[][] a = {{100,200,300,800,600},
                {30,20,40,80},
                {6,7,9,1,0}};
        printArray(a);
        printArray(new int[][]{{1,2,3},{3,4,5,0,9},{12,13,15,9,7}});
    }
    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();
        }
    }
}

模拟栈数据结构

1、这个栈可以存储java中的任何引用类型的数组。
2、在栈中提供push方法模拟压栈。（栈满了要有提示信息)
3、在栈中提供pop方法模拟弹栈。（栈空了要有提示信息)
4、假设栈的默认初始化容量是10。

public class MyStack{//栈类
    //提供一个数组来存储栈中的元素
    private Object[] elements;
    //栈帧，永远指向栈顶部元素
    //注意：最初的栈是空的，一个元素都没有
    //private int index = 0;//如果index采用0，表示栈帧指向了顶部元素的上方。
    //private int index = -1;//如果index采用-1，表示栈帧指向了顶部元素。
    private int index;
    public MyStack() {
        //一维数组动态初始化,默认初始化容量是10
        this.elements = new Object[10];
        this.index = -1;
    }

    /**
     * 压栈的方法
     * @param obj 被压入的元素
     */
    public void push(Object obj){
        if(this.index>=this.elements.length-1){
            System.out.println("压栈失败，栈已满！");
            return;
        }
        //程序走到这里，说明栈没满
        //向栈中加1个元素，栈帧向上移动一个位置

        this.index++;
        this.elements[index]=obj;
        //elements[++index]=obj;
        //所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法
        System.out.println("压栈"+obj +"元素成功，栈帧指向"+index);
    }

    /**
     * 弹栈的方法，从数组中往外取元素。每取出一个元素，栈帧向下移动一位。
     * @return
     */
    public void pop(){
        if(index < 0){
            System.out.println("弹栈失败，栈已空！");
        }else{
            System.out.print("弹栈"+this.elements[index] +"元素成功" );
            //栈帧向下移动一位
            index--;
            System.out.println("栈帧指向"+index);
        }
        return ;
    }

    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

public class MyStackTest {
    public static void main(String[] args) {
        //创建一个栈对象
        MyStack stack=new MyStack();
        //调用方法压栈
        stack.push(new Object());//压栈java.lang.Object@39ba5a14元素成功，栈帧指向0
        //弹栈
        stack.pop();//弹栈java.lang.Object@39ba5a14元素成功栈帧指向-1
    }

}
顺毛黑起
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java语法基础-4（数组）
weixin_44059750的博客
09-03 621
Java基本语法（数组）的使用概述数组的分类一维数组一维数组的声明和初始化如何给一维数组赋值如何调用一维数组指定位置的元素如何获取一维数组的长度如何遍历一维数组一维数组元素的默认初始化值多维数组二维数组的声明和初始化如何给二维数组赋值如何调用二维数组指定位置的元素如何获取二维数组的长度如何遍历二维数组二维数组元素的默认初始化值 概述 数组是Java中用来存储固定大小的同类型元素 数组是有序排列的 数组中的元素，可以是基本数据类型，也可以是引用数据类型 数组的长度一旦确定，就不能更改 数组创建的时候会在内存
Java基础语法（五）-数组
Denzel_li的博客
06-11 107
dataType[ ] arrayRefVar ；首选dataType arrayRefVar[ ];​ arrayRefVar = new dataType[数组长度]； 内存分析 静态初始化int[ ] a = {1, 2, 3}Man[ ] mans = {new Man(1, 1), new Man(2, 2)}动态初始化int[ ] a = new int[2];a[0] = 1;a[1] = 2;数组的默认初始化数组是引用类型，它的元素相当于类的实例变量
【java】数组是基本类型还是引用类型
之虎者也的博客
12-20 6151
答：是引用类型。 这里通过一个简单的样例进行说明： public static void main(String[] args) { int[] a = {1,2}; int[] b = a; a[0] = 10; System.out.println(b[0]); //输出10 } 可以看到，把数组a的第一个值改为10后，输出b的第一个值也是10，a和b两个变量引用了同一个数组。虽然保存的是基本类型值int，但是数组本身是引用类型的。 ...
Java【数组】定义与使用，什么是引用类型你知道吗
yzhcjl_的博客
11-06 2398
数组的定义和使用，引用类型到底是什么，关于数组的库方法，你都会嘛
JAVA引用类型（1）——数组
qq_42424228的博客
07-19 2273
数组是一种容器，可以同时存放多个相同数据类型的数据 数组是一种引用类型，其长度在程序运行期间不可以改变 初始化 动态初始化（指定长度）： 格式： 数据类型[] 数组名称 =new 数据类型[数据长度]； 左右俩侧数据类型必须相同。int[] str = new int[10]; short[] str2 = new short[200]; String[] str3 = new String[20]; 静态初始化（指定内容） 静态初始化的长度由初始化的数据个数决定。 基本格式：数据类型[] 数组名称 =
数组（Java）
qq_55917377的博客
12-26 131
数组（Java）
Java——引用数据类型—数组
最新发布
qq_53861505的博客
02-23 780
Java —— 引用数据类型—数组
04_Java基础语法_（数组）_讲义
02-15
Java是一种广泛使用的面向对象的编程语言，其强大的功能...这份“04_Java基础语法_（数组）_讲义”文档将详细解析数组的各个方面，助你巩固这方面的知识。阅读并实践其中的例子，将有助于你更好地理解和运用Java数组。
day07-基础语法-数组
12-12
Java 基础语法 - 数组 数组是 Java 语言中的一种基本数据结构，它可以存储多个变量（元素），这些变量的数据类型必须一致。数组既可以存储基本数据类型，也可以存储引用数据类型。 一、数组的定义和初始化 在 ...
Java基础语法.docx
05-13
Java基础语法的word版，md版本图片可能加载不出来，这个有全部的效果图，配合视频看效率更快——b站“狂神说Java”
JAVA入门基础语法数组.docx
12-27
JAVA入门基础语法数组.docx
day002 JAVA语法基础-数组加强.doc
08-16
在 `JAVA` 程序中，数组的使用是基础也是关键。数组加强练习旨在提高对数组操作的理解和熟练度。 ### 1. 数组加强练习 在实际编程中，数组经常用于存储和处理数据。以下是一些常见的数组操作练习： 1. **统计字符...
Java数组类型
HHYZBC的博客
04-26 4881
数组的概述 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类
《java练级之路》之数组为什么叫引用类型
xiaoyubuhuiqiche的博客
11-06 612
相信大家都会想要了解，在java中我们的数组是如何访问的呢？又是如何修改，以及注意事项，今天，我这篇文章会给大家详细点的讲解，经过小鱼多次修改反复确认，绝对是值得一看的作品
JavaSE---02数组
feverd555的博客
05-21 198
02 数组 2.1 数组的特点 数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间 数组的长度一旦确定，就不能修改 数组是有序排列的 2.2 数组的一些操作 1.初始化和长度 //1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行 int[] ids = new int[]{1001,1002,1003,1004}; //1.2动态初始化:数组的初始化和数组元素的赋值...
第二章：数组
qq_28384023的博客
11-13 265
asdasd
六年面试经验来分享JAVA基础面试题
weixin_51072772的博客
10-12 3869
来源 | 极链AI云（性价比最高的共享GPU算力平台，双十活动进行中 10.9-10.11，充值就送！最多可送2500元现金券！免费试用地址：https://cloud.videojj.com/） 1.面向对象和面向过程的区别 面向过程 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源。比如单片机、嵌入式开发、Linux/Unix，等一般采用面向过程开发，性能是最重要的因素。 缺点：没有面向对象易维护、易复用、易扩展 面向对象 优点：易维护、易复用、易扩展，由于面向对象有
引用数据类型：数组 - Java基础知识 4
57
05-02 1250
所有的项目开发中，都存在有数组的使用，下面介绍数组的基本概念与使用。 数组的基本概念 如果要定义一百个变量，使用基本数据类型可以定义，但是不方便定义与使用。在程序开发过程中考虑一组变量的整体维护，专门提供数组的定义。即数组的本质是相关变量的集合，需要注意：在Java中数组定义为引用数据类型，所以数组一定牵扯到内存的分配，即考虑到使用关键字new来处理，数组的定义格式： 数组的动态初始化：初始...
java基础语法（二十二）List
热门推荐
Apikaqiu的博客
04-27 1万+
List接口常用方法 1、List集合存储元素特点：有序可重复 有序：List集合中的元素有下标，从0开始，依次递增 可重复：存储的元素可以重复 2、List既然是Collection接口的子接口，那么肯定List接口有自己"特色"的方法; 以下只列出List接口特有的常用的方法 void add(int index,E element) 在列表的指定位置插...
Java编程技术课件：03数组(4学时).pptx
05-31
数组不能直接初始化元素，但可以通过初始化语法`int[] a = {1, 2, 3, 4, 5}`或`int[] a = new int[] {1, 2, 3, 4, 5}`快速初始化。 2. **二维数组**： - 二维数组用于表示表格结构，声明时需指定两个维度，如`int...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值