数组
数组是一种容器类型，存放多个数据值。
特点
- 1.数组是一种引用数据类型
- 2.数组当中的多个数据，类型必须统一
- 3.数组的长度在程序运行期间不可改变
数组的初始化
在Java中将数组的创建叫做数组的初始化，在内存当中创建一个数组，并且向其中赋予一些默认值。
常见的俩种初始化方式：
- 1.动态初始化（指定长度）
- 2.静态初始化（指定内容）
动态初始化数组
基本格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
格式信息 | 解析含义 |
左侧数据类型 | 也就是数组当中保存的数据，全都是统一的什么类型 |
左侧的中括号 | 代表这是一个数组，而不是变量 |
左侧的数组名称 | 数组的名字 |
右侧的new | 代表创建数组的动作 |
右侧的数据类型 | 必须和左边的数据类型保持一致 |
右侧中括号的长度 | 也就是数组当中，到底可以保存多少个数据，是一个int数字 |
动态初始化代码演示：
public class Demo01ArraySetUp {
public static void main(String[] args) {
// 创建一个数组，存放300个int数据
// 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
int[] arrayA = new int[300];
// 创建一个数组，可以存放是10个double类型
double[] arrayB = new double[10];
// 创建一个数组，可以存放5个String类型
String[] arrayC = new String[5];
}
}静态初始化
在创建数组的时候，不直接指定数据个数的多少，而是直接将具体的数据内容进行指定。
基本格式：
数据类型[] 数据名称 = new 数据类型[] { 元素1, 元素2, …};
注意事项：
虽然静态初始化，没有直接告诉长度，但是根据打括号里面的元素具体内容，也可以自动推算出长度。
静态初始化标准格式代码演示：
public class Demo02ArraySetUp {
public static void main(String[] args) {
// 直接创建一个数组，里面全都是装的int数字
int[] arrayA = new int[] { 10, 100, 1000};
// 创建一个数组，用来装字符串
String[] arryB = new String[] { "Hello", "Java", "shuyv"};
}
}省略格式
数据类型[] 数据名称 = { 元素1, 元素2, …};
注意事项：
- 1.静态初始化没有直接指定长度，但是任然会自动推算的到长度。
- 2.静态初始化标准格式可以拆分成俩个步骤。
- 3.动态初始化同样也可以拆分成俩个步骤。
- 4.静态初始化一旦使用省略格式，就不可以拆分。
使用建议：
如果不确定数组当中的具体内容，用动态初始化。如果已经确定内容，使用静态初始化。
静态初始化省略格式代码演示：
public class Demo03ArraySetUp {
public static void main(String[] args) {
// 使用了静态初始化格式
int[] arrayA = { 10, 20, 30};
// 静态初始化标准格式可以拆分成俩个步骤
int[] arrayB;
arrayB = new int[] { 11, 22, 33};
// 动态初始化同样也可以拆分成俩个步骤
int[] arrayC;
arrayC = new int[5];
// 静态初始化一旦使用省略格式，就不可以拆分,编译器无法识别
// int[] arrayD;
// arrayD = { 1, 2, 3};
}
}数组的访问使用
访问数组元素的格式：
数组名称[索引值]
注意：索引值是从0开始的，一直到“数组的长度-1”为止。
代码演示：
public class Demo04ArrayUse {
public static void main(String[] args) {
// 静态初始化的省略格式
int[] arrayA = { 10, 20, 30};
// 直接打印数组名称，得到的结果是一个数组对应的内存地址哈希值。
System.out.println(arrayA); // [I@6956de9
System.out.println(arrayA[0]); // 10
int num = arrayA[1];
System.out.println(num); // 20
}
}使用动态初始化数组的时候，其中的元素自用会拥有默认的索引值，规则如下：
如果是整数类型，默认值：0
如果是浮点型，默认值：0.0
如果是字符类型（注意是字符类型），默认值：’\u0000’
如果是布尔类型，默认值：false
如果是引用类型，默认null
注意事项：
静态初始化也有默认值，只不过系统自动马上将默认值替换成为了大括号当中的具体默认值。
代码演示：
public class Demo05ArrayUse {
public static void main(String[] args) {
// 动态初始化一个数组
int[] arrayA = new int[3];
System.out.println(arrayA); // 内存地址哈希值
System.out.println(arrayA[0]); // 0
System.out.println(arrayA[1]); // 0
System.out.println(arrayA[2]); // 0
// 将数据123赋值交给数组arrayA当中的1号元素
// 重新赋值会将原本的数值覆盖掉
arrayA[1] = 666;
System.out.println(arrayA[1]); // 666
int[] arrayB = arrayA;
System.out.println(arrayB); // [I@6956de9
}
}Java中的内存划分
Java的内存需要划分成5个部分（简单说明）：
1.栈（Stack）：存放的都是方法中的局部变量。方法运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法{}中的变量。
作用域：一旦超出作用域，立刻从栈内存当中消失。
2.堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址，都在堆当中。
堆内存里面的数据，都有默认值。
规则：
如果是整数类型，默认值：0
如果是浮点型，默认值：0.0
如果是字符类型（注意是字符类型），默认值：’\u0000’
如果是布尔类型，默认值：false
如果是引用类型，默认null
3.方法区（Method Area）：存数.class相关信息，包含方法信息q
4.本地方法栈（Native Method Stack）：与操作系统相关。
5.寄存器（pc Register）:与CPU相关。
获取数组的长度
格式：
数组名称.length
代码演示：
public class Demo06ArrayLength {
public static void main(String[] args) {
// 动态初始化已经知道长度
int[] arrayA = new int[3];
// 静态初始化无法直接知道长度
int[] arrayB = {1, 2, 3, 4, 5, 6, 7, 8};
int len = arrayB.length;
System.out.println("arrayB数组的长度是：" + len);
// arrayB数组的长度是：8
// 注意数组一旦创建，程序运行期间，长度不可改变。
int[] arrayC = new int[3];
System.out.println(arrayC.length); // 3
arrayC = new int[5];
System.out.println(arrayC.length); // 5
}
}注意：数组一旦创建，程序运行期间，长度不可改变。
数组的遍历
利用循环即可做到遍历
代码演示：
public class Demo07ArrayBianLi {
public static void main(String[] args) {
int[] arrayA = { 10, 20, 30, 40 ,50, 60 };
// 循环打印输出
for (int i = 0; i < arrayA.length; i++) {
System.out.println(arrayA[i]);
}
}
}代码执行结果为：
10
20
30
40
50
60获取数组的最值
代码演示：
public class Demo08ArrayMax {
public static void main(String[] args) {
int[] array = {11, 22, 13, 17, 10, 99, 66};
int max = array[0];
// 遍历就是访问数组中的每一个元素，使用循环就OK
for (int i = 0; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
System.out.println(max); // 99
}
}练习：将数组中的元素进行反转
代码演示：
public class Demo09ArrayReverse {
public static void main(String[] args) {
int[] array = { 1, 2, 3, 4, 5 };
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
// 下面的循环做法确实使得数组结果反转了，但其实做法却是重新赋值而已
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
System.out.println("============================");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}代码执行结果为：
1
2
3
4
5
============================
5
4
3
2
1
Process finished with exit code 0数组可以作为方法的参数
代码演示：
public class Demo10ArrayParam {
public static void main(String[] args) {
int[] array = { 19, 20, 33, 23, 45, 66};
// 注意此除将数组作为参数传进去，其实传入的是数组的地址哈希值
printArray(array);
}
// printArray方法收到的参数也是数组的地址哈希值
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}代码执行结果为：
19
20
33
23
45
66注意：此除将数组作为参数传进去，其实传入的是数组的地址哈希值，printArray方法收到的参数也是数组的地址哈希值。
数组可以作为方法的返回值
任何数据类型都可以作为方法的参数类型，或者返回值。
数组作为方法的参数，传递进去的其实是数组的地址哈希值。
数组作为方法的返回值，返回的其实也是数组的哈希地址值。
代码演示：
public class Demo11ArrayReturn {
public static void main(String[] args) {
int[] result = calculate(10,20,30);
System.out.println("总和为：" + result[0]);
System.out.println("平均数为：" + result[1]);
System.out.println("接收到的返回值地址是：" + result);
}
// 注意这里为什么是int[],因为return返回值类型是一个数组
public static int[] calculate(int a, int b, int c) {
int sum = a + b + c; // 和
int avg = (a + b + c) / 3; // 平均数
// 使用动态初始化数组的方式来保存
// int[] arrayA = new int[2];
// array[0] = sum;
// array[1] = avg;
// 使用静态初始化数组的方式来保存
int[] arrayB = { sum, avg };
System.out.println("calculate方法内部的数组地址值是：" + arrayB);
// return arrayA;
return arrayB;
}
}代码执行结果为：
calculate方法内部的数组地址值是：[I@5e025e70
总和为：60
平均数为：20
接收到的返回值地址是：[I@5e025e70我们发现地址哈希值一样！！！
