正文

七java数组

许忠慧  2022-06-15  607

关键词：

一、一维数组

1.声明方式：

type var [ ] ; 或 type [ ] var ;

例如：

int a1[];
int[] a2;
double b[];
Person [] p1;
String s1[];

java语言中声明数组时不能指定其长度（数组中的元素个数）因为java数组分配的空间是在堆上面，例如：

int a[5];    //非法

2.数组对象的创建

java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素个数]，例如：

public class Test {
    public static void main(String[] args){
        int[] s;
        s = new int[5];
        for (int i=0;i<5;i++){
            s[i] = 2 * i + 1;
        }
        
    }
}

3.元素为引用数据类型的数组

注意：元素为引用数据类型的数组中的每一个元素都需要实例化

例如：

public class Test {
    public static void main(String[] args){
        Date[] days;
        days = new Date[3];
        for (int i=0;i<3;i++){
            days[i] = new Date(2004,4,i+1);
        }
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

4.数组初始化

1）动态初始化

数组定义与为数组元素分配空间和赋值的操作分开进行，先分配空间再赋值；例如：

public class Test {
    public static void main(String[] args){
        int a[];
        a = new int[3];
        a[0] = 3;
        a[1] = 9;
        a[2] = 8;
        
        Date days[];
        days =new Date[3];
        days[0] = new Date(1, 4, 2004);
        days[1] = new Date(2, 4, 2004);
        days[2] = new Date(3, 4, 2004);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

2）静态初始化

在定义数组的同时就为数组元素分配空间并赋值，例如：

public class Test {
    public static void main(String[] args){
        int a[] = {3,9,8};    
        Date days[] = {new Date(1, 4, 2004),new Date(2, 4, 2004),new Date(3, 4, 2004)};
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

5.数组元素默认初始化

数组是引用类型，他的元素相当于类的成员变量，因此，数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，例如：

public class Test {
    public static void main(String[] args){
        int a[] = new int[3];
        Date[] days = new Date[3];
        System.out.println("a[3] = "+a[2]);
        System.out.println("days[3] = "+days[2]);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

输出结果：

a[3] = 0
days[3] = null

6.数组元素的引用

定义并用运算符new为数组分配空间后，才可以引用数组中的每个元素，数组元素的饮用方式为：

arrayName[index]

其中index为数组元素的下标，可以是整型常量或整型表达式。如：a[3],b[i],c[6*i]等

数组元素下表从0开始；长度为n的数组的合法下标取值范围为：0—（n-1）

每个数组都由一个属性length指明它的长度，例如：a.length的值为数组a的长度（也就是元素个数）

二、二维数组

1.概念

二维数组可以看成是以数组为元素的数组，例如：

int a[] [] = { {1,2}, {3,4,5,6}, {7,9}};

java中多维数组的声明和初始化应从高纬到低纬的顺序进行，例如：

int a[][] = new int [3][];
a[0] = new int [2];
a[1] = new int [4];
a[2] = new int [3];
//非法
int t1[][] = new int [][4];

如上的示例可以参考下面的图来理解：

以二维数组为例，其实二维数组就相当于数组中包含数组，所以在声明的时候要先声明第一纬度，如上：、

a[0] = new int [2]; 相当于给第一个包含在内的数组声明了两个小格的内存，

a[1] = new int [4]; 相当于给第二个包含在内的数组声明了四个小格的内存，

a[2] = new int [3]; 相当于给第三个包含在内的数组声明了三个小格的内存，

理解了二维数组的概念应该就能理解多维的概念

2.初始化

静态初始化：

int intA[][] = {{1,2},{3,4},{7,8,9}};
int intB[3][2] = {{1,2},{3,4},{7,8,}};//非法

动态初始化：

int a[][] = new int [3] [5];
int b[][] = new int [3][];
b[0] = new int [2];
b[1] = new int [3];
b[2] = new int [5];

3.二维数组举例

//测试类
public class Test {
    public static void main(String[] args){
        int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
        for(int i=0;i<a.length;i++) {
            for (int j=0;j<a[i].length;j++) {
                System.out.print("a["+i+"]["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }        
    }    
}

//输出结果

a[0][0]=1  a[0][1]=2  
a[1][0]=3  a[1][1]=4  a[1][2]=5  a[1][3]=6  
a[2][0]=7  a[2][1]=8  a[2][2]=9

//测试类
public class Test {
    public static void main(String[] args){
        String[][] s;
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];
        
        for(int i=0;i<s.length;i++) {
            for(int j=0;j<s[i].length;j++) {
                s[i][j] =new String("我的位置是： "+i+","+j);
                System.out.print(s[i][j]+"    ");
            }
            System.out.println();
        }
    }
}

//输出结果：

我的位置是： 0,0    我的位置是： 0,1    
我的位置是： 1,0    我的位置是： 1,1    我的位置是： 1,2    
我的位置是： 2,0    我的位置是： 2,1

三、数组的拷贝

使用java.lang.System类的静态方法：

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int lenth)

可以同于数组src从第srcPos项元素开始的lenth个元素拷贝到目标数组从destPos项开始的length个位置
如果源数据数目超过目标数组边界会抛出IndexOutOfBpundsException异常
需要注意的是，修改拷贝后的数组，源数组的值也会跟着改变，因为copy后的数组和源数组在内存空间指向的是同一地址，可以参考后面的例子来理解这句话

看一个例子：

//测试类
public class Test {
    public static void main(String[] args){
        //一维数组的拷贝
        String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s, 0, sBak, 0, s.length);
    
        for(int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+" ");
        }
        System.out.println();
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+" ");
        }
        System.out.println();
        //二维数组的拷贝
        int [][] intArray = {{1,2},{1,2,3},{3,4}};
        int [][] intArrayBak = new int[3][];
        System.arraycopy(intArray, 0, intArrayBak, 0, intArray.length);
        intArrayBak[2][1] = 100;
        for(int i = 0;i<intArray.length;i++) {
            for(int j=0;j<intArray[i].length;j++) {
                System.out.print(intArray[i][j]+"     ");
            }
            System.out.println();
        }
    }
}

再看一个例子：

public class Test {
	public static void main(String[] args) {		
		int a[] = {1,2,3,4};
		int b[] = {4,2,3,5,6};
		int c[];
		int c1[];
		//相当于数组扩充,观察c1和c2的输出来参考这个函数的使用方式
		c = Arrays.copyOf(b, a.length + b.length);
		c1 = Arrays.copyOf(a, a.length + b.length);
		System.out.println("c = " + Arrays.toString(c));
		System.out.println("c1 = " + Arrays.toString(c1));
		//数组拷贝
		System.arraycopy(b, 0, c, a.length, b.length);
		System.out.println("c = " + Arrays.toString(c));		
		System.out.println("a = " + Arrays.toString(a));
		System.out.println("b = " + Arrays.toString(b));	
	}
}

四、练习

1.练习1

public class Test {
    public static void main(String[] args){
        int a[] = {1,3,5,7,9,11,13,15,17};
        //打印数组中所有元素
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
}

输出结果

1 3 5 7 9 11 13 15 17

这里要说一下main主方法中有一个（String[] args），main()方法是Java应用程序的入口方法，也就是说main()方法是程序运行的时候第一个执行方法，这个方法体是被固定的，比如方法名字必须是main，类型必须是public static void的，方法必须接受一个字符串数组的参数，这个参数主要是为程序使用者在命令行状态下与程序交互提供的一种手段

再简单点，其实main方法中的数组就是为了让使用者通过命令行传参来使用的一个数组。你也可以在自己的程序中利用for循环将main方法中的数组打印出来，但是在不传参的情况下打印出来的内容为空，但是如果在命令行下运行你的测试类，并在命令行传入参数，就会进行输出了，比如：

2.练习2

使用命令行传参的方式写了一个小的计算器，计算加减乘除

public class Test {
    public static void main(String[] args){
        if(args.length<3){
            //使用了转义符
            System.out.println("Usage: java Test \"n1\" \"op\" \"n2\"");
        } else if(args.length==3) {
            //写了一个小计算
              //将参数的字符串转换为基础类型

            double d1 = Double.parseDouble(args[0]);
            double d2 = Double.parseDouble(args[2]);
            double d = Double.parseDouble(args[1]);
            if(args[1].equals("+")) {
                d = d1 + d2;
            }else if(args[1].equals("-")) {
                d = d1 - d2;
            }else if(args[1].equals("x")) {
                d = d1 * d2;
            }else {
                d = d1 / d2;
            }
            System.out.println(d);
        } else {
            System.out.println("Usage: java Test \"n1\" \"op\" \"n2\"");
        }
    }
}

3.练习3

这是一段对命令行传参进行排序并输出的小程序，可以试着写一下调试一下，当然这不一定是最优算法，只是拿来测试用一下

public class Test {
    public static void main(String[] args){
        int[] a = new int[args.length];
        for(int i=0;i<args.length;i++) {
            a[i] = Integer.parseInt(args[i]) ;
        }
        print(a);
        sort(a);
        print(a);
        
    }
    
    private static void sort(int[] a) {
        for(int i=0;i<a.length;i++) {
            for(int k=i+1;k<a.length;k++){
                if(a[k] < a[i]) {
                    int temp =a[i];
                    a[i] = a[k];
                    a[k] = temp;
                }
            }
        }
    }

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

java学习日记基础篇（七)——数组排序

数组为什么要有数组？案例：一个养鸡场有六只鸡，他们的体重分别为3kg，5kg，1kg，3.4kg，2kg，50kg。请问这六只鸡的总体重和平均体重是多少？1publicclasstest52{3publicstaticvoidmain(String[]args)4{5//如果没有数组就要定义六个变量,然后算... 查看详情

第七讲课后

1.阅读QiPan.java示例程序了解如何利用二维数组和循环语句绘制五子棋盘。他利用每次改变二维数组的值+每次改变棋盘2.请编写一个程序将一个整数转换为汉字读法字符串。比如“1123”转换为“一千一百二十三”。... 查看详情

四月七号java基础学习

...型有整型、浮点型、字符型、布尔型引用数据类型有类、数组以及接口2.常量的声明需要用关键字final来标识3.JAVA语言的变量名称由数字，英文字母以及下划线组成，第一个字符不能是数字也不能是java语言关键字，JAVA语言变量名... 查看详情

swift学习笔记七：集合

数组Array数组的创建OC中使用@[]定义数组,Swift中使用[]定义数组 [类型]表示数组中存放的都是该类型的元素Swift中数组中的元素可以是基本数据类型//创建数组vararray1:Array<Int>vararray2:Array<Int>=[2,3]vararray3:[Int]vararray33=[Int](... 查看详情

17.10.27作业字符数组七则

例题(12.3)忽略大小写的字符串比较(1016) 描述一般我们用strcmp可比较两个字符串的大小，比较方法为对两个字符串从前往后逐个字符相比较（按ASCII码值大小比较），直到出现不同的字符或遇到‘ 查看详情

matlab学习七：数组比较sortrows(代码片段)

数组比较sortrows对矩阵行或表行进行排序语法B=sortrows(A)B=sortrows(A,column)B=sortrows(___,direction)B=sortrows(___,Name,Value)[B,index]=sortrows(___)tblB=sortrows(tblA)tblB=sortrows(tblA,&# 查看详情

实验七c字符数组和字符串函数

7.1#include<stdio.h>#include<string.h>intmain(){ chara[40]; inti; gets(a); //输入字符串进入数组 for(i=0;i<strlen(a);i++) { if(a[i]>=‘a‘&&a[i]<=‘z‘) a[i]-=32; } puts(a); printf 查看详情

树状数组bzoj3132上帝造题的七分钟

3132:上帝造题的七分钟TimeLimit:20Sec MemoryLimit:128MBSubmit:1004 Solved:445[Submit][Status][Discuss]Description“第一分钟，X说，要有矩阵，于是便有了一个里面写满了0的n×m矩阵。第二分钟，L说，要能修改，于是便有了将左上角... 查看详情

七线性表的链式存储结构(代码片段)

1、问题引入开发数组类模板的原因在于：在创建基于顺序存储结构的线性表时，发现这样的线性表可能被误用，因为重载了数组访问操作符，使用时跟数组类似，但是线性表和数组有很大的区别，所以激发了新的需求：开发数... 查看详情

bzoj3132上帝造题的七分钟（差分+二维树状数组）(代码片段)

bzoj3132上帝造题的七分钟（差分+二维树状数组）　　TimeLimit:20Sec　　MemoryLimit:128MBDescription　　“第一分钟，X说，要有矩阵，于是便有了一个里面写满了0的n×m矩阵。　　第二分钟，L说，要能修改，于是便有了将左上角为(a,b)，... 查看详情

bzoj3132上帝造题的七分钟树状数组

【BZOJ3132】上帝造题的七分钟Description“第一分钟，X说，要有矩阵，于是便有了一个里面写满了0的n×m矩阵。第二分钟，L说，要能修改，于是便有了将左上角为(a,b)，右下角为(c,d)的一个矩形区域内的全部数字加上一个值的... 查看详情

codevs2492上帝造题的七分钟2(树状数组+并查集)

传送门树状数组模板题。注意优化，假设某个数的值已经是1了的话。那么我们以后就不用对他进行操作了，这个能够用并查集实现。这道题还有个坑的地方，给出查询区间端点的a,b，有可能a>b。#include<cstdio>#include<cm... 查看详情

java数组超详解(代码片段)

目录一、前言二、数组的定义数组定义的形式：格式1：格式2：三、数组的初始化方式：1.动态初始化动态开辟的示意图：2.静态初始化四、索引访问数组五、数组长度表示六、遍历数组方法一：实例演示&#x... 查看详情

七数组和集合（一维数组和二维数组的声明以及使用，arraylist类，hashtable,list,directory字典等常用集合（泛型和非泛型））

数组数组就是一个集合，同一数据类型的一组值，是数量固定的相同类型元素的组合。数组属于引用类型数组的索引从0开始，就是说如果你想访问一个数组元素，你就得通过，相应元素的整数索引号访问。定义一维数组：数组... 查看详情

七ref引用与数组的常用方法(代码片段)

一、ref引用1.1、什么是ref引用ref用来辅助开发者在不依赖于jQuery的情况下，获取DOM元素或组件的引用。每个vue的组件实例上，都包含一个$refs对象，里面存储着对应的DOM元素或组件的引用。默认情况下，组件的$refs... 查看详情

七ref引用与数组的常用方法(代码片段)

经典排序算法学习笔记七——堆排序

堆排序数据结构数组最差时间复杂度O(n*logn)最优时间复杂度O(n*logn)平均时间复杂度O(n*logn)最差空间复杂度О(n) total, O(1) auxiliary 1、堆的基础知识堆节点的访问通常堆是通过一维... 查看详情

七数组及其操作《2022solidity8.+版本教程到实战》(代码片段)

结构体结构体是一种可以自行定义的数据类型，其结构体内是复合的数据类型结构，当单一数据类型不能满足时可以使用创建所需结构体。结构体定义使用struct，例如以下示例：structHumanuintage;stringname;uintheight;以... 查看详情