目录
4.1.使用JDK提供的工具类Arrays中的toString()方法
5.1.1.使用JDK提供的类Arrays中的copyOf()方法
5.2.1.使用JDK提供的类Arrays中的copyOfRange()方法
6.2.2.从最高维起,分别为每一维分配空间,创建不规则数组。
1.数组基本用法
1.1.什么是数组
数组是一种顺序表数据结构。它用一组连续的内存空间,是用于储存多个相同类型数据的集合。
数组的长度在创建时确定,并且在创建后不变。
如果需要建立存储不同类型数据的集合,或者要求这种数据存储结构的长度可以动态变化,可以使用java.util包中的各种集合(collection)类,如Vector等。
1.2.数组声明
可以声明任何类型的数组,包括基本类型(char[] s)和类类型(Point[] p)的数组。
数组声明语句有两种格式:
- 将表示数组的[]跟随在数组变量之后:int arr[];(C,C++,Java的标准格式)
- 将表示数组的[]跟随在数组类型之后:int[] arr;(Java特有,推荐使用)
数组声明中不指定数组长度。
1.3.数组的创建与初始化
1.3.1.基本类型数组
//动态初始化
数据类型[] 数组名称 = new 数据类型 [元素个数]; //定好其长度,此时数组中元素都是默认值0(只定义不初始化)
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
//静态初始化
数据类型[] 数组名称 = { 初始化数据 };
int[] arr = new int[3];
int[] arr = new int[]{1, 2, 3};
int[] arr = {1, 2, 3}; //是上一行的简化,二者实际是一样的
1.3.2.对象数组
Point p[];
//创建包含10个Point类型对象引用的数组
p = new Point[10];
//创建10个Point对象
for(int i = 0; i < 10; i++){
p[i] = new Point(i, i + 1);
}
数组创建后,其元素被系统自动进行初始化,不同类型的数组被初始化为不同的默认值。
1.4.数组的使用
1.4.1.获取长度 & 访问元素
int[] arr = {1, 2, 3};
// 获取数组长度
System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1
arr[2] = 100;
System.out.println(arr[2]); // 执行结果: 100
注:
1).使用 arr.length 获取数组的长度。("."这个操作为成员访问操作符,后面在面向对象中会经常用到)
2).使用 [ ] 按下标取数组元素。需要注意,下标从 0 开始计数。(数组索引(偏移量)从0开始,表示与数组中第一个元素的相对位置)
3).使用 [ ] 操作既能读取数据,也能修改数据。
4).下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常(抛出了 java.lang.ArrayIndexOutOfBoundsException 异常)
1.4.2.遍历数组
int[] arr = {1, 2, 3};
//使用for循环
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//使用for-each循环
for (int x : arr) {
System.out.println(x);
}
// 执行结果
1
2
3
2.数组作为方法的参数
2.1.基本用法
代码示例:打印数组内容
public static void main(String[] args) {
int[] arr = {1, 2, 3};
printArray(arr);
}
public static void printArray(int[] a) {
for (int x : a) {
System.out.println(x);
}
}
//执行结果
1
2
3
注:int[] a 是方法形参,int[] arr 是方法实参。
2.2.内存
内存可直观理解成一个宿舍楼。有一个长长的大走廊,上面有很多房间。
每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿个这样的房间)。
每个房间上面又有一个门牌号,这个门牌号称为地址。
2.3.引用
引用相当于一个 "别名",也可以理解成一个指针。
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。
null 在 Java 中表示 "空引用" ,表示一个无效的内存位置,不能对这个内存进行任何读写操作。一旦尝试读写,就会抛出 NullPointerException异常。Java 中并没有约定 null 和 0 号地址的内存有任何关联。
int[] arr = null; //表示arr不再指向任何地址
System.out.println(arr[0]);
// 执行结果 空指针异常
Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:6)
2.4.初识 JVM 内存区域划分
程序计数器 (PC Register): 一个很小的空间,保存下一条执行的指令的地址。
虚拟机栈(JVM Stack): 主要存储局部变量和引用。
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似,只不过保存的内容是Native方法的局部变量。在有些版本的 JVM 实现中(例如HotSpot),本地方法栈和虚拟机栈是一起的。空间比较小。
堆(Heap): 使用 new 创建的对象保存在堆上。是JVM所管理的最大内存区域。
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法编译出的的字节码就是保存在这个区域。
运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用。(从 JDK1.7 开始, 运行时常量池在堆上)
Native 方法:
JVM 是一个基于 C++ 实现的程序,在 Java 程序执行过程中,本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互。因此在 Java 开发中也会调用到一些 C++ 实现的函数。
这里的 Native 方法就是指这些 C++ 实现的,再由 Java 来调用的函数。
程序计数器,虚拟机栈,本地方法栈是每个线程具有一份;而堆,方法区,运行时常量池是整个 JVM 共享一个。
2.5.参数传内置类型&参数传数组类型
//参数传内置类型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
//执行结果:修改形参 x 的值,不影响实参的 num 值。
x = 10
num = 0
//参数传数组类型
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
a[0] = 100;
System.out.println("a[0] = " + a[0]);
}
//执行结果:在函数内部修改数组内容,函数外部也发生改变。
//此时数组名 arr 是一个 "引用",当传参的时候,是按照引用传参。
a[0] = 100
arr[0] = 100
针对 int[] arr = new int[]{1, 2, 3}:
a) new int[]{1, 2, 3} :在堆上创建了一块内存空间保存三个 int。(有new就有新空间)
b) int[] arr = new int[]{1, 2, 3} :在栈上创建了一个 int[] 变量arr。(引用类型,里面只保存了一个整数(数组的起始内存地址0x100))
c) int[] a = arr:进行传参,在栈上创建了一个 int[] 变量a。保存数组的起始内存地址0x100。
d) a[0] = 100:根据 0x100 地址找到对应的内存位置, 将值由1改成100。
此时已经将 0x100 地址的数据改成了 100 ,那么根据实参 arr 来获取数组内容 arr[0],本质上也是获取 0x100地址上的数据,也是 100。
总结: "引用" 本质上是存了一个地址,Java 将数组设定成引用类型,这样进行数组参数传参,就是将数组的地址传入到函数形参中。这样可以避免对整个数组的拷贝(数组可能比较长,那么拷贝开销就会很大)。
3.数组作为方法的返回值
代码示例: 写一个方法, 将数组中的每个元素都 * 2
//直接修改原数组
class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
transform(arr);
printArray(arr);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void transform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
}
//返回一个新的数组,不破坏原数组
class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] output = transform(arr);
printArray(output);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] transform(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i] * 2;
}
return ret;
}
}
由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效。
4.数组转字符串
4.1.使用JDK提供的工具类Arrays中的toString()方法
import java.util.Arrays; //包含了一些操作数组的常用方法
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
System.out.println(arr);
// 执行结果
[1, 2, 3, 4, 5, 6]
[I@1b6d3586] //表示输出的是一个数组对象的地址
什么是包?
程序开发不是从零开始,而是要站在巨人的肩膀上。
很多程序我们在写的过程中不必把所有的细节都自己实现,已经有大量的标准库(JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用。这些代码就放在一个一个的 "包" 之中。
4.2.实现自己版本的数组转字符串
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(toString(arr));
}
public static String toString(int[] arr) {
String ret = "[";
for (int i = 0; i < arr.length; i++) {
// 借助 String += 进行拼接字符串
ret += arr[i];
// 除了最后一个元素之外, 其他元素后面都要加上 ", "
if (i != arr.length - 1) {
ret += ", ";
}
}
ret += "]";
return ret;
}
5.数组拷贝
5.1.全拷贝
5.1.1.使用JDK提供的类Arrays中的copyOf()方法
import java.util.Arrays;
int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
//执行结果
newArr: [1, 2, 3, 4, 5, 6]
arr: [10, 2, 3, 4, 5, 6]
newArr: [1, 2, 3, 4, 5, 6]
新拷贝出来的数组和原数组指向的不是同一块内存空间。
相比于 newArr = arr 这样的赋值, copyOf 是将数组进行了深拷贝,即又创建了一个数组对象,拷贝原有数组中的所有元素到新数组中。因此,修改原数组,不会影响到新数组。
5.1.2.实现自己版本的数组全拷贝
public static int[] copyOf(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}
5.2.部分拷贝
5.2.1.使用JDK提供的类Arrays中的copyOfRange()方法
import java.util.Arrays;
int[] arr = {1,2,3,4,5,6};
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
//拷贝某个范围:arr是原数组引用,2是原数组开始索引,4是结束索引(左闭右开区间)
System.out.println("newArr2: " + Arrays.toString(newArr2));
//执行结果
newArr2: [3, 4]
5.2.2.实现自己版本的数组部分拷贝
public static int[] copyOfRange(int[] arr, int startIndex, int endIndex){
int[] ret = new int[endIndex - startIndex];
for(int i = startIndex; i < endIndex; i++){
//原数组和拷贝后的数组索引相差startIndex个索引
ret[i - startIndex] = arr[i];
}
return ret;
}
6.多维数组
Java中的多维数组可看作是数组的数组,即n维数组是n-1维数组的数组。
6.1.多维数组的声明
要用多对[]表示数组的维数,一般n维数组要用n对[]。
6.2.多维数组的实例化
6.2.1.直接为每一维分配内存,创建规则数组。
int a[][];
a = new int[4][4];
6.2.2.从最高维起,分别为每一维分配空间,创建不规则数组。
int a[][] = new int[2][]; //只有最后维可以不给值,其他都要给
a[0] = new int[10];
a[1] = new int[5];
6.3.二维数组
二维数组本质上是一维数组,不过每个元素又是一个一维数组。
基本语法
数据类型[][] 数组名称 = new 数据类型[行数][列数] {初始化数据};
代码示例
int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
// 执行结果
1 2 3 4
5 6 7 8
9 10 11 12