目录
最近学习JAVA数组相关知识,写篇博客,作为学习笔记,以便查阅,主要从四个方面简介(0)数组为什么特殊?(1)数组简介 (2)一维数组,定义,声明,初始化,使用,内存分析,(3)二维数组,定义,声明·,初始化,使用,内存分析。(4)数组array类及其方法时使用,增删改查。数组中涉及到排序算法相关,如冒泡排序,最小二分法等相关在数据结构和算法中介绍,此处数组的应用只介绍数组中数据的增删改查。
(零)数组为什么特殊?
JAVA中有大量其他方式持有对象,那么,到底是什么使得数组与众不同呢?
数组与其他类型的容器之间的区别有三个方面:效率,类型和保存基本类型的能力,在Java中,数组是一种效率最高的存储和随机访问对象序列的方式,数组为简单的线性序列,这使得元素访问的速度非常快,但是这种速度所付出的代价为数组对象的大小固定,且其生命周期不可变。数组之所以优于泛型之类的容器,因为你可以创建一个数组去持有某个具体的类型,这意味着你可以通过编译器检查,防止插入错误信息和抽取不当类型。
那么,为什么要定义数组呢?
定义100个整型变量,其结构如下:
int i1, i2, i3, ... i100;
这样的定义方式非常麻烦,因为这些变量彼此之间没有任何的关联,当你要输出这100个变量的内容,意味着你要编写System.out.println()
语句100
次,或用for循环打印100次。
其实数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作,即为相同数据类型的集合,通过这样的方式来保存数据,以实现数据的增删改查。数组本身属于引用数据类型。
(一)数组概述
数组(Array),是多个相同类型数据按一定顺序排列 的集合,并使用一个名字命名,并通过编号的方式 对这些数据进行统一管理。数组中常用的概念有,数组名,下标,元素,和数组长度等。
- 数组本身是引用数据类型,而数组中的元素可以是任何数据类型,包括 基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间,而数组名中引用的是 这块连续空间的首地址。
- 数组的长度一旦确定,就不能修改。
- 我们可以直接通过下标(或索引)的方式调用指定位置的元素,速度很快。
- 数组的分类: 按照维度:一维数组、二维数组、三维数组、… ; 按照元素的数据类型分:基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)
数组的声明方式有两种,静态初始化和静态初始化
数组的静态初始化:
- 数据类型 [] 数组名称 =
new
数据类型[]{元素1,元素2,元素3,.....};如 int [] sa=new int[]{1,2.3};
数组动态初始化:
- 声明并开辟数组:
- 数据类型 [] 数组名称 =
new
数据类型[长度];如 int [] a=new int[5]; - 数据类型 数组名称[] =
new
数据类型[长度];如int a[]=new int[4];
- 数据类型 [] 数组名称 =
那么当数组开辟空间之后,就可以采用如下的方式的操作:
- 数组的访问通过索引完成,即:“数组名称[索引]”,如a[2] ; 数组的索引从
0
开始,索引的范围就是0
~ 数组长度-1
,例如开辟了3
个空间的数组,所以可以使用的索引是:0,1,2,如果此时访问的时候超过了数组的索引范围,会产生java.lang.ArrayIndexOutOfBoundsException
异常信息; - 当我们数组采用动态初始化开辟空间后,数组里面的每一个元素都是该数组对应数据类型的默认值;且每种数据类型都有其自身的默认值。
- 数组本身是一个有序的集合操作,所以对于数组的内容操作往往会采用循环的模式完成,数组是一个有限的数据集合,所以应该使用
for
循环。 - 在
Java
中提供有一种动态取得数组长度的方式:数组名称.length
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]); //通过循环控制索引
}
}
}
/*
输出结果为
10
20
30
*/
(二)一维数组
一维数组是由同一数据类型组成的数据集合。由一维数据组成,如下图:
(1)声明
一维数组的声明方式有两种:type var[] 或 type[] var,比如说 int a[];或int []a;
(2)初始化
初始化方式由两种,动态初始化和静态初始化。
- 动态初始化:数组声明且为数组元素分配空间与赋值的操作分开进行
- 静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
(3)引用
- 定义并用运算符new为之分配空间后,才可以引用数组中的每个元素;
- 数组元素的引用方式:数组名[数组元素下标]
- 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
- 数组元素下标从0开始;长度为n的数组合法下标取值范围: 0 —>n-1;如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
- 每个数组都有一个属性length指明它的长度,例如:a.length 指明数组a的长 度(元素个数)
- 数组一旦初始化,其长度是不可变的
(4)默认初始化值
数组是引用类型,它的元素相当于类的成员变量,因此数组一经 分配空间,其中的每个元素也被按照成员变量同样的方式被隐式初始化。如下程序,a[3]的默认初始化址为0;
public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}
通常而言,其他数据类型的默认值为:
(5)内存分析
Java中jvm内存简化图为
那么,对于如下程序,其运行过程为:
package strings;
/**
* Created with IntelliJ IDEA.
* User: yongping Li
* Date: 2020/11/14
* Time: 15:10
* Description: No Description
*/
public class Test{
public static void main(String args[]){
int[] s;
s = new int[10];
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
}
在int[] s; 在s = new int[10]处; 在s[i] =2*i+1;处:
对于如下程序,其内存分析为
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]);
}
}
}
内存分析:
int[] arr1 = new int[4];
arr1[0] = 10;
arr1[2] = 20;
String[] arr2 = new String[3];
arr2[1] = “刘杰”;
arr2 = new String[5];
内存分析:
int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = “刘德华”;
arr1[2] = “张学友”;
arr1 = new String[3];
sysout(arr1[1]);//null
内存分析:
一维数组程序代码示例:
package arrays;//: arrays/ArrayOptions.java
// Initialization & re-assignment of arrays.
import java.util.*;
public class ArrayOptions {
public static void main(String[] args) {
// Arrays of objects:
BerylliumSphere[] a; // Local uninitialized variable
BerylliumSphere[] b = new BerylliumSphere[5];
// The references inside the array are
// automatically initialized to null:
System.out.println("b: " + Arrays.toString(b));
BerylliumSphere[] c = new BerylliumSphere[4];
for(int i = 0; i < c.length; i++)
if(c[i] == null) // Can test for null reference
c[i] = new BerylliumSphere();
// Aggregate initialization:
BerylliumSphere[] d = { new BerylliumSphere(),
new BerylliumSphere(), new BerylliumSphere()
};
// Dynamic aggregate initialization:
a = new BerylliumSphere[]{
new BerylliumSphere(), new BerylliumSphere(),
};
// (Trailing comma is optional in both cases)
System.out.println("a.length = " + a.length);
System.out.println("b.length = " + b.length);
System.out.println("c.length = " + c.length);
System.out.println("d.length = " + d.length);
a = d;
System.out.println("a.length = " + a.length);
// Arrays of primitives:
int[] e; // Null reference
int[] f = new int[5];
// The primitives inside the array are
// automatically initialized to zero:
System.out.println("f: " + Arrays.toString(f));
int[] g = new int[4];
for(int i = 0; i < g.length; i++)
g[i] = i*i;
int[] h = { 11, 47, 93 };
// Compile error: variable e not initialized:
//!print("e.length = " + e.length);
System.out.println("f.length = " + f.length);
System.out.println("g.length = " + g.length);
System.out.println("h.length = " + h.length);
e = h;
System.out.println("e.length = " + e.length);
e = new int[]{ 1, 2 };
System.out.println("e.length = " + e.length);
}
} /* Output:
b: [null, null, null, null, null]
a.length = 2
b.length = 5
c.length = 4
d.length = 3
a.length = 3
f: [0, 0, 0, 0, 0]
f.length = 5
g.length = 4
h.length = 3
e.length = 3
e.length = 2
*///:~
运行结果为:
(三)二维数组
一维数组可以将其看成一行数据;如下图:
而二维数组可以将其看成为一个列表,如下图:
因此,二维数组可以将其看成两个一维数组的组合。
(1)声明及初始化
二维数组的初始化:
- 数组的动态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数];
- 数组的静态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数]{ {值, 值,…}, {值, 值,…},…};
(2)内存分析