Java数组基础

1. 数组简介

1.1 概述

• 数组就是用来存储多个同类型元素的容器.
• 例如: 存储5个整数, 或者存储10个小数, 亦或者存储3个字符串等.

1.2 格式

动态初始化: 我们给定长度, 由系统给出默认初始化值.

 //格式一
 //数据类型[] 数组名 = new 数据类型[长度];
 
 //格式二
 //数据类型 数组名[] = new 数据类型[长度];

 //解释: 上述两种定义方式只是写法不同, 并无其他区别. 

静态初始化: 我们给定初始化值, 由系统指定长度. 

 //格式一
 //数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};      
 //这里可以有多个元素.
 
 //格式二 语法糖.
 //数据类型[] 数组名 = {元素1, 元素2, 元素3};
    
 //解释: 上述两种定义方式只是写法不同, 并无其他区别. 

1.3 示例: 定义数组

需求
1.	创建int类型的数组, 用来存储3个元素.
2.	创建int类型的数组, 存储数据11, 22, 33.
    
参考代码
public class ArrayDemo {
    public static void main(String[] args) {
        //1. 创建int类型的数组, 用来存储3个元素.
        //我们制定长度, 由系统给出默认值.
        //格式一:
        int[] arr1 = new int[3];		
        //推荐.
        //格式二:
        int arr2[] = new int[3];

        //2. 创建int类型的数组, 存储数据`11, 22, 33`.
        //我们直接传入元素, 由系统指定长度.
        //格式1
        int[] arr3 = new int[]{11, 22, 33};
        //推荐.
        //格式2
        int[] arr4 = {11, 22, 33};		
    }
}

1.4 数组各部分解释

此处以动态初始化举例:
数据类型[] 数组名 = new 数据类型[长度];

//例如:
int[] arr = new int[3];  
解释:
	数据类型: 指的是数组中存储元素的数据类型.
 	例如: 如果是int, 说明数组中只能存储int类型的数据, 如果是String, 则说明数组中只能存储字符串.
	[]: 表示是一个数组.
	数组名: 类似于之前定义的变量名, 要符合命名规范, 我们可以通过数组名来操作数组.
	new: 它是一个关键字, 表示用来创建数组对象的. 

1.5 数组的特点及基本用法

特点:
1.	数组中的每个元素都是有编号的, 且编号是从0开始的. 可以方便我们快速操作数组中的元素. 
 	解释: 编号也叫索引(这个是最常见的念法), 下标, 角标.   index
2.	数组中每个元素都有默认值. 
 	例如:
 	 1.	int类型数组, 元素默认值是: 0
 	 2.	double类型的数组, 元素默认值是: 0.0
 	 3.	boolean类型的数组, 元素默认值是: false
 	 4.	String类型的数组, 元素默认值是: null
         
基本用法
1.	通过数组名[索引]的形式, 可以快速获取数组中的指定元素.
 	//格式
数组名[索引]

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr[0]);	//打印结果是: 11
2.	通过数组名[索引] = 值;的方式, 可以修改数组中的指定元素值. 
 	//格式
数组名[索引] = 值;

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr[1]);	//打印结果是: 22
arr[1] = 222;
System.out.println(arr[1]);	//打印结果是: 222
3.	通过数组名.length的方式, 可以获取数组的长度.
 	//格式
数组名.length

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr.length);	//打印结果是: 3

2. 数组的内存图

2.1 内存解释

• 内存是计算机中的重要原件，也是临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

  即: Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

  JVM的内存划分

  1. 栈: 存储局部变量以及所有代码执行的.

  ​ 局部变量: 指的是定义在方法中, 或者方法声明上的变量.

  ​ 特点: 先进后出.

  2. 堆: 存储所有new出来的内容(即: 对象).

  ​ 特点: 堆中的内容会在不确定的时间, 被GC回收.

  3. 方法区: 存储字节码文件的.

  ​ 字节码文件: 指的是后缀名为.class的文件.

  4. 本地方法区:

  ​ 和系统相关, 了解即可.

  5. 寄存器

     和CPU相关, 了解即可.

2.2 案例一: 一个数组内存图

• 略.

2.3 案例二: 两个数组内存图

• 略.

2.4 案例三: 两个数组指向同一个对象

• 略.

3. 两个小问题

• 数组是我们在实际开发中用到的比较多的容器, 在使用它的时候, 很可能会遇到如下的两个问题:

  1. 数组索引越界异常(ArrayIndexOutOfBoundsException)

  2. 空指针异常(NullPointerException)

3.1 数组索引越界异常

• 产生原因

  访问了数组中不存在的索引.

  解决方案

  访问数组中存在的索引即可.

3.2 空指针异常

• 产生原因

  访问了空对象. 即: 对象为空, 你还去调用它的一些方法, 肯定不行.

  解决方案

  对对象赋具体的值即可.

4. 数组的常见操作

4.1 遍历数组

  需求:
  1.	定义int类型的数组arr, 存储元素11, 22, 33, 44, 55.
  2.	通过for循环, 遍历数组. 
      
  参考代码
  public class Array01 {
      public static void main(String[] args) {
          //1. 定义int类型的数组arr, 存储元素11, 22, 33, 44, 55.
          int[] arr = {11, 22, 33, 44, 55};
          //2. 通过for循环, 遍历数组. 
          for (int i = 0; i < arr.length; i++) {
              System.out.println(arr[i]);
          }
      }
  }

4.2 获取数组的最大值

需求:
求数组int[] arr = {5, 15, 2000, 10000, 100, 4000}的最大值.
 
参考代码
public class Array02 {
    public static void main(String[] args) {
        //求数组int[] arr = {5, 15, 2000, 10000, 100, 4000}的最大值.
        int[] arr = {5, 15, 2000, 10000, 100, 4000};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        System.out.println("数组的最大值为:" + max);
    }
}

4.3 反转数组

需求
1.	定义int类型的数组, 存储数据: 11, 33, 22, 55, 44.
2.	反转数组, 并打印反转后的结果. 
    
参考代码
public class Array03 {
    public static void main(String[] args) {
    //需求
    //1.	定义int类型的数组, 存储数据: 11, 33, 22, 55, 44.
    //2.	反转数组, 并打印反转后的结果.
        int[] arr = {11, 33, 22, 55, 44};
        for (int i = 0; i < arr.length / 2 ; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
    }
}