数组
一、数组的介绍
1、数组的概念：
（1）数组是存储同一数据类型的多个元素的集合，可以理解为一个容器
（2）数组既可以存储基本数据类型，也可以存储引用数据类型
回顾：基本数据类型：byte，short，int，long，float，double，char，boolean
引用数据类型：类（class）、接口（interface）、数组（[]）
2、数组的语句格式：
格式1：数据类型[] 数组名;
举例：int[] arr
格式2：数据类型 数组名[];
举例：int arr[]
3、注意事项：
（1）这两种定义，数组中是没有元素值的。
（2）针对于这两种定义数组的格式，推荐使用第一种。
（因为第一种的定义格式可读性更强。早期的时候很多人喜欢用第二种，
但是慢慢地发展，使用第一种的人越来越多了）
4、定义了一个数组，如果数组里面没有值，没有任何意义。要想使用它，就必须先做初始化
（1）初始化：为数组中地元素进行分配内存空间，并且为元素赋值。
（2）如何对数组的元素进行初始化呢?
①动态初始化：初始化时，只指定数组长度，由系统为数组分配初始值（先不赋值）
②静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度（先赋值）
5、数组中常见的两个报错
（1）ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
（2）NullPointerException
数组引用没有指向实体，却在操作实体中的元素时
二、动态初始化
1、动态初始化
（1）初始化时只指定数组长度，由系统为数组分配初始值。
（2）格式：
数据类型[] 数组名 = new 数据类型[数组长度]
（数组长度其实就是数组中元素的个数）
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值
2、单独使用是没有任何意义地，因为尚未初始化变量arr，未初始化之前不能使用
（未初始化之前若使用，执行时会报错）
如下：
public class ArrayDemo1 {
public static void main(String[] args) {
int[] arr; //定义一个数组，int类型地数组
System.out.println(arr);
}
}
3、
public class ArrayDemo1 {
public static void main(String[] args) {
int[] arr = new int[3];
/*
左侧：
int:说明数组的元素是int类型
[]：说明它是一个数组类型
arr: 给数组起的名字
右侧：
new: 代表为数组分配一个内存空间
int: 说明数组中的元素的数据类型是int类型
[]: 说明它是一个数组
3: 代表着数组的长度，其实就是数组元素的个数
*/
System.out.println(arr);
}
}
执行结果如下：
[I@1540e19d
Process finished with exit code 0
========================================================================
（1）解释说明：
[I@4554617c 代表地址值 十六进制的
（2）在实际编写代码的过程中，拿到地址值是没有任何意义的，我们大多数情况下
实际上是想获取数组的元素值；
数组里面提供了一个类似于编号的作用的东西，我们称之为索引（下标）
（3）如何通过索引获取数组中的元素呢？
语法格式：
数组的名称[索引]
注意事项：
①索引的编号是从0开始的，从左往右的顺序编号
②索引不能越界
=====================================================
获取数组中的元素如下代码所示：
public class ArrayDemo1 {
public static void main(String[] args) {
int[] arr = new int[3];//定义一个int类型的数组，长度位3
//（数组长度位3，其实就是数组的元素有3个）
System.out.println(arr[0]);//获取arr数组中的第一个元素
System.out.println(arr[1]);//获取arr数组中的第二个元素
System.out.println(arr[2]);//获取arr数组中的第三个元素
}
}
执行结果如下：
0
0
0
Process finished with exit code 0
======================================================================
（1）Java程序为了提高程序运行的效率，在内存中对数据进行了划分
具体划分了5个部分：
①栈：存储局部变量（方法中定义的变量称之为局部变量）
②堆：存储new出来的东西
③方法区：（后期会说到）
④本地方法区：（后期会说到）
⑤寄存器：（后期会说到）
（2）堆内存的特点：
①堆内存中放的都是new出来的东西
②每个变量都有一个系统给的默认值，根据数据类型不同，默认值也不同
byte,short,int,long 0
float,double 0.0
char '\u0000'
boolean false
引用数据类型 null
由（1）（2）可知，执行结果都是系统给的默认值0
4、定义一个int类型的数组，给数组中的元素赋值
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = new int[3]; //定义一个长度为3的int类型的数组
arr[0] = 10; //将10赋值给数组中的第一个元素
arr[1] = 20; //将20赋值给数组中的第二个元素
arr[2] = 30; //将30赋值给数组中的第三个元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
执行结果为：
[I@1540e19d
10
20
30
Process finished with exit code 0
5、定义两个int类型的数组，分别给数组中的元素赋值
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
int[] arr2 = new int[4];
arr2[0] = 44;
arr2[1] = 55;
arr2[2] = 66;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);//第4个元素没赋值，
//输出结果就默认为0
}
}
执行结果如下：
[I@1540e19d
11
22
33
[I@677327b6
44
55
66
0
Process finished with exit code 0
6、
定义两个数组，先定义一个数组，赋值，输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值，再次输出两个数组的名及元素
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = new int[3]; //定义第一个数组
arr[0] = 11; //赋值
arr[1] = 22; //赋值
arr[2] = 33; //赋值
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
定义第二个数组，把第一个数组的地址赋值给第二个数组
int[] arr2 = arr;
然后给第二个数组赋值，再次输出两个数组的名及元素。
arr2[0] = 100;
arr2[1] = 200;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
执行结果如下：
[I@1540e19d
11
22
33
[I@1540e19d
100
200
33
[I@1540e19d
100
200
33
Process finished with exit code 0
由此可见，将第一个数组的地址赋值给第二个数组之后，二者输出结果一样
三、静态初始化
1、静态初始化：指定每个数组元素的初始值，由系统决定数组长度。
2、静态初始化格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{11,12,13};
解释：
定义了一个int类型的数组，这个数组中可以存放3个int类型的值，
并且值分别是11,12,13
简化的写法：
int[] arr = {1,2,3};
3、静态初始化注意事项：
（1）大括号中值要和定义数组的时候数据类型要一致
（2）使用静态初始化的时候，右边的中括号中不允许出现数字
如果出现了，就意味着，定义的时候既有动态初始化，也有静态
初始化两者不能混淆
例：int[] arr1 = new int[5]{1,2,3,4,5};//错误
（3）当初始值不是0的时候，推荐使用静态初始化
4、静态初始化代码如下：
public class ArrayDome4 {
public static void main(String[] args) {
int[] arr = new int[]{1,3,5};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
或者
public class ArrayDome4 {
public static void main(String[] args) {
int[] arr = {1,3,5}; //静态初始化的简化格式
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
执行结果如下：
1
3
5
Process finished with exit code 0
四、数组遍历（依次输出数组中的每一个元素）
打印出数组中的每一个元素
方法1：使用顺序结构
public class ArrayDemo6 {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[8];
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
arr[3] = 44;
arr[4] = 55;
arr[5] = 66;
arr[6] = 77;
arr[7] = 88;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
}
}
方法2：使用for循环
public class ArrayDemo6 {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[8];
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
arr[3] = 44;
arr[4] = 55;
arr[5] = 66;
arr[6] = 77;
arr[7] = 88;
for(int i=0;i<8;i++){
System.out.println(arr[i]);
}
}
}
五、属性length的引入
1、由于我们上面的数组arr可以一眼就能数清有多少个元素，所以在循环的时候，可以确定一个范围但是呢，当我们数组中的元素有非常多的时候，这时候就不一定能数清了，如果有一个办法可以获取数组元素的个数就好了，java中的数组提供一个属性，可以让我们获取到数组的长度
2、这个属性的名字叫做：length
3、使用格式：
数组名称.length
4、例：利用属性获取数组中元素的个数：
public class ArrayDemo6 {
public static void main(String[] args) {
int[] arr = {1,2,3,67,78,90,67,45,67,89,12}
System.out.println(arr.length); //属性的使用
}
}
执行结果如下：
11
Process finished with exit code 0
即，利用属性求出数组中的元素个数为11
5、数组遍历引入属性
public class ArrayDemo5 {
public static void main(String[] args) {
int[] arr ={11，22，33，44，55，66，77，88};
//元素非常多时需要引入属性
for(int i =0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
六、数组遍历的包装（开发常用）
1、遍历的包装就是为了让依次输出的数值，排列更加的美观
2、例：这种情况输出都在一列，很难看
public class ArrayDemo6 {
public static void main(String[] args) {
//第1步：静态初始化，指定数组中元素的值
int[] arr = {1,2,34,56,45,24,56,76,5,666,7776,4456,1233,10};
//第2步：如果元素较多，使用属性获取元素的个数
System.out.println(arr.length); //有14个元素(arr.length是一个数)
//第3步：引入属性，并使用for循环遍历
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
================================================================
包装改进：
为了排列美观，我们需要让输出的元素在一行，而且两端加上[]，元素之间用逗号隔开
=================引入属性，使用for循环遍历==========================
public class ArrayDemo6 {
public static void main(String[] args) {
//第1步：静态初始化，指定数组中元素的值
int[] arr = {1,2,34,56,45,24,56,76,5,666,7776,4456,1233,10};
//第2步：如果元素较多，使用属性获取元素的个数
System.out.println(arr.length); //有14个元素
//第3步：引入属性，并使用for循环遍历
for(int i = 0;i<arr.length;i++){
if(i==0){
System.out.print("["+arr[i]);//给最左端加[
}else if(i==arr.length-1){ //给最右端加]
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+",");//依次输出，并且逗号隔开
}
}
}
}
执行结果如下：
14
[12,34,56,45,24,56,76,5,666,7776,4456,1233,10]
Process finished with exit code 0
=======================使用方法遍历=============================
public class ArrayDemo6_1 {
public static void main(String[] args) {
//第1步：静态初始化，指定数组中元素的值
int[] arr = {1,2,34,56,45,24,56,76,5,666,7776,4456,1233,10};
//第2步：如果元素较多，使用属性获取元素的个数
System.out.println(arr.length); //有14个元素(arr.length是一个数)
//第4步:调用方法,调用时方法里的名字要和初始化定义的一致
printArry(arr); //没有明确的返回值，可以单独调用
}
//第3步：新定义一个方法,起个名字叫printArry
//定义方法时，参数名字要和方法内部一致
public static void printArry(int[] arr1){
for(int i = 0;i<arr1.length;i++){
if(i==0){
System.out.print("["+arr1[i]);
}else if(i==arr1.length-1){
System.out.print(arr1[i]+"]");
}else{
System.out.print(arr1[i]+",");
}
}
}
}
七、获取数组数组中的最值
获取数组中的最大值最小值
分析： 1、定义一个数组，存储一些元素（使用静态初始化）
2、首先在数组中任意找一个元素进行比较，默认一开始它就是最大值
一般来说，我们取第一个（选择排序）
3、遍历其他的元素与第一个元素进行比较，如果找到了更大的元素，
就将它取代，如果比它小，不管它继续和后面比较
4、输出最大值
public class Array2Test2 {
public static void main(String[] args) {
int[] arr ={2,25,3,21,15,18,88,38,26};//定义一个一维数组
int max = arr[0]; //取第一个元素，定义为最大值
for(int i =1;i<arr.length;i++){
if(arr[i]>max){ //拿着这个定义的最大值与其他元素进行比较
max = arr[i]; //如果其他元素大于max，则其他元素为最大值
}
}
System.out.println(max); //在for循环外输出最大值
// 若在for循环内，则会打印每一个元素值
}
}