（一维，二维）数组初始化、遍历；求数组中的最值问题、元素逆序、某个元素第一次出现的索引；冒泡排序

数组

可以存储多个元素的容器（多个元素必须是同一个数据类型）

格式：
数据类型 [ ] 数组名；例，int [ ] arr
数据类型 数组名 [ ]；例，int arr [ ]

数组初始化
动态初始化：具体数组中的元素值，由系统默认给定，数组长度由开发者定义！

格式：
数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ] ；
数据类型 数组名 [ ] = new 数据类型 [ 数组长度 ] ；
例，int [ ] arr = new int [ 3 ]；

静态初始化：由系统给定默认长度，开发者定义数组元素内容

格式：
数据类型 [ ] 数组名 = new 数据类型 [ ] {元素1，元素2，元素3…}；
数据类型 数组名 [ ] = new 数据类型 [ ] {元素1，元素2，元素3…}；
简写：
数据类型 [ ] 数组名 = {元素1，元素2，元素3…}；
例，
int [ ] arr = new int [ ] {1,2,3}；
int [ ] arr = {1,2,3}；

数组的遍历： 将数组中的元素依次输出出来

1.自定义数组
int [ ] arr = {1,2,3,4,5}；
2.数组中的属性：length；数组中最大索引值：arr.length-1；
代码体现：
for(int x = 0 ; x < arr.length ; x ++){
sop (arr [x] ) ; }

求数组中的最值

步骤：(这里以求最大值为例，求最小值同理)
1.自定义数组，静态初始化
2.定义一个参照物，默认数组中的第一个元素，arr [0]
3.将后面索引对应的元素遍历，获取到值之后，依次和参照物进行比较，如果后面的元素都比参照物大，将后面的元素赋值给前面的变量
4.输出数组中的最大值
代码体现：
int [ ] arr = {1,2,3,4,5}；
int max = arr [0];
for(int x = 1 ; x < arr.length ; x ++)
if(arr [x] > max)
max = arr [x] ;
sop (arr [x] );

数组元素逆序

方式一：
将0索引对应的元素和arr.length-1索引对应的元素互换；
将1索引对应的元素和arr.length-1-1索引对应的元素互换…到arr.length/2；
代码体现：
int [ ] arr = {1,2,3,4,5}；
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 ;
//接下来遍历数组，输出

方式二：
代码体现：
int [ ] arr = {1,2,3,4,5}；
for(int start = 0 , end = arr.length-1 ;start <= end ; start ++ , end --)
int temp = arr [start] ;
arr [start] = arr [end] ;
arr [end] = temp ;
//接下来遍历数组，输出

求一个元素在数组中第一次出现的索引

方式一：考虑如果该元素在数组中找不到，返回-1，-1代表该元素在数组中不存在
代码体现：
int [ ] arr = {1,2,3,4,5}；
int index = getIndex(arr , 5); //赋值调用
sop(index); //输出索引值
public static int getIndex(int [ ] arr , int value){ //定义获取索引值方法
for(int x = 0 ; x < arr.length ; x++){ //遍历数组
if(arr [x] == value){ //如果这个元素在数组中
return x ;} //返回x索引
}
return -1;} //不存在返回-1

方式二：假定该元素在数组中不存在 int index = -1 ;
int [ ] arr = {1,2,3,4,5}；
int index = getIndex(arr , 5); //赋值调用
sop(index); //输出索引值
public static int getIndex(int [ ] arr , int value){ //定义获取索引值方法
int index = -1 ;
for(int x = 0 ; x < arr.length ; x++){ //遍历数组
if(arr [x] == value){ //如果这个元素在数组中
index = x ;} //将索引x赋值给index
}
return index ;} //返回index

二维数组

由多个一维数组组成的数组

格式:
数据类型 [ ] [ ] 数组名；例，int [ ] [ ] arr
数据类型 [ ] 数组名 [ ]；例，int [ ] arr [ ]

二维数组初始化
动态初始化：系统默认给当前数组元素值

格式一：
数据类型 [ ] [ ] 数组名 = new 数据类型 [m] [n]；
例,
int [ ] [ ] arr = new int [3] [2]；
解析：
int [ ] [ ]：定义了一个int类型的二维数组
arr：数组名称
new：在堆内存中开辟空间
[3]：当前二维数组中有3个一维数组
[2]：每一个一维数组中有两个元素

格式二：
数据类型 [ ] [ ] 数组名 = new 数据类型 [m] [ ]； m表示一维数组的长度；
例，
int [ ] [ ] arr = new int [3] [ ]；
这种一维数组中的具体的元素动态给定

静态初始化：由开发者定义数组元素内容

格式：
数据类型 [ ] [ ] 数组名 = new 数据类型 { {元素1，元素2…}，{元素3，元素4…}，{元素5，元素6…} }；
例，
int [ ] [ ] arr = new int [ ] [ ] { {1,2,3}，{4,5,6}，{7,8,9} }；
简写：
数据类型 [ ] [ ] 数组名 = { {元素1，元素2…}，{元素3，元素4…}，{元素5，元素6…} }；
例，
int [ ] [ ] arr = { {1,2,3}，{4,5,6}，{7,8,9} }；

二维数组遍历

代码体现：
int [ ] [ ] arr = { {1,2,3}，{4,5,6}，{7,8,9} }；
for（int x = 0 ；x < arr.length ；x ++）
for（int y = 0 ；y < arr [x].length ；y ++ ）
sop（arr [x] [y] ）；

冒泡排序
思路：两个两个比较，打的值往后放，第一次比较完后，最大值出现在最大索引处，依次这样比较得到排好序的数组；

代码体现：
int [ ] arr = {1,2,3,4,5}；
for（int x = 0 ；x < arr.length-1 ；x ++）
for（int y = 0 ；y < arr.length-1-x ；y ++）
if（arr [y] > arr [y+1]）
int temp = arr [y]；
arr [y] = arr [y+1]；
arr [y+1] = temp；
//接下来遍历，输出