数组的概念

数组是相同类型的数据按顺序组成的一种引用数据类型。

数组的规范

  • 存放的数据是相同的数据类型
  • 数组的长度在定义时就确定了大小，数组是不可变长度的，或者说叫定长
  • 数组中可以存放任意的数据类型（包含基本数据类型、引用数据类型、数组）
  • 数组本身是引用数据类型（在栈内存中会存储其在堆内存中的引用地址）
  • 数组会在内存中开辟一块连续的内存空间

一维数组

定义方式

数据类型[] 变量名;

  1. int[] arr;

数组的初始化

在 Java 语言中，数组必须先被初始化，才能被使用。所谓的初始化，对于基本数据类型来说，就是赋值，对于引用数据类型，就是在内存中为数组元素分配空间，并为每个元素赋予初始值。

静态初始化

显式的指定每个数组元素的值，由系统来决定数组的大小。

  1. type[] arrayName = {element1, element2,....}; 
  2. type[] arrayName = new type[]{element1, element2,...};

该初始化方法，首先定义了数组的内容，同时也根据数组中内容的个数，决定了数组的长度。

动态初始化

数据类型[] 数组名= new 数据类型[数组长度];

  1. int[] arr = new int[10];
  2. int[] arr;
  3. arr = new int[10];//表示我们创建了一个长度为10的整型数组

该初始化方法，首先定义了数组的长度，同时根据数据类型的默认值，来暂时确定了数组的内容。

注：数组声明和初始化分开的时候，需要借助new关键字。

  1. int[] arr;
  2. arr = new int[]{1,2,3};

数组的长度

数组名.length

  1. int[] a = new int[5];
  2. System.out.println(a.length);//输出5

数组在内存中的存储与默认值

image.png
前面我们说到数组的长度在初始化时就固定了，不可改变，但从上图中，我们发现数组的长度好像改变了？
这里就要说到数组在内存中的存储方式。
image.png
数组初始化会在堆内存中建立连续的空间用来存储数组内容，在栈内存中会建立一个空间用来存储数组名和堆中地址，new关键字的效果就是另开辟一个新的空间，此时也会有一个新的地址，次地址会替换掉原来的地址。

循环与数组

普通循环

通过数组索引方式对数组元素进行赋值时，使用数组.length属性作为 for 循环的条件。
在对数组元素进行操作时，一般使用 for 循环结构。

  1. for (int i = 0; i < arrs3.length; i++) {
  2.     arrs3[i] = (i+1) * 10;
  3. }
  5. for (int i = 0; i < arrs3.length; i++) {//注意不要犯数组越界的错误
  6.     System.out.println(arrs3[i]);
  7. }

数组越界:数组的长度是固定的，输出超出数组长度的不存在的值，就是数组越界了。

增强型for循环

增强型for循环又叫foreach循环

  1. for (数据类型 变量名 : 数组名| 集合名) {
  2.     element...
  3. }
  5. for(int a : arrs3) {
  6.     System.out.println(a);
  7. }

注：使用 foreach 一般情况下，只用作遍历数据，如果要对数组中元素进行修改，还是需要使用 for 循环带索引的方式进行，因为在上述的代码中，a 只是循环元素的一个副本。

冒泡排序

思考：如何交换a和b的数值。

  1. int a = 2,b = 3;
  2. int temp;
  3. temp = a;
  4. a = b;
  5. b = temp;

冒泡排序的思路：
image.png
对如上一组数组进行从小到大的排序，

  1. 首先对数组中相邻的两个数进行比较，把数组元素从头到尾比较一次以后，我们希望能找出最大的那个值，放到数组的末尾。
  2. 第二次进行比较的时候，找出第二大的值，放到数组的倒数第二位。
  3. 随后进行第三次直到n次比较完成。

image.png

  1. //冒泡排序法生成从小到大的排序方式
  2. public class MaoPaoDemo {
  3.     public static void main(String[] args) {
  4.         int[] mina = { 34, 42, 33, 45, 6, 7 };
  5.         System.out.println("排序前的内容是：");
  6.         for (int n : mina) {
  7.             System.out.print(n + " ");
  8.         }
  9.         int temp;
  10.         for (int i = 0; i < mina.length - 1; i++) {
  11.             for (int n = mina.length-1; n > i; n--) {
  12.                 if (mina[n] < mina[n - 1]) {
  13.                     temp = mina[n - 1];
  14.                     mina[n - 1] = mina[n];
  15.                     mina[n] = temp;
  16.                 }
  17.             }
  18.         }
  19.         System.out.println( '\n'+ "排序后的内容是：");
  20.         for (int j : mina) {
  21.             System.out.print(j+" ");
  22.         }
  23.     }
  24. }
  1. 冒泡排序从前往后排
  2. public class MaoPaoDemo {
  3.             int[] mina = { 34, 42, 33, 45, 6, 7 };
  4.             int temp;
  5.       //利用外部一个大的循环去确立总共要执行多少次排序
  6.       for(int i = 0; i < mina.length - 1; i++) {
  7.           //内部循环比较元素，每一次大循环结束后，都有一个元素被确立为最大值不比较
  8.           for(int j = 0;j < mina.length-1-i;j++) {
  9.                 //如果排在前面的元素大于后面的元素，相互对调
  10.             //也就是从小到大
  11.                 if(mina[j] > mina[j+1]) {
  12.                 temp = mina[j];
  13.               mina[j] = mina[j+1];
  14.               mina[j+1] = temp;           
  15.             }
  17.         }
  19.       }
  26. }

二维数组

声明方式

  1. 数据类型[][] 数组名
  2. 数据类型 数组名[][]
  3. 数据类型[] 数组名[]
  5. int[][] arr;
  6. int arr[][];
  7. int[] arr[];

初始化和引用

初始化方式

  1. 1.数据类型[][] 数组名;//先声明一个数组
  2.   数组名 = new 数据类型[长度][长度];//对数组进行初始化
  4. 2.数据类型[][] 数组名 = new 数据类型[长度][长度];//对数组声明的同时进行初始化

动态创建方式

可以将数组的存储方法跟表格作对比，例如一个三行三列的数组，int[][] arr = new int[3][3];
image.png
各个位置的索引号如上图。

  1. //想要输出第三行第二列的数据：
  2. System.out.println("arr[2][1]");
  3. //为第二行第三列的数据赋值为9：
  4. arr[1][2] = 9;
  6. // 创建float类型的数组，只指定行数
  7. // 注意：只指定行数的写法是可行的，但只指定列数和全不指定的写法是错误的
  8. float arr1 = new float[3][];
  9. // 因为没有指定列数，对该数组取值会出现空指针错误
  10. //System.out.println(arr1[0][0]);
  11. // 针对于该二维数组进行创建行
  12. arr1[0] = new  float[3];//第一行有三列，这样的写法可以指定每行有着不同的列
  13. arr1[1] = new  float[2];//第二行有二列
  14. arr1[2] = new  float[1];//第三行有一列
  15. System.out.println(arr1[0][0]);//0.0
  16. System.out.println(arr1[0][3]);//数组下标越界

静态创建方式

  1. 数据类型[][] 数组名 = {{x,,x,x},{x,x},{x,x,x,x},...,{x}};
  3. int[][] arr = {{1,2,3},{1,2,3},{1,2,3}};//三行三列的数组
  4. 或
  5. int[][] arr = {{1},{1,2},{1,2,3}};//三行不同列的数组

引用：

  1. System.out.println(arr[0][1]);//arr数组第一行第二列的元素
  2. System.out.println(arr.length);//arr数组的长度
  3. System.out.println(arr[0].length);//arr数组第一行的长度
  4. //循环输出二维数组的内容
  5. for(int i = 0; i < arr.length; i++) {
  6.     for(int t = 0; t < arr[i].length; t++) {
  7.         System.out.println(arr[i][t]);
  8.     }
  9. }