数组
理解容器的概念
掌握数组的第一种定义方式
掌握数组的第二种定义方式
掌握数组的第三种定义方式
使用索引访问数组的元素
了解数组的内存图解
了解空指针和越界异常
掌握数组的遍历
掌握数组最大值的获取
了解数组反转的原理
了解数组作为方法参数传递
了解数组作为方法的返回值
1.1 数组的定义
数组(Array):是多个相同数据类型数据按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理。
数组定义: 数组就是存储相同数据类型的,长度固定的数据 的容器。
理解数组:
容器:是将多个数据存储到一起,每个数据称为该容器的元素。
生活中的容器:水杯,衣柜,教室
1.2数组相关的概念:
数组名:
元素:
角标/下标/索引
数组的长度:元素的个数
1.3数组的特点:
1.数组本身是引用数据类型,而数组中的元素尅是任何数据类型,包括基本数据类型和引用数据类型。
2.创建数组对象会在内存中开辟一整块连续的空间,而数组名中引用的是这块连续空间的首地址。
3.数组的长度一旦确定,就不能修改(长度在程序运行期间不可改变)。
4.我们可以直接通过下标(或索引)的方式调用指定位置的元素。速度很快。
1.4 数组的分类
按照维度:一维数组、二维数组、三维数组、…
按照元素的数据类型分:基本数据类型元素的数组,引用数据类型元素的数组(即对象数组)
1.5一维数组的使用
(1)一维数组的声明和初始化
(2)如何调用数组的指定位置的元素
(3)如何获取数组的长度
(4)如何遍历数组
(5)数组元素的默认初始化值
(6)数组内存解析
分割线----------------------------------------------------------------------------------------------
数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。
两种常见的初始化方式:
- 动态初始化(指定长度)
- 静态初始化(指定内容)
- 动态初始化数组的格式:
数据类型[] 数组名称 = new 数据类型[数组长度];
解析含义: 左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型 左侧的中括号:代表我是一个数组 左侧数组名称:给数组取一个名字 右侧的new:代表创建数组的动作 右侧数据类型:必须和左边的数据类型保持一致 右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字
方式一:动态初始化
格式:
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解:
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名 字操作数组。
new:关键字,创建数组使用的关键字。
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[长度]:数组的长度,表示数组容器中可以存储多少个元素。
注意:数组有定长特性,长度一旦指定,不可更改。
和水杯道理相同,买了一个2升的水杯,总容量就是2升,不能多也不能少。
举例:
定义可以存储3个整数的数组容器,代码如下:
int[] arr = new int[3];
方式二:静态初始化
格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
举例:int[] arr = new int[]{1,2,3,4,5};
定义存储1,2,3,4,5整数的数组容器。
代码演示数组初始化:
package com.fan.pojo;
public class ArrayTest {
public static void main(String[] args) {
//引入:在说一维数组的初始化之前。我们类比变量的声明和初始化
int num;//声明变量
num = 10;//变量的初始化
//或者这种一步到位的
int a = 100;//变量的 声明 + 初始化
//同样,数组的类似
int[] arr1;//声明
//1.静态初始化:数组的初始化和数组元素的赋值操作同时进行
arr1 = new int[]{1,2,3,4};
//2.动态初始化:数组的初始化和数组的赋值操作分开进行
String[] names = new String[5];
}
}
初始化方式三:省略初始化
格式:数据类型[] 数组名 = {元素1,元素2,元素3…};
举例:int[] arr = {1,2,3,4,5};
定义存储1,2,3,4,5整数的数组容器
总结三种定义方式:当带长度的时候,不能一起带数组的元素,当带数组元素的时候不能带数组的长度。
比较:
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};
1.6 数组的访问
索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引,有时候也叫下标或者角标;
(index),可以通过数组的索引访问到数组中的元素。
格式:数组名[索引]
数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为: 数组名.length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数组的最大索引值为 数组名.length-1 。
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性,输出结果是5
System.out.println(arr.length);
}
获取数组的长度
属性:length
//int[] arr1 = new int[]{1,2,3,4,5};
System.out.println(arr1.length);
数组的默认初始化值:
数组元素是整型(byte/short/int/long):0
数组元素是浮点型:0.0
数组元素是char型:0或者’\u0000’,而非’0’
数组元素是boolean型:false
数组元素是引用数据类型:null
一维数组的内存解析:
2.二维数组的使用
二维数组的理解:
我们可以画一张表格,一维数组的话,表格中只有一行;二维数组的话,表格中就有多行。也就是 我们可以看成一维数组arr又作为另一个一维数组arr2 的元素而存在。从数组的底层运行机制来看,其实没有多维数组的。
内存结构图理解:
2.1二维数组的初始化:
代码演示:
package com.fan.pojo;
public class ArrayTest {
public static void main(String[] args) {
//引入:先看一维数组的初始化
int[] arr = new int[]{1,2,3};//一维数组的初始化
//二维数组的初始化
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][4];
//动态初始化2:
String[][] arr3 = new String[3][];
//错误情况
//String [][] arr4 = new String[][4];
//String [4][3] arr5 = new String[][];
//int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
//真确写法:将[][]放到变量名后也可以,一维数组也有类似的写法
int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
}
}
2.2二维数组如何调用指定位置的元素和遍历
代码演示说明:
package com.fan.pojo;
public class ArrayTest {
public static void main(String[] args) {
//引入:先看一维数组的初始化
int[] arr = new int[]{1,2,3};//一维数组的初始化
//二维数组的初始化
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][4];
//动态初始化2:
String[][] arr3 = new String[3][];
//错误情况
//String [][] arr4 = new String[][4];
//String [4][3] arr5 = new String[][];
//int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
//真确写法:将[][]放到变量名后也可以,一维数组也有类似的写法
int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
//2.如何调用数组的指定位置的元素
System.out.println(arr1[0][1]);//arr1的第一行第二个元素:2
System.out.println(arr2[1][1]);//arr2数组的第二行第二列元素:null
arr3[1] = new String[4];//如果要不报错,需要添加这一行代码。并将地址给arr3[1]
System.out.println(arr3[1][0]);//运行报错:空指针异常,因为只是申请了三个元素的位置,但是每一个位置上没有东西。
//3.获取数组的长度
System.out.println(arr4.length);//3,其实就是外层数组的长度。即行数
System.out.println(arr4[0].length);//arr4[0]还是一个数组,是数组就有length属性。//3,即列数
System.out.println(arr4[1].length);//2,即{4,5}的元素的个数
//4.如何遍历二维数组:几维数组遍历就需要几个for循环
for (int i = 0; i < arr4.length ; i++) {
for (int j = 0; j < arr4[i].length; j++) {
System.out.println(arr4[i][j] + " ");
}
System.out.println();//换行
}
}
}
2.3二维数组的默认初始化
规定:二维数组分为外层数组的元素,内层数组的元素
int[] arr = new int[4][3];
//外层元素:arr[0],arr[1]等
//内层元素:arr[0][0],arr[1][2]等。
针对一初始化方式一:比如int[][] arr = new int[4][3];;
- 外层元素的初始化值为:地址值
- 内层元素的初始化值为:与一维数组初始化情况相同
针对于初始化方式二:比如:int[][] arr = new int[4][];
- 外层元素的初始化值为:null
- 内层元素的初始化值为:不能调用,否则报错,空指针异常。
代码演示说明:
package com.fan.pojo;
public class ArrayTest {
public static void main(String[] args) {
int[][] arr = new int[4][3];
System.out.println(arr[0]);//地址值:[I@5ebec15其中【代表是数组,I代表是int型,@后为位置
System.out.println(arr[0][0]);//0
System.out.println(arr);//[[I@6d06d69c
System.out.println("\n=======================");
//初始化方式一
String[][] arr2 = new String[4][2];//4行2列中每个元素先赋值为默认值null
System.out.println(arr2[1]);//地址值
System.out.println(arr2[1][1]);//null
System.out.println("\n========================");
//初始化方式二
double [][] arr3 = new double[4][];
System.out.println(arr3[1]);//null
//System.out.println(arr3[1][0]);//报空指针异常。因为我们没有给内层数组指定空间。
}
}
二维数组内存图解:
数组经典练习
1.利用二维数组打印杨辉三角。
package com.fan.pojo;
/*利用二维数组打印杨辉三角*/
public class ArrayTest {
public static void main(String[] args) {
int[][] arr = new int[10][];//动态赋值的一种方式
for (int i = 0; i < arr.length; i++) {
arr[i] = new int[i+1];//[i+1]内层数组元素的个数是不同的
for (int j = 0; j < arr[i].length; j++) {
if(j == 0 || i == j){//给第一列 赋值为1,给行列相等的位置也赋值为1
arr[i][j] = 1;
}else{//其他位置元素符合,当前元素 等于 头顶元素 + 头顶元素的前一个元素的 和
arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
}
}
}
//遍历输出赋值后的二维数组:
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
二分法查找:前提是:数组有序
package com.fan.pojo;
/*二分查找方法*/
public class ArrayTest {
public static void main(String[] args) {
//静态初始化,二分查找的前提是,数组必须有序,升序或者降序
int[] arr = new int[]{1,3,5,7,9,11};
//定义要查找的数key
int key = 99;
//定义开始索引和结束索引
int start = 0;
int end = arr.length - 1;
//设置是否找到的开关、旗帜,flag
boolean flag = false;
while (start <= end){
int middle = (start + end)/2;//在循环中,每次求出的中间索引
if(key == arr[middle]){//如果目标值等于 数组中间索引所对应的元素,则找到了
System.out.println("找到了"+key+",位置是:"+middle);
flag = true;
break;
}else if(arr[middle] > key){//假如中间数大于目标值,则在左半边找。右边界索引重置成 middle
end = middle - 1;//索引等一 middle的前一个索引
}else{//目标值在右边
start = middle + 1;//middle的后一个索引
}
}
//循环外判断开关
if(!flag){
System.out.println("没找到");
}
}
}
数组的排序
3.1 数组越界异常
创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运
行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一
旦出现了,就必须要修改我们编写的代码。
3.2 数组空指针异常
arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候
会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修
改我们编写的代码。
3.4 数组获取最大值元素(比武招亲)
最大值获取:从数组的所有元素中找出最大值。
实现思路:
定义变量,保存数组0索引上的元素
遍历数组,获取出数组中的每个元素
将遍历到的元素和保存数组0索引上值的变量进行比较
如果数组元素的值大于了变量的值,变量记录住新的值
数组循环遍历结束,变量保存的就是数组中的最大值
public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
//定义变量,保存数组中0索引的元素
int max = arr[0];
//遍历数组,取出每个元素
for (int i = 0; i < arr.length; i++) {
//遍历到的元素和变量max比较
//如果数组元素大于max
if (arr[i] > max) {
//max记录住大值
max = arr[i];
}
}
System.out.println("数组最大值是: " + max);
}
第四章 数组作为方法参数和返回值
数组作为方法参数传递,传递的参数是数组内存的地址。
数组作为方法的返回值,返回的是数组的内存地址
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;
}