数组就这点儿内容,你不看你怎么会呢

第三章数组

---

一、数组是什么？

1、定义

数组（Array）是相同数据类型元素的集合,数组本身也是引用数据类型(对象),是一种线性结构的数据结构.

2、数组的特点

• 数组是有序排列的
  • 每个元素都有下标
  • 可以快速查找
  • 但是从中间添加,删除就比较麻烦
  • 数组中可以存储基本类型,也可以存储引用类型
• 数组本身属于引用数据类型，但是数组的元素既可以是基本数据类型，也可以是引用数据类型
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名引用的是这块连续空间的首地址
• 数组的长度一旦确定，就不能更改

二、如何创建一个数组

1.创建数组

代码如下（示例）：

//创建一个数组
        int [] a;//简单创建法
        int b [];
        int[] c = {1,2,3,4,5,6};//赋值创建法
        String[] str = new String[5]//表明数组长度创建法

2.数组的长度即赋值

• **注:**数组是有下标的
• eg:
  b=new int []{1,2,3,4,5};
• 数组第一个值"1"也就是数组的第0位,表示就是
  b[0] = 1
  代码如下（示例）：

        int [] a;
        int b [];//创建一个int型的数组a,b
        a =new int[5];//给数组a赋予5个长度
        b=new int []{1,2,3,4,5};//这个就直接给数组b赋5个值
        int[] c = {1,2,3,4,5,6};//另一种定义数组的方法,直接赋值法,和上面的int[] b=new int []{1,2,3,4,5}是一个道理的
        System.out.println(Arrays.toString(a));//一维数组的输出,如果只写System.out.println(a);的话,只能输出地址,就是数组a的地址
        String[] str = new String[5];//也是一种数组创建法,直接赋值长度
        System.out.println(str[5]);//当然也可以这样输出数组

        int[] arr={1,2,3,4,5,6,7};
        System.out.println(arr[0]);
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
         }

三、一维数组的使用

1、一维数组的声明和初始化

//静态初始化：数组的声明和数组元素赋值操作同时进行
int[] ids = new int[]{1001,1002,1003};
//动态初始化：数组的声明和数组元素赋值操作分开进行
String[] names = new String[3];

2、如何调用数组指定位置的元素

• 数组通过索引的方式调用指定位置元素，可以进行赋值或者查看操作。
• 数组的索引从 0 开始，到数组长度 - 1 为止
• 在使用索引时，我们经常会碰到数组越界异常，报错信息为 java.lang.ArrayIndexOutOfBoundsException

String[] names = new String[3];
names[0] = "jak";
names[1] = "ros";
names[2] = "jack";

name[3] = "tom";	//java.lang.ArrayIndexOutOfBoundsException

3、如何获得数组的长度

• 通过数组的属性 length
• String name = new String[5];
• name.length() 输出5

4、如何遍历数组

• for循环遍历

  int[] ids = new int[10];
  
  for(int i = 0;i < ids.length;i++){
      System.out.println(ids[i]);
  }
  

• 增强for循环遍历

  int[] ids = new int[10];
  
  for(int id : ids){
      System.out.println(id);
  }
  

5、数组元素的默认初始化值

默认初始化就是没有给数组显式的赋值，但是JVM会给数组的每个元素默认的赋初值

• 数组元素是整型 0
• 数组元素是浮点型 0.0
• 数组元素是char型 0的ASCII值
• 数组元素是Boolean型 false
• 数组元素是引用数据类型 null

三、一维数组排序方法

1.冒泡排序

• 什么叫做冒泡排序法,就说从小到大排序一样,是不是小的轻的,在水面上就冒出头,漂上来了,而重的就沉下去了,
• 这个非常简单,每次排序从第一个开始找将最大的排序到最后面,依次循环像下面演示循环4次即可第一次内循环就是45321,然后一直循环下去
  eg:
  5 4 3 2 1
  4 3 2 1 5
  3 2 1 4 5
  2 1 3 4 5
  1 2 3 4 5
  代码如下（示例）：

//创建一个数组
      public static void main(String[] args) {
       /* 54321
        43215
        32145
        21345
        12345*/
        int[] a = {5, 4, 3, 2, 1};//先创建一个数组a[]=54321
        for (int i = 0; i < a.length - 1; i++) {//这里面i < a.length - 1,其实这里减一不减一效果是一样的,在这个代码中i表示的是循环i次,经过上面分析,这个代码只需要循环4次也就是a.length-1次,有了减一代码可以少循环一次,是不是更好呢!
            for (int j = 0; j < a.length - 1 - i; j++) {//这里为什么是j < a.length - 1 - i,而不是单单减一又不是单单减i呢,先说减i,这个减i和上面减是一个道理,不减i也可以,但是你看上面步骤中,第一个数字是,第一次循环最最大,就已经和所有数字比较过了,放在4号位置,也就是最后一个元素位置上了,那下次循环是不是可以忽略,不在用4和5来比较呢,减i之后可以少运行一般,是不是减i更好呢,再然后减一是根据下面代码中j+1,如果不减一当j=4时,a[j+1]也就a[5],不就是会出现越界数组内存不够而报错嘛
                if (a[j] > a[j + 1]) {//当a[j]>a[j+1]时也就是第一个数字5大于4是开始执行if的条件语句,然后开始循环
                    int tamp = a[j + 1];//说第一次内循环吧,先定义一个tamp,将4赋值给tamp,
                    a[j + 1] = a[j];//将5赋值给a[j+1]也就是说第一个数字变成了4,可以理解为现在变成了44321
                    a[j] = tamp;//这个时候将4也就是刚赋值的tamp赋值给a[j]也就是说第二个数字变成了5,可以理解为现在变成了45321
                }//经过上面内循环4次得到最好结果就是43215
            }//开始上面的总循环,每个数字都需要循环一次共4次得到12345
        }
        System.out.println(Arrays.toString(a));//输出数组a;
    }

2.选择排序法

第一种选择排序法
像下面一组数组,就可以很好的反馈,第一次外循环,循环出最小的数字放在第一个位置上,怎么放到第一个呢!就需要靠内循环了,0号位数字和1号位数字进行比较,小的就和第一个数字换一下,比如下面,5先和4换,变成45321,在4和3换变成35421就这样一直循环下去
eg:
54321
15432
{
45321
35421
25431
15432
}
12543
12354
12345
代码如下（示例）：

//创建一个数组
        import java.util.Arrays;
public class Day2 {
    public static void main(String[] args) {
   
            /*
        54321
        15432     45321
        12543      35421
        12354      25431
        12345      15432
        * */
        int[] a = {5, 4, 3, 2, 1};//创建一个数组
        for (int i = 0; i < a.length - 1; i++) {//这里面i < a.length - 1,其实这里减一不减一效果是一样的,在这个代码中i表示的是循环i次,经过上面分析,这个代码只需要循环4次也就是a.length-1
            for (int j = i; j < a.length; j++) {//这里有一个细节int j = i初始化,j是等于i的,你想第一次循环,是不是不需要a[0]和a[0]来比较,而且,前面排序排完了,是不是不需要在运行前面了,比如a[2]了是不是不需要在和a[0],a[1]来比较了所以这里初始值设定为i而不是1不是0
                if (a[i] > a[j]) {//如果第一次外循环中,a[0]>a[1]则进行if语句,一次完了循环第二次a[0]>a[2]
                    int b = a[i];//说第一次内循环吧先定义一个b,将5赋值给b,
                    a[i] = a[j];//上面判断了a[j]<a[i],所以把a[j]赋值给a[i],也就变成了44321
                    a[j] = b;//这个时候将5也就是刚赋值的b赋值给a[j]也就是说第一个数字变成了5,可以理解为现在变成了45321
                }//内循环第一个数字一直和后面的比大小,第一个小则跳过,若后面的小那就俩个交换位置
            }//开始上面的总循环,每个数字都需要循环一次共4次得到12345
        }
        System.out.println(Arrays.toString(a));
    }
}

第二选择排序法
原理和第一种一样,但是不一样的地方就出来了,比第一种简洁,比第一种运行快
他是第一个数字和后面的数字比较,然后记录出最小的数字,然后再用记录的最小的数字依次和后面的做比较,然后最后用标记的最小的那个数字和第一个数字进行交换,比如下面,5先和4比较,4小然后标记4,在4和3进行比较 一直这样循环下去 最后内循环就变成了14325
eg:
54321
{
b = 4
54321
b=1
14325
}
14325
12345
代码如下（示例）：

        int[] a = {5, 4, 3, 2, 1};//创建一个数组
        int b = 0; //定义一个变量b,用来将来给数组赋值
        for (int i = 0; i < a.length - 1 ; i++) {
            int c = i;//定义一个变量c,用来标记数组,这里c = i表示从第i个开始执行,比如循环到a[1],那么说明a[0]已经确定c只需要从1开始循环比较下去
            for (int j = i; j < a.length; j++) {
                if (a[i] > a[j]) {
                    c = j;//定义一个变量c,用来标记数组,这里c = j表示从第j个开始执行,比如循环到a[1],那么说明a[0]已经确定c只需要从1开始循环比较并且记录值最小的那个数组的下标
                }
                b = a[i];
                a[i] = a[c];
                a[c] = b;
            }
        }
        System.out.println(Arrays.toString(a));

3.插入排序

• 这个就强了,可难可不难,前面那么多都是从后往前开始循环的,这个是从后往前循环的
• eg:
  2593
• 提取最后一个数字 b=3
  用最后一个和他的前一个做比较,如果前面的大那就将前面的往后赋值
  知道遇见一个比他小的再将b插入其中
• 2 5 9 9
  2 5 5 9
  2 3 5 9
  代码如下（示例）：

import java.util.Arrays;

public class Day3 {
    public static void main(String[] args) {
        /*
        * 2593   3提出来
        * 2599    b=3
        * 2559
        * 2359
        * */
        int [] a = {2,5,9,3,9,8,1,2};//创建一个数组
        //          0 1 2 3
        for (int i = 0; i < a.length ; i++) {
            int b =a[i];
            for (int j = i-1; j >= 0; j--) {
            //for循环解读,第一次外循环b=a[0]=1,到内循环中,没有b[0-1]所以直接跳过if语句,继续循环外循环,第二次也一样,知道第4次b=a[3]=3,到内循中直接插入到5的前面可以说(25939812)-(2599812)-(2559812)-(2359812)然后继续进行外循环直到(12235899)
                if (b < a[j]){
                    a[j+1] = a[j];
                    a[j] = b;
                }
            }
        }
        System.out.println(Arrays.toString(a));

三、如何创建一个二维数组

1.创建数组

• 二维数组的定义：
  数组的数组即二维数组的每一个元素是一个一维数组
• 数组创建
  int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
  int [][] b = {{1,2,3},{1,2,3},{1,2,3}};
  int [][] c = new int[3][5];
  定义了一个整型的二维数组 ,这个二维数组有3个一维数组,每一个一维数组包含5个元素.

代码如下（示例）：

//创建一个数组
package array.day2;
import java.util.Arrays;
public class Day3 {
    public static void main(String[] args) { 
        //{{}{}{}}二维数组就像这个模式一样简称数组套数组
        int [][] b = new int[3][3];//根据数组长度定义
        int [] c = {1,2,3};
         b[0] = c;//给二维数组的一个小数组赋值,必须这样
        int [][] a = {{1,2,3},{7,8,9,10},{4,5,6}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+"\t" );
            }
            System.out.println();
        }
    }
}

2、如何调用数组指定位置的元素

int[][] arr = new int[3][];

arr[1][1];	//java.lang.NullPointerException 报错，空指针异常

3、获取数组长度

int[][] arr1 = new int[][]{{1,2,3},{2,3},{3,4,5}};

System.out.println(arr1.length);	//3
System.out.println(arr1[2].length);	//3
System.out.println(arr1[1].length);	//2

4、数组元素的默认初始化值

首先我们规定几个概念

int[][] arr = new int[3][4];

//外层元素
arr[1];
arr[2];
//内层元素
arr[1][1];
arr[1][2];

int[][] arr = new int[2][3];

• 外层元素的默认初始化值：地址值
• 内层元素的默认初始化值：与一维数组初始化情况相同

int[][] arr = new int[2][];

• 外层元素的默认初始化值：null
• 内层元素的默认初始化值：不能调用，否则空指针异常

5.二维数组的迭代(输出)

for循环在遍历输出二维数组

代码如下（示例）：

        package array.day2;
import java.util.Arrays;
public class Day3 {
    public static void main(String[] args) {
        //{{}{}{}}
        int [][] a = {{1,2,3},{7,8,9,10},{4,5,6}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+"\t" );
            }
            System.out.println();
        }
    }
}