一维数组
概念:是一种"容器",可以存储同一类型元素的容器.
定义:
数据类型[] 数组名称
数据类型 数组名称[]
数组的初始化:
动态初始化:开发者定义数组初始化的时候,指定数组的长度,系统默认给数组中的元素赋值.
静态初始化:直接指定数组的元素内容,系统指定的数组长度
数组的动态初始化
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
举例:
定义一个数组并且动态初始化
int[] arr = new int[3] ;
int arr[] = new int[3] ;
=号左边:
int:数组中的存储的是基本类型int类型元素
[]:表示一个一维数组
arr:表示数组的对象名称
=号右边:
new :在堆内存中产生一个空间地址(申请空间)
int:数组中的存储的是基本类型int类型元素
[]:表示一个一维数组
3:指定数组的长度
举例:
class ArrayDemo{
public static void main(String[] args){
//创建一个数组对象,并且动态初始化
int[] arr = new int[3] ;
System.out.println(arr);
//[I@6d06d69c 组成:[表示一个维数组 I(int类型) @:表示地址值标记 后面就是一堆十六进制数据
//打印一个数组名称:产生一个地址值, 如何确定元素的内容:
/*
访问数组的元素:
给数组中的元素进行编号,从0开始编号,一直到 取到数组的最大长度-1为止
将编号以及数组名称配合使用:
数组名称[索引值(数组的角标)]
*/
arr[1] = 100 ;
//数组动态初始化 int[] arr = new int[3] ; 指定数组长度,系统默认给元素进行分配(默认值)
System.out.println(arr[0]) ;//输出数组内的第一个元素
System.out.println(arr[1]) ;//输出数组内的第二个元素
System.out.println(arr[2]) ; //输出数组内的第三个元素
}
}
数组的静态初始化
指定的元素的内容,系统默认长度!
静态的初始化的格式:
标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3,} ;
简写方式:(推荐)
数据类型[] 数组名称 = {元素1,元素2,元素3,} ;
数据类型 数组名称[] = {元素1,元素2,元素3,} ;
int[] arr = new int[]{1,2,3} ;
int[] arr = {1,2,3} ;
注意:
int[] arr = new int[2]{10,20} ; 是错误的,动态初始化和静态初始化一块使用了!
class ArrayDemo{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {7,8,9,10} ;
System.out.println(arr) ;
System.out.println(arr[0]) ;
System.out.println(arr[2]) ;
System.out.println(arr[3]) ;
}
}
数组中的异常
数组中会遇见的一些异常:
异常:Throwable 类
异常分为两大类:
Error:程序出现了严重的问题;
Exception:
RuntimeException:运行时期异常
java.lang.ArrayIndexOutOfBoundsException属于运行时期异常的一种
java.lang.NullPointerException属于运行时期异常的一种
编译时期异常(只要不是RuntimeException的异常都属于编译时期)
java.lang.ArrayIndexOutOfBoundsException:属于运行时期异常的一种
数组角标越界异常
出现的原因:访问了数组中不存在的角标值
解决方案:更改角标在范围内即可!
java.lang.NullPointerException:空指针异常(引用类型中经常会出现的异常!)
出现的原因:
代码结构不严谨(某个对象已经为null,还有使用这个对象调用方法或者访问元素...)
解决方案:
只要 给对该对象进行非空判断
如果该对象不为空,才能使用这个对象完成一些操作!
class ArrayAbnormal{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {1,2,3} ; //new int[]{1,2,3} ;
System.out.println(arr[0]);
System.out.println(arr[1]);
//该数组最大的角标值是2
//System.out.println(arr[3]); //java.lang.ArrayIndexOutOfBoundsException :数组角标越界
//引用类型的默认值是null
//arr = null ;
//System.out.println(arr[0]) ; //java.lang.NullPointerException:空指针异常
arr = null ;
//加入一个逻辑判断:非空判断
if(arr!=null){
System.out.println(arr[0]) ;
}else{
System.out.println("该对象为空了,不能再使用这个对象了") ;
}
}
}
数组的应用
数组的遍历
将数组的元素进行遍历
遍历:就是将元素的内容一一输出出来!
class ArrayTest{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {57,69,80,13,22} ;
//如何访问数组中的元素:数组名称[索引值]
//调用
//将数组中的数据遍历出来
printArray(arr);
//需求:遍历arr数组,最终以 [元素1, 元素2, 元素3, ....元素n]格式出现 变成功能
printArray2(arr) ;
}
//最终版代码:遍历数组
public static void printArray2(int[] array){
//拼接左中括号
System.out.print("[") ;
//遍历array数组
for(int x = 0 ; x < array.length; x ++){//x角标
//获取到每一个元素
//判断:如果x取到最大索引值,---->取到最后一个元素了
if(x==array.length-1){
//最后一个元素,输出元素内容以及右中括号
System.out.println(array[x]+"]") ;
}else{
//不是取到最大索引值,将中间的元素按照按照格式输出(元素+逗号+空格)
System.out.print(array[x]+", ") ;
}
}
}
/*
遍历的功能
定义一个方法
两个明确
1)明确返回值类型:void
2)明确参数类型以及参数格式
int类型的数组 1个参数
*/
public static void printArray(int[] array){//方法的形式参数:传递的是一个引用类型:数组
for(int x = 0 ; x < array.length ; x ++){
System.out.println(array[x]) ;
}
}
}
求数组的最大值
求数组中最大值/最小值
分析:
1)定义数组,静态初始化
2)定义一个参照物,数组中的第一个元素(它就是一个最大值)
3)从角标1遍历后面的元素,获取到每一个元素
判断:
如果后面的元素都大于max了,
将该元素赋值max
4)输出max值
举例:
class ArrayTest2{
public static void main(String[] args){
//1)定义数组,静态初始化
int[] arr = {57,69,80,13,22} ;//new int[]{57,69,80,13,22} ;
//定义一个参照物
int max = arr[0] ;
//遍历后面的元素:从索引1开始
for(int x =1 ; x < arr.length ; x ++){
//判断 如果后面的元素都大于max了,
if(arr[x] > max){
//将该元素赋值max
max = arr[x] ;
}
}
System.out.println("数组中的最大值是:"+max);
System.out.println("---------------------");
//赋值调用
int max2 = getMax(arr) ; //调用这个方法,实际参数需要:该数组对象
System.out.println("max2:"+max2) ;
//最小值:自己完成!
}
//定义一个获取数组最大值的方法
/*
两个明确
1)明确返回值类型: int类型
2)参数类型以及参数个数
int类型的数组 1个参数
*/
public static int getMax(int[] array){ //形式参数传递的是一个数组,方法调用,实际参数需要改数组的对象
//定义一个参照物
int max = array[0] ;
//遍历后面的元素:从索引1开始
for(int x =1 ; x < array.length ; x ++){
//判断 如果后面的元素都大于max了,
if(array[x] > max){
//将该元素赋值max
max = array[x] ;
}
}
return max ;
}
}
元素的逆序
元素逆序:
特点:
arr:是一个数组
将0索引对应的元素和arr.length-1索引对应的元素进行互换
将1索引对应的元素和arr.length-1-1索引对应的元素进行互换
...
...
只要保证 数组长度 arr.length/2
举例:
class ArrayTest3{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {57,87,96,13,24} ;
//在逆序之前,先去遍历这个数组(将元素一一打印)
System.out.println("逆序之前:") ;
printArray(arr) ;
//逆序
//调用逆序的功能
reverse(arr) ;
reverse2(arr) ;
//遍历一下
System.out.println("逆序后:");
printArray(arr) ;
}
//方式2
public static void reverse2(int[] arr){
//在一个for循环中定义一个两个变量
//start:表示开始索引
//end:最终最大索引
for(int start = 0,end = arr.length -1 ; start<=end ;start ++,end -- ){
//中间第三方变量
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
/*
定义一个逆序的功能
两个明确:
1)明确返回值类型:void
2)明确参数类型以及参数个数
int类型的数组 1个参数
*/
//方式1;
public static void reverse(int[] arr){
//将0索引对应的元素和arr.length-1索引的元素进行互换
for(int x = 0 ; x < arr.length/2; x ++){
//进行互换
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ;
arr[arr.length-1-x] = temp ;
}
}
//遍历的功能
public static void printArray(int[] arr){
//先拼接左中[
System.out.print("[") ;
for(int x = 0 ; x < arr.length ; x ++){
//如果角标是最大索引值:最后一个元素
if(x==arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ") ;
}
}
}
}
二维数组
定义:一个元素为一维数组的数组
定义格式:
数据类型[] 数组名称[] ;
数据类型[][] 数组名称 ;
动态初始化:
格式1:
数据类型[][] 数组名称 = new 数据类型[m][n] ;
举例:
int[][] arr = new int[3][2] ;
=号左边:
int:当前数组存储的是int类型的元素
[][]:定义的是一个二维数组
arr :数组对象名称
=号右边:
new :在堆内存中创建该数组的对象(产生堆内存空间地址)
int:当前数组存储的是int类型的元素
[3]:当前定义的这个二维数组中有3个一维数组
[2]:每一个一维数组中有2个长度
举例:
class ArrayDemo{
public static void main(String[] args){
//格式1:
int[][] arr = new int[3][2] ;
System.out.println(arr);//[[I@6d06d69c 输出整个二维数组
System.out.println(arr[0]) ;//[I@7852e922输出第一个一维数组
System.out.println(arr[1]) ;//[I@4e25154f输出第二个一维数组
System.out.println(arr[2]) ;//[I@70dea4e输出第三个一维数组
System.out.println(arr[0][1]) ; //输出第一个一维数组里的第二个元素
System.out.println(arr[1][1]) ; //输出第二个一维数组里的第二个元素
arr[0][1] = 10;
arr[0][0] = 20 ;
arr[1][1] = 40 ;
System.out.println("-----------------------") ;
System.out.println(arr);//[[I@6d06d69c
System.out.println(arr[0]) ;//[I@7852e922
System.out.println(arr[1]) ;//[I@4e25154f
System.out.println(arr[2]) ;//[I@70dea4e
System.out.println(arr[0][1]) ;
System.out.println(arr[1][1]) ;
}
}
格式2:
指定了一维数组的个数,一维数组的长度需要动态给定
数据类型[][] 数组名称 = new 数据类型[m][] ;
举例:
int[][] arr = new int[3][] ;
举例:
class ArrayDemo{
public static void main(String[] args){
//格式2:
int[][] arr = new int[2][] ;
//二维数组中有2个一维数组,长度不知道,得动态给定长度
System.out.println(arr) ;//二维数组的地址值[[I@十六进制数据 //[[I@6d06d69c
//动态给定义2个一维数组的长度
arr[0] = new int[2] ; //第一个一维数组给定了2个长度
arr[1] = new int[3] ;//第二个一维数组给定了3个长度
System.out.println(arr[0]) ; //[I@7852e922
System.out.println(arr[1]) ;//[I@4e25154f
System.out.println(arr[0][1]) ;
System.out.println(arr[1][0]) ;
System.out.println(arr[1][2]) ;
//赋值
arr[0][0] = 10 ;
arr[0][1] = 20 ;
arr[1][1] = 50;
arr[1][2] = 40 ;
}
格式3:
就是静态初始化
数据类型[][] 数组名称 =
new 数据类型[][]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
简写格式:
数据类型 [][] 数组名称 = {{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
举例
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
-->简写格式
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;
二维数组的应用
遍历
外层循环:其实是一维数组的个数(arr.length)
内层循环:其实每一个一维数组的长度(arr[x].length)
最终让你以:{{1,2,3},{4,5},{6}}按照这个格式
class Array2Test{
public static void main(String[] args){
//定义一个二维数组,静态初始化:
int[][] arr = {{1,2,3},{4,5},{6}};
//调用遍历的功能
printArray2(arr) ;
}
public static void printArray2(int[][] arr){
//输出以下左大括号
System.out.print("{");
//遍历
for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
//先输出左大括号
System.out.print("{");
//遍历一维数组的元素
for(int y = 0 ; y < arr[x].length ; y++){
//判断
//如果是二维数组的最后一个元素
if(x == arr.length-1){
//输出元素值以及后面的}
System.out.print(arr[x][y]+"}") ;
//如果当前元素取到的一维数组的最后一个元素
}else if(y == arr[x].length-1){
//输出元素内容以及}以及,
System.out.print(arr[x][y]+"}"+",") ;
}else{
System.out.print(arr[x][y]+",") ;
}
}
}
//输出整个右}
System.out.print("}");
}
}
149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
