Java——数组

1.概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器
1)既可以存放基本数据类型元素，也可以存放引用数据类型元素
2)数组本身是引用数据类型
3)初始化之后长度不可改变
解决：有大量相同类型元素需要处理
2.数组的定义
数据类型[] 数组名;
数据类型 数组名[];
3.数组的初始化
1)静态初始化—初始化时指定每个数组元素的初始值，由系统决定数组长度

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

2)动态初始化—初始化时只指定数组长度，由系统为数组分配初始值

  int[] arr = new int[5];

基本数据类型
|-byte 0
|-short 0
|-int 0
|-long 0
|-double 0.0
|-float 0.0
|-boolean false
|-char 0
引用数据类型----null //面向对象—面向过程
|-String null
3)数组的长度：数组名.length;
4)访问数组中的元素
数组名[下标];
下标的范围 0~数组的长度-1
4.常见问题
ArrayIndexOutOfBoundsException–下标越界异常
NullPointerException–空指针异常
5.数组常见操作
1)遍历

  //数组的遍历
  int[] arr = {100, 99, 101, 200, 1};
  //for循环
  for(int index = 0; index < arr.length; index++) {
   System.out.println(arr[index]);
  }
  System.out.println("***********************************");
  //while循环
  int index = 0;
  while(index < arr.length) {
   System.out.println(arr[index]);
   index++;
  }
  System.out.println("***********************************");
  
  //增强for循环 -- foreach
  for(int item : arr) {
   System.out.println(item);
  }
 

2)求最值

  int[] arr = {-5, -4, -9, -1, -6};
  //最大值  一次遍历
  int max = arr[0];
  for (int i : arr) {
   if(max < i) {
    max = i;
   }
  }
  System.out.println(max);
  
  //最小值
  int min = arr[0];
  for (int i : arr) {
   if(min > i) {
    min = i;
   }
  }
  System.out.println(min);

3)逆序

  int a = 100;
  int b = 10;
  System.out.println(a + b);
  
  int[] arr = {1, 4, 9, 3, 2};
  
  //数组逆序
  for(int head = 0, tail = arr.length - 1; head < tail; head++, tail--) {
   //变量交换
   int temp = arr[head];
   arr[head] = arr[tail];
   arr[tail] = temp;
  }
  
  for (int i : arr) {
   System.out.println(i);
  }
 

4)选择排序
|—选定一个元素和其后的元素进行比较
|—每一轮比较完成都会选出最大或最小的元素

  //选择排序
  int[] arr = {5, 0, 9, 8, 3};
  
  //i 表示的是选定的元素，j 其后的元素
  for(int i = 0; i < arr.length - 1; i++) {
   //小大  选定arr[0],和其后的元素进行比较....
   for(int j = i+1; j < arr.length; j++) {
    if(arr[i] > arr[j]) {
     int temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
    }
   }
  }
  
  for (int i : arr) {
   System.out.println(i);
  }
 

5)冒泡排序
|—相邻元素两两进行比较
|—如果数组已经排好序，如何减少比较次数

  //冒泡排序
  int[] arr = {1, 2, 3, 4, 5};
  boolean flag = false; //假定数组是已经排好顺序的
  
  for(int i = 0; i < arr.length - 1; i++) {
   System.out.println("-----------------------------------");
   //第i轮代码
   for(int j = 0; j < arr.length - 1 - i; j++) {
    if(arr[j] > arr[j+1]) {
     int temp = arr[j];
     arr[j] = arr[j+1];
     arr[j+1] = temp;
     flag = true;
    }
   }
   
   if(flag == false) {//假设成立，数组是有序的
    break;
   } else {
    flag = false;
   }
  }
  
  for (int i : arr) {
   System.out.println(i);
  }
 

6.数组一旦初始化，长度不可改变
栈----
|----基本数据类型变量
|----引用—生成对象时，赋值左侧的内容
堆----
|----对象，数组—通过new生成的区域
GC----垃圾回收

7.打印数组
直接打印数组：在内存中的地址
用toString()方法打印内容

  int[] arr = {4, 5, 6};
  System.out.println(arr);
  //打印数组中的内容
  System.out.println(Arrays.toString(arr));
 

8.二维数组

1. 概念：二维数组就是一维数组，一维数组中的每个元素都是一维数组
   2)定义

//二维数组
  //定义了一个二维数组，有三个元素，每个元素是一个有两个元素的一维数组
  int[][] arr = new int[3][2];
  
  //定义了一个二维数组
  int[][] arr1 =  new int[3][];
  System.out.println(arr1[0]);
  System.out.println(arr1[1]);
  System.out.println(arr1[2]);
  arr1[0] = new int[1];
  arr1[1] = new int[2];
  arr1[2] = new int[3];
  
  //定义了一个二维数组
  int[][] arr2 = new int[][]{
   {1, 2, 3},
   {4, 4},
   {6, 7, 8}
  };
  
  //定义了一个二维数组
  int[][] arr3 = {
   {1, 2, 3},
   null,
   {6, 7, 8}    
  };

3. 遍历

  /* 
   * 二维数组遍历1
   */
  for(int i = 0; i < arr3.length; i++) {
   if(arr3[i] == null) {
    System.out.println("null");
    continue;
   }
   //遍历一维数组
   for(int j = 0; j < arr3[i].length; j++) {
   	System.out.print(arr3[i][j] + "\t");
   }
  	System.out.println();
  }
  
  /**
   * 增强for循环遍历二维数组
   */
  for(int[] itemArr : arr3) {
  	if(itemArr == null) {
   		System.out.println("null");
    		continue;
   }
   
   for(int item : itemArr) {
   	System.out.print(item + "\t");
   }
   	System.out.println();
  }

4)二维数组内存中的形式