数组

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个元素，按照一定的先后次序排列组合而成
其中每一个数据称作一个数组元素，每个数组元素可以通过一个下表来访问他们
首先必须声明数组变量，才能在程序中使用数组。下面是声明变量的语法：
Java使用new操作符来创建数组，语法如下：
数组的元素是通过索引访问的，数组索引从0开始

获取数组长度：arrays.length ```java public class arrayDemo01 { public static void main(String[] args) {

  int[] nums;//声明一个数组
  nums = new int[10];//创建一个数组
  //int[]nums = new int[10];
  //给数组中的元素赋值
  nums[0] = 1;
  nums[1] = 2;
  nums[2] = 3;
  nums[3] = 4;
  nums[4] = 5;
  nums[5] = 6;
  nums[6] = 7;
  nums[7] = 8;
  nums[8] = 9;
  nums[9] = 10;
  int sum = 0;//计算元素的和
  //获取数组长度：array.Length
  for (int i = 0; i < nums.length; i++) {
      sum = sum + nums[i];//sum+=nums[i];
      System.out.println("数组的合为："+sum);
  }
  System.out.println("数组的合为："+sum);

} }

<a name="JMVUZ"></a>
## **数组元素的默认初始化值**
1.  数组元素是整型：0
1.  数组元素是浮点型：0.0
1. 数组元素是char型：0或'\u0000'，而非'0'
1. 数组元素是boolean型：false
1. 数组元素是引用数据类型：null
<a name="eFsHD"></a>
# 内存分析
![image.png](https://cdn.nlark.com/yuque/0/2021/png/25423415/1638253569904-96e23c50-9600-42d5-a34f-65d376b41f08.png#clientId=u40165ad7-cea2-4&from=paste&height=186&id=iBGRw&margin=%5Bobject%20Object%5D&name=image.png&originHeight=371&originWidth=794&originalType=binary&ratio=1&size=123278&status=done&style=none&taskId=uc13f0392-6655-43c0-b3b1-e7e266525a3&width=397)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/25423415/1640178039447-87382f13-6401-404f-b6c0-fd60b7a06799.png#clientId=u4bf77ffa-f0b7-4&from=paste&height=245&id=u3f13142b&margin=%5Bobject%20Object%5D&name=image.png&originHeight=489&originWidth=836&originalType=binary&ratio=1&size=65057&status=done&style=none&taskId=u1af08aa9-2bc8-439e-8f19-fe086192d9c&width=418)
<a name="mlp4n"></a>
# 三种初始化
<a name="UECE4"></a>
## 静态初始化
```java
int[] a = {1,2,3};
Man[]man = {new Man(1,1),new Man(2,2)};

动态初始化

int[] a = new int[2];
a[0]=1;
a[1]=2;

数组默认初始化

数字是引用类型，他的元素相当于类的实例变量，因此数组意境分配空间，其中的每个元素也被按照实际实例变量同样的方式被隐式初始化。 ```java public class arrayDemo02 { public static void main(String[] args) {
```
  //静态初始化
  int[] a ={1,2,3,4,5,6,7};
  System.out.println(a[2]);
  //动态初始化
  int[] b = new int[10];
  b[2] = 13;
  System.out.println(b[2]);
  //数组默认初始化
  int[] c = new int[10];
  System.out.println(c[2]);
```
} }

<a name="CnW2g"></a>
##  数组的四个基本特点
1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
1. 其元素必须是相同类型，不允许出现混合类型
1. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
1. 数组变量属引用类型，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
<a name="KRf2t"></a>
# 数组边界
下标的合法区间：[0,length-1],如果越界就会报错：
```java
public class arrayError01 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        System.out.println(nums[5]);
    }
}

ArrayIndexOutOfBoundsException:数组下标越界异常！
小结：

数组是相同数据类型的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，是可变的。如果越界就会报Error
多维数组

多维数组可以看成是数组的数组。比如二维数组就是一个特殊的以为数组，其每一个元素都是一个一维数组

int a[][] = new int[2][5];

public class arrayDemo05 {
  public static void main(String[] args) {
      int[][] arrays = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
      System.out.println(arrays[2][0]);
  }
}

Arrays类

由于数组对象本身并没有什么方法可以供我们调用，但是API中提供了一个工具类Arrays供我们使用

public class arrayDemo06 {
  public static void main(String[] args) {
      int[] a ={423,345,63,6,1754,843534,123};
      System.out.println(Arrays.toString(a));
      //打印数组元素 Arrays.toString()
      Arrays.sort(a);
      System.out.println(Arrays.toString(a));
      //数组排序  Arrays.sort()
      Arrays.fill(a,2);
      System.out.println(Arrays.toString(a));
      //数组填充 Arrays.fill()
      Arrays.fill(a,3,6,0);
      System.out.println(Arrays.toString(a));
      //指定数组填充  Arrays.fill(x,y,z)
  }
}

冒泡排序

冒泡排序是最出名的排序算法之一，总共有八大排序

public class arrayDemo07 {
  public static void main(String[] args) {
      int[] a ={423,676,471,3,735457,788};
      int[] sort = sort(a);
      System.out.println(Arrays.toString(sort));
  }
  public static int[] sort(int[] array){
      //临时变量
      int temp = 0;
      //外层循环
      for (int i = 0; i < array.length-1; i++) {
          //内层循环，比价判断两个数，如果第一个数比第二个数大，则交换位置
          for (int j = 0; j < array.length-1-i; j++) {
//减i是因为，第i次比较之后，已经产生了i个最大或最小的数，不需要进行下一轮比较了
              if (array[j+1]<array[j]){
                      temp = array[j];
                  array[j] = array[j+1];
                  array[j+1] = temp;
              }
          }
      }
      return array;
  }
}

进行了优化的冒泡排序 ```java public class arrayDemo07 { public static void main(String[] args) {

  int[] a ={423,676,471,3,735457,788};
  int[] sort = sort(a);
  System.out.println(Arrays.toString(sort));

} public static int[] sort(int[] array){

  /*冒泡排序

1.在数组中，两个相邻元素，如果第一个数比第二个数大，那么就交换他们的位置 2.每一次比较都会产生一个最大或者最小的数字 3.下一轮可以少一次排序 4.一次循环，直到结束 */

  //临时变量
  int temp = 0;
  //外层循环
  for (int i = 0; i < array.length-1; i++) {
      //内层循环，比价判断两个数，如果第一个数比第二个数大，则交换位置
      boolean flag = false;
      //通过flag标识位来减少没有意义的比较
      for (int j = 0; j < array.length-1-i; j++) {
      /*减i是因为，第i次比较之后，已经产生了i个最大或最小的数，不需要进行下一轮比较了*/
          if (array[j+1]<array[j]){
                  temp = array[j];
              array[j] = array[j+1];
              array[j+1] = temp;
              flag = true;
          }
      }
      if (flag==false){
          break;
      }
  }
  return array;

} }

```

稀疏数组

当一个数组中大部分元素为0或者为同一个值得时候，可以用稀疏数组来保存该数组
稀疏数组得处理方式是
1. 记录数组一共有几行几列，有多少不同值
2. 把具有不同值的元素和详列及值记录在一个小规模得数组里，从而缩小程序得规模
如下图：左边是原始数组，右边是稀疏数组