---

什么是数组？

在Java中，数组是一种引用数据类型，用于存储相同数据类型的一组数据。

声明一个变量就是在内存中开辟一个空间，那声明数据就是在内存中开辟一串连续的空间。

数组的定义

• 第一种：数据类型[] 数组名= new 数据类型[数组长度]
  这种方式我们需要指明数组的长度，例子中的数据类型用的是int

    int[] arr = new int[5];

• 第二种：声明数组时直接给元素初始化
  这种方式数组是给定的，就不用定义长度了。

int[] arr = {67,13,5,78,100};

当然上面只是简写，下面这个是完整写法，知道有这种方式即可。

int[] arr = new int[]{67,13,5,78,100};

• 有些时候，可能由于作用域的问题，需要先声明数组，然后赋值。
  因为数组是引用数据类型，所以它的默认值为null。

	int[] arr = null;
	{
		arr = new int[]{67, 13, 5, 78, 100};
	}

• 我们的数组不仅仅用于基本数据类型，还可以用对象数组：
  只是对象数组容易遇到空指针异常，并且数组不灵活，建议使用集合ArrayList来存放对象，后面会介绍集合的。

	Object[] objects = new Object[]{};
	Object[] objects1 = new Object[5];

数组的访问

通过索引访问数组：
需要注意，索引是从0开始逐一增加。

        int[] arr = {67, 13, 5, 78, 100};
        System.out.println(arr[0]);//访问第1个元素
        System.out.println(arr[1]);//访问第2个元素
        System.out.println(arr[2]);//访问第3个元素

内存分配

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

• 栈内存: 存储局部变量
  定义在方法中的变量，例如: arr
  使用完毕，立即消失
• 堆内存:存储new出来的内容(实体,对象)
  数组在初始化时，会为存储空间添加默认值

数据类型	默认值
整数	0
浮点数	0.0
布尔	false
字符	空字符
引用数据类型	null

当我们访问一个数组中的某个元素时，首先在栈中找到数组的引用，然后根据数组的地址在堆中找到该数组，然后根据索引拿到数组中索引对应的数据。

数组遍历

遍历就是连续访问该数据结构中所有的元素。

    int[] arr = {67, 13, 5, 78, 100};
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

arr.length代表数组的长度，可以猜测到，length是Array中的一个属性。

数组中的数组

数组可以存放基本数据类型，还可存放对象类型，那么数据中的元素可以是数组吗？当然可以的，拿二维数组举例。

认真看下面的代码哦，找到规律就可以理解二维数组了甚至多维数组，概念的东西很抽象，下面的结果图很清晰，唯一要提醒的就是索引 0 代表首个元素

定义二维数组
数据类型[][] 数组名= new 数据类型[外层数组长度][内层数组长度]

        int[][] arr = new int[2][4];
        arr[0][0]=11;
        arr[0][1]=12;
        arr[0][2]=13;
        arr[0][3]=14;
        arr[1][0]=21;
        arr[1][1]=22;
        arr[1][2]=23;
        arr[1][3]=24;

遍历二维数组

	for (int i = 0; i < arr.length; i++) {
		for (int j = 0; j < arr[i].length; j++) {
			System.out.print(arr[i][j] + " ");
		}
		System.out.println();
	}

冒泡排序

排序就是将数组元素按照某种顺序排序，比如int类型可以从大到小、从小到大排序。

冒泡排序原则：
比较相邻的元素，如果违反最后的准则，则交换。
第一次找到所有元素中最大的放在最后一个位置，不再变动；
第二次找到剩余所有元素中最大的放在倒数第二个位置上，不再变动；
以此类推，直到排序完成。

理解冒泡排序首先要分析需要排几轮，然后分析每轮需要排几次。
根据图中规律，需要排(n-1)轮，每轮需要排（n-i-1）次，n是元素个数，i是轮数。
所以冒泡排序的时间复杂度是∑(n-1)（n-i-1）次，也就是O(n²/2 )

        int[] arr = {89, 50, 84, 57, 21};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序结束");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

数组最大值最小值

如果你想获取到数组中的最大值或最小值，你可以遍历数组，比较条件。

    public int getMaxAge()
    {
        int ages[] = {18 ,23 ,21 ,19 ,25 ,29 ,17};
        int max = ages[0];
        for(int i = 1;i<ages.length;i++){
            if(ages[i]>max){
                max = ages[i];
            }
        }
        return max;
    }

数组过滤重复条件的元素

去掉数组中重复的数据，给每个元素一个标记， 每个元素跟数组中其他元素进行比较，如果完全相同就改变原有标记，将没有改变标记的元素重新放入一个新的数组，并统计其个数，最终将新数组的数据复制到另一个新的数组中。

Arrays常用API

方法名	说明
public static String toString(int[] a)	可返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	可按照数字从小到大顺序排列指定的数组
public static long[] copyOf(long[] original,int newLength)	复制指定的数组(original :要复制的数组newLength :新数组的长度)

        int[] arr = {89, 50, 84, 57, 21};
        //排序(从小到大)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));