目录
1.数组基本用法
1.1.什么是数组
1.2.数组声明
1.3.数组的创建与初始化
1.3.1.基本类型数组
1.3.2.对象数组
1.4.数组的使用
1.4.1.获取长度 & 访问元素
1.4.2.遍历数组
2.数组作为方法的参数
2.1.基本用法
2.2.内存
2.3.引用
2.4.初识 JVM 内存区域划分
2.5.参数传内置类型&参数传数组类型
3.数组作为方法的返回值
4.数组转字符串
4.1.使用JDK提供的工具类Arrays中的toString()方法
4.2.实现自己版本的数组转字符串
5.数组拷贝
5.1.全拷贝
5.1.1.使用JDK提供的类Arrays中的copyOf()方法
5.1.2.实现自己版本的数组全拷贝
5.2.部分拷贝
5.2.1.使用JDK提供的类Arrays中的copyOfRange()方法
5.2.2.实现自己版本的数组部分拷贝
6.多维数组
6.1.多维数组的声明
6.2.多维数组的实例化
6.2.1.直接为每一维分配内存，创建规则数组。
6.2.2.从最高维起，分别为每一维分配空间，创建不规则数组。
6.3.二维数组
数组是一种顺序表数据结构。它用一组连续的内存空间，是用于储存多个相同类型数据的集合。
数组的长度在创建时确定，并且在创建后不变。
如果需要建立存储不同类型数据的集合，或者要求这种数据存储结构的长度可以动态变化，可以使用java.util包中的各种集合(collection)类，如Vector等。
1.2.数组声明可以声明任何类型的数组，包括基本类型(char[] s)和类类型(Point[] p)的数组。
数组声明语句有两种格式：
数组声明中不指定数组长度。
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}; //是上一行的简化，二者实际是一样的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代码示例:打印数组内容
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)
程序计数器 (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] //表示输出的是一个数组对象的地址4.2.实现自己版本的数组转字符串什么是包?
程序开发不是从零开始，而是要站在巨人的肩膀上。
很多程序我们在写的过程中不必把所有的细节都自己实现，已经有大量的标准库(JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用。这些代码就放在一个一个的 "包" 之中。
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;
}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;
}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]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;
}Java中的多维数组可看作是数组的数组，即n维数组是n-1维数组的数组。
6.1.多维数组的声明要用多对[]表示数组的维数，一般n维数组要用n对[]。
6.2.多维数组的实例化 6.2.1.直接为每一维分配内存，创建规则数组。int a[][];
a = new int[4][4];
int a[][] = new int[2][]; //只有最后维可以不给值，其他都要给
a[0] = new int[10];
a[1] = new int[5];二维数组本质上是一维数组，不过每个元素又是一个一维数组。
基本语法
数据类型[][] 数组名称 = 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你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧