数组
- 数组就是存储数据长度固定的容器，要保证多个数据的数据类型一致；
数组声明创建
note：数组有定长特性，长度一旦指定，不可更改；
方式一：
// 数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度]；
int[] nums = new int[10];//定义存储10个整数的数组容器
方式二：
//数据类型[] 数组名 = new 数据类型[]{元素1，元素2，……}
int[] nums = new int[]{1,2,3};
方式三：
数据类型[] 数组名 = {元素1，元素2，……}；
数组的访问
- 索引（index）：每个存储到数组的元素，都会自动拥有一个编号，从0开始
这个自动编号我们称索引。数组元素通过索引访问；
// 数组名[index];
//数组长度： 数组名.length
//取出素组元素：
System.out.println(nums[2]);
public static void main(String[] args) {
int[] nums;//声明一个数组
nums=new int[3];//创建一个数组
//------> int[] nums=new int[3];
nums[0]=1;//数组赋值
nums[1]=2;
nums[2]=3;
//------> int[] nums={1,2,3};
System.out.println(nums[2]);
}
数组的几个基本特点
-
长度确定，且不可更改；
-
数组元素可以是任何数据类型，包括基本类型和引用类型，但同一个数组中的元素必须是相同类型；
-
数组变量属于引用类型，数组可看作对象，数组中的每个元素就相当于该对象的成员变量；数组本身就是对象，Java中对象在堆中，所以数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
Java内存
| 区域名 | 作用 |
|---|---|
| 寄存器 | 给CPU使用，与我们无关 |
| 本地方法栈 | VM在使用操作系统功能时使用，与我们开发无关 |
| 方法区 | 存储可以运行的class文件，可被所有的线程共享，包含了所有的class和static变量 |
| 堆内存 | 存放new的对象和数组，可以被所有线程共享，不会存放别的对象引用 |
| 方法栈 | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行； 存放基本变量类型（包含该类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址） |
public static void main(String[] args) {
//静态初始化
int[] a={9,3,5,6,7};
System.out.println(a[0]);// 9
//动态初始化,包含默认初始化
int[] b=new int[3];
b[0]=10;
System.out.println(b[2]);//int型数据默认值为0
}
数组在内存中的存储
- 一个数组内存圈
public static void main(String[] args) {
int[] arr=new int[3];
//这里的arr只是有三个地址而已，它被称为引用数据类型
System.out.println(arr);//[I@3f3afe78
}
我们发现输出的结果是 [I@5f150435，这个是数组在内存中的地址，
new出来的内容，都是在堆内存中存储的，⽽⽅法中的变量array保存的是数组的
地址。
- 两个数组内存圈
public static void main(String[] args) {
int[] arr = new int[3];
int[] arr2 = new int[2];
System.out.println(arr);
System.out.println(arr2);
}
- 两个变量指向⼀个数组
public static void main(String[] args) {
// 定义arr数组，存储3个元素
int[] arr = new int[3];
//数组索引进⾏初始化赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);//5
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2，将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]); }
数组的几个常见异常
1.数组越界异常
public static void main(String[] args){
int[] arr={1,2,3};
System.out.println(arr[3]);//取出arr中第4个数----->越界
}
该数组的索引是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运⾏后，将会抛出
**ArrayIndexOutOfBoundsException **数组越界异常。
2.数组空指针异常
- NullPointerException
public static void main(String[] args) {
int[] arr = {1,2,3};
arr = null; // 变量arr将不会再保存数组的内存地址，此时不允许操作数组
System.out.println(arr[0]);// NullPointerException
}
- 空指针异常在内存图中的表现
数组的遍历使用
-
将数组中的每个元素分别获取出来，就是遍历
-
数组的索引是 0 到 lenght - 1 ，可以作为循环的条件出现。
public static void main(String[] args) {
int[] arr={1,2,3};
for (int i = 0; i < arr.length ; i++) {
//注意这里只能小于arr.length，如果等于，会有数组越界异常
System.out.println(arr[i]);
}
}
- // 数组遍历
public static void main(String[] args) {
int[] arr={1,2,3,45};
for (int i = 0; i < arr.length ; i++) {
System.out.println(arr[i]);
}
//计算总和
int sum=0;
for (int i = 0; i < arr.length ; i++) {
sum=sum+arr[i];
}
System.out.println(sum);
查找最大元素
-
最⼤值获取:从数组的所有元素中找出最⼤值。
-
实现思路:
-
定义初始元素变量，这里可以是数组0索引上的元素
-
遍历数组，获取出数组中的每个元素
-
将遍历到的元素和保存数组0索引上值的变量进⾏⽐较
-
如果数组元素的值⼤于了变量的值，变量记录住新的值
-
数组循环遍历结束，变量保存的就是数组中的最⼤值
int max=arr[0];
//遍历数组，取出每个元素
for (int i = 1; i < arr.length ; i++) {
//遍历到的元素和max比较
if (arr[i]>max){
max=arr[i];
}
}
System.out.println(max);
数组的反转
-
实现思想:实现反转，就需要将数组最远端元素位置交换
-
定义两个变量，保存数组的最⼩索引和最⼤索引；
-
两个索引上的元素交换位置；
-
最⼩索引++，最⼤索引–，再次交换位置；
-
最⼩索引超过了最⼤索引，数组反转操作结束。
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
/*
循环中定义变量min=0最⼩索引 max=arr.length‐1最⼤索引 min++,max‐‐
*/
for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐)
{ //利⽤第三⽅变量完成数组中的元素交换
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
// 反转后，遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4,5};
int[] result=reverse(arr);
printArray(result);
}
public static int[] reverse(int[] array){
int[] resule=new int[array.length];
for (int i=0,j=resule.length-1;i<array.length ;i++,j--){
resule[j]=array[i];
}
return resule;
}
public static void printArray(int[] array){
for (int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
}
数组作为⽅法参数
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7，9};
/* arr.for+回车// 遍历数组元素
for (int i : arr) {
}
*/
printArray(arr); // 调用方法，数组作为方法参数
}
// 打印数组元素
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
数组作为方法返回值
- 返回的是数组的内存地址
public static void main(String[] args) {
//调⽤⽅法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
/*
创建⽅法，返回值是数组类型
return返回数组的地址
*/
public static int[] getArray() {
int[] arr = { 1, 3, 5, 7, 9 }; //返回数组的地址，返回到调⽤者
return arr;
}
⽅法的参数类型区别
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a);
System.out.println(b);
change(a,b);
public static void change(int a, int b) {
a = a + b;
b = b + a;
}
public static void main(String[] args) {
int[] arr = {1,3,5};
System.out.println(arr[0]);
change(arr);
System.out.println(arr[0]);
}
public static void change(int[] arr) {
arr[0] = 200;
}
总结:
- ⽅法的参数为基本类型时,传递的是数据值.
- ⽅法的参数为引⽤类型时,传递的是地址值.
二维数组
public static void main(String[] args) {
int[][] arr = {{1,2} ,{2,3}, {3,0},{4,5} };
//4x2
/*
1，2 arr[0]
2，3 arr[1]
3，0 arr[2]
4，5 arr[3]
*/
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j <arr[i].length ; j++) {
System.out.print(arr[i][j]);
}
}
}
二维数组类似于往大箱子里面装小箱子，再往小箱子里面放一个“数值”
Arrays类
- Arrays类中的方法都是static修饰的静态方法，在使用时可直接使用类名调用，而不用“使用对象来调用”（是“不用“，不是“不能”）
具体方法可查看jdk帮助文档
public static void main(String[] args) {
int[] arr={1,3,4,7,8,96,34};
System.out.println(Arrays.toString(arr));// 打印数组元素 Arrays.toString
Arrays.sort(arr);// 数组排序（升序）
System.out.println(Arrays.toString(arr));
}
二维数组类似于往大箱子里面装小箱子，再往小箱子里面放一个“数值”
Arrays类
- Arrays类中的方法都是static修饰的静态方法，在使用时可直接使用类名调用，而不用“使用对象来调用”（是“不用“，不是“不能”）
具体方法可查看jdk帮助文档
public static void main(String[] args) {
int[] arr={1,3,4,7,8,96,34};
System.out.println(Arrays.toString(arr));// 打印数组元素 Arrays.toString
Arrays.sort(arr);// 数组排序（升序）
System.out.println(Arrays.toString(arr));
}
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
