Java中数组的定义与使用详解

目录
  • 数组的基本概念
  • 数组引用传递
  • 数组静态初始化
  • 二维数组
  • 总结

数组的基本概念

如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下:

int i1, i2, i3, ... i100;

但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次。

其实所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型,那么既然是引用数据类型,这里面实际又会牵扯到内存分配,而数组的定义语法有如下两类。

  • 数组动态初始化:

    • 声明并开辟数组:

      • 数据类型 [] 数组名称 = new 数据类型[长度];
      • 数据类型 [] 数组名称 = new 数据类型[长度];
    • 分布进行数组空间开辟(实例化)

| Tables | Are |
| ------------- |:-------------?
| 声明数组: | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间: | 数组名称 =new` 数组类型[长度]; |

那么当数组开辟空间之后,就可以采用如下的方式的操作:

  • 数组的访问通过索引完成,即:“数组名称[索引]”,但是需要注意的是,数组的索引从0开始,所以索引的范围就是0 ~ 数组长度-1,例如开辟了3个空间的数组,所以可以使用的索引是:0,1,2,如果此时访问的时候超过了数组的索引范围,会产生java.lang.ArrayIndexOutOfBoundsException 异常信息;
  • 当我们数组采用动态初始化开辟空间后,数组里面的每一个元素都是该数组对应数据类型的默认值;
  • 数组本身是一个有序的集合操作,所以对于数组的内容操作往往会采用循环的模式完成,数组是一个有限的数据集合,所以应该使用 for 循环。
  • 在 Java 中提供有一种动态取得数组长度的方式:数组名称.length;

范例: 定义一个int型数组

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
		data[0] = 10; // 第一个元素
		data[1] = 20; // 第二个元素
		data[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过循环控制索引
		}
	}
}

数组本身除了声明并开辟空间之外还有另外一种开辟模式。

范例: 采用分步的模式开辟数组空间

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; /*开辟了一个长度为3的数组*/
		data[0] = 10; // 第一个元素
		data[1] = 20; // 第二个元素
		data[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过循环控制索引
		}
	}
}

但是千万要记住,数组属于引用数据类型,所以在数组使用之前一定要开辟控件(实例化),如果使用了没有开辟空间的数组,则一定会出现 NullPointerException 异常信息:

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		System.out.println(data[x]);
	}
}

这一原则和之前讲解的对象是完全相同的。

数组在开发之中一定会使用,但是像上面的操作很少。在以后的实际开发之中,会更多的使用数组概念,而直接使用,99%情况下都只是做一个 for 循环输出。

数组引用传递

既然数组属于引用数据类型,那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。

范例: 观察一道程序

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //开辟一个长度为3的数组
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
	}
}

那么既然说到了引用数据类型了,就一定可以发生引用传递,而现在的引用传递的本质也一定是:同一块堆内存空间可以被不同的栈内存所指向。

范例: 定义一个程序

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //开辟一个长度为3的数组
		int temp[] = null; //声明对象
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
		temp = data;  //int temp[] = data;
		temp[0] = 99;
		for(int i = 0; i < temp.length; i++) {
			System.out.println(data[i]);
		}
	}
}

引用传递分析都是一个套路。同一块堆内存被不同的栈内存所指向。

数组静态初始化

在之前所进行的数组定义都有一个明显特点:数组先开辟内存空间,而后再使用索引进行内容的设置,实际上这种做法都叫做动态初始化,而如果希望数组在定义的时候可以同时出现设置内容,那么就可以采用静态初始化完成。

数组的静态初始化一共分为以下两种类型:

Tables Are
简化格式: 数据类型 数组名称 = {值, 值,…}
完整格式: 数据类型 数组名称 = new 数据类型[] {值, 值,…}

TablesAre简化格式:数据类型 数组名称 = {值, 值,…}完整格式:数据类型 数组名称 = new 数据类型[] {值, 值,…}

范例: 采用静态初始化定义数组

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = {1, 2, 4, 545, 11, 32, 13131, 4444};
		for(int i = 0; i < data.length; i++) {
			System.out.println(data[i]);
		}
	}
}

在开发之中,对于静态数组的初始化强烈建议使用完整语法模式,这样可以轻松地使用匿名数组这一概念。

public class ArrayDemo {
	public static void main(String args[]) {
		System.out.println(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}.length);
	}
}

以后使用静态方式定义数组的时候一定要写上完整格式。

数组最大的缺陷:长度固定。

二维数组

在之前所使用的数组发现只需要一个索引就可以进行访问,那么这样的数组实际上非常像一个数据行的概念。

索引 0 1 2 3 4 5 6 7 8
内容 12 23 44 56 90 445 49 99 1010

现在痛过一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组,而二维数组本质上指的是行列集合,也如果要确定某一个数据需要行索引和列索引来进行定位。

索引 0 1 2 3 4 5 6 7 8
0 12 23 44 56 90 445 49 99 1010
1 2 3 41 56 9 45 49 99 10

如果要想确定一个数据则数据使用的结构是“数组名称[行索引][列索引]”,所以这样的结构就是一个表的结构。

那么对二维数组的定义有两种声明形式:

  • 数组的动态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数];
  • 数组的静态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};

数组的数组就是二维数组。

范例: 定义一个二维数组

public class ArrayDemo {
	public static void main(String args[]) {
		//此时的数组并不是一个等列数组
		int data[][] = new int[][] {
			{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
		//如果在进行输出的时候一定要使用双重循环,
		//外部的循环控制输出的行数,而内部的循环控制输出列数
		for(int i = 0; i < data.length; i++) {
			for(int j = 0; j < data[i].length; j++) {
				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
			}
			System.out.println();
		}
	}
}

于输出麻烦,所以可以忽略了,在进行开发之中,出现二位数组的几率并不高。

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Java中数组的定义和使用教程(三)

    数组排序 在很多的面试题上都会出现数组排序的操作形式.但是这个时候你千万别写上:java.util.Arrays.sort(数组).而这种排序都是以升序为主. 基础的排序操作: 范例: 冒泡排序 public class ArrayDemo { public static void main(String args[]) { int data[] = new int[] {9, 3, 1, 5, 4, 2, 7, 8, 6, 0}; sort(data); printArray(data); }

  • Java中数组的定义与使用

    目录 一.数组的基本用法 1.什么是数组 2.创建数组 3.数组的使用 二.数据作为方法参数 1.基本用法 2.理解引用类型 3.认识null 4.JVM内存区域划分 5.数组作为方法的返回值 6.关于数组的地址 四.数组练习 1.数组转字符串 2.数组拷贝 五.二维数组 1.二维数组的语法 2.二维数组的结构 3.用for-each遍历二维数组 总结 一.数组的基本用法 1.什么是数组 数组本质上就是让我们能 "批量" 创建相同类型的变量. 如果我们需要创建多个同一个类型的变量,则不

  • Java基础教程之数组的定义与使用

    目录 一.数组的基本概念 二.数组的声明 三.数组的创建及初始化 1.数组的创建 2.数组的初始化 四.访问数组元素 五.for each 循环 六.数组的拷贝 七.数组排序 八.二维数组 总结 一.数组的基本概念 数组是一种数据类型,用来存储同一类型值的集合,它在内存中是一段连续的空间.通过一个整形下标(index,或者称之为索引)可以访问数组中的每一个值.例如,如果a是一个整型数组,a[i]就是一个下标为i的一个整数,数组是一种引用类型. 二.数组的声明 声明数组变量时,需要指出数组类型(数

  • Java中数组的定义和使用教程(一)

    数组的基本概念 如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次. 其实所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作.数组本身属于引用数据类型,那么既然是引

  • Java中数组的定义和使用教程(二)

    数组与方法调用 数组是一个引用数据类型,那么所有的引用数据类型都可以为其设置多个栈内存指向.所以在进行数组操作的时候,也可以将其通过方法进行处理. 范例: 方法接受数组 public class ArrayDemo { public static void main(String args[]) { int data[] = new int[] {1, 2, 3}; printArray(data); } //定义一个专门进行数组输出的方法 public static void printArr

  • Java二维数组简单定义与使用方法示例

    本文实例讲述了Java二维数组简单定义与使用方法.分享给大家供大家参考,具体如下: Java的二维数组是先创建一个一维数组,然后该数组的元素再引用另外一个一维数组.在使用二维数组的时候,通过两个中括号[]来访问每一层维度的引用,直到访问到最终的数据. public class MultiDimArray{ /** * @param args */ public static void main(String[] args) { int[][] arr = new int[3][]; arr[0]

  • Java中数组的定义与使用详解

    目录 数组的基本概念 数组引用传递 数组静态初始化 二维数组 总结 数组的基本概念 如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次. 其实所谓的数组指的就是一组相关类型的变量集合,并且这些变

  • Java开发中synchronized的定义及用法详解

    概念 是利用锁的机制来实现同步的. 互斥性:即在同一时间只允许一个线程持有某个对象锁,通过这种特性来实现多线程中的协调机制,这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问.互斥性我们也往往称为操作的原子性. 可见性:必须确保在锁被释放之前,对共享变量所做的修改,对于随后获得该锁的另一个线程是可见的(即在获得锁时应获得最新共享变量的值),否则另一个线程可能是在本地缓存的某个副本上继续操作从而引起不一致. 用法 修饰静态方法: //同步静态方法 public synchronized

  • java中数组的定义及使用方法(推荐)

    数组:是一组相关变量的集合 数组是一组相关数据的集合,一个数组实际上就是一连串的变量,数组按照使用可以分为一维数组.二维数组.多维数组 数据的有点 不使用数组定义100个整形变量:int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义:int i[100];只是一个伪代码,只是表示含义的 一维数组 一维数组可以存放上千万个数据,并且这些数据的类型是完全相同的, 使用java数组,必须经过两个步骤,声明数组和分配内存给该数组, 声明形式一 声明一维数组:数据类型

  • java 中模式匹配算法-KMP算法实例详解

    java 中模式匹配算法-KMP算法实例详解 朴素模式匹配算法的最大问题就是太低效了.于是三位前辈发表了一种KMP算法,其中三个字母分别是这三个人名的首字母大写. 简单的说,KMP算法的对于主串的当前位置不回溯.也就是说,如果主串某次比较时,当前下标为i,i之前的字符和子串对应的字符匹配,那么不要再像朴素算法那样将主串的下标回溯,比如主串为"abcababcabcabcabcabc",子串为"abcabx".第一次匹配的时候,主串1,2,3,4,5字符都和子串相应的

  • Java 中泛型 T 和 ? 的区别详解

    目录 泛型中 T 类型变量 和 ? 通配符 区别 Generic Types 类型变量 用法 2.声明通用的方法 – 泛型方法: 有界类型参数 Wildcards 通配符 1.上界通配符:? extend 上界类型 2.无界通配符:? 3.下界通配符:? super 子类 类型擦除 泛型中 T 类型变量 和 ? 通配符 区别 定义不同 :T 是类型变量,? 是通配符 使用范围不同: ? 通配符用作 参数类型.字段类型.局部变量类型,有时作为返回类型(但请避免这样做) T 用作 声明类的类型参数.

  • Java postgresql数组字段类型处理方法详解

    在实际开发中遇到postgresql中定义的数组字段,下面解决两个问题,如何定义数组字段的默认值为空格数组,以及如何再java实体类中直接使用数组对象接受数据或把数据存入数据库. 1.在postgresql中定义数组对象及默认值 以字符串你数组为例: 比如一个字段用于存储多张图片的url,可以使用一下sql定义 pictures _varchar NOT NUll default ARRAY[]::character varying[] 2.实体类存入数组到数据库并接受数据库的数组数据 直接定义

  • java中Executor,ExecutorService,ThreadPoolExecutor详解

    java中Executor,ExecutorService,ThreadPoolExecutor详解 1.Excutor 源码非常简单,只有一个execute(Runnable command)回调接口 public interface Executor { /** * Executes the given command at some time in the future. The command * may execute in a new thread, in a pooled thre

随机推荐