1，数组的定义和使用

1.1，数组的定义和作用

• 数组是一种数据类型，存储相同数据类型的一组数据。
• 声明一个变量就是在内存中开辟一个空间。
• 声明数组就是在内存中开辟一串连续的空间。

数组的定义方式

动态初始化

• 初始化时只指明长度，由系统为数组分配初始值
• 格式：数据类型[] 数组名 = new 数据类型[数据长度]
• 范例：int[] arr = new int[3]

静态初始化

• 声明数组的同时对数组元素赋初始值
• 格式：数据类型[] 数组名 = new int[]{元素1取值,元素2取值,…}
• 范例：int[] arr = new int[]{1,2,3,4}
• 简化格式：数据类型[] 数组名 = {元素1取值,元素2取值,…}
• 范例：int[] arr = {1,2,3,4}

public class ArrayDemo1
{
    public static void main(String[] args)
    {
        //1，动态定义
        int[] arr = new int[3];//数组arr中只能存放三个int类型的整数
        //2，静态定义
        int[] arr1 = new int[]{1, 2, 3, 4};
        //3，简写
        int[] arr2 = {1, 2, 3, 4};
    }
}

数组元素访问

• 格式：数组名[索引]

索引是数组中数据的编号方式，用于访问数组中的数据

• 特征1：索引从0开始
• 特征2：索引是连续的
• 特征3：索引逐一增加，每次加一

public class ArrayDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        System.out.println(arr);//输出数组名
        System.out.println(arr[0]);//输出0，第一个元素
        System.out.println(arr[1]);//输出0，第二个元素
        System.out.println(arr[2]);//输出0，第三个元素
    }
}

Java中内存分配

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

栈内存：存储局部变量

• 定义在方法中的变量，例如：arr
• 使用完毕，立即消失

堆内存：存储new出来的内容（实体，对象）

数组在初始化时，会为存储空间添加默认值

• 整数：默认值0

• 浮点数：默认值0.0

• 布尔：默认值false

• 字符：默认值空字符

• 

• 

• 

• 

1.2，数组遍历

什么是数组遍历？

• 获取数组中的每个元素

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

for循环

• 循环次数：数组长度-1

public class Test
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        for (int i = 0; i < 5; i++)
        {
            System.out.println(arr[i]);
        }
    }
}

动态数组长度

• 格式：数组名.length
• 范例：arr.length

数组遍历的通用格式

public class Test
{
    public static void main(String[] args)
    {
        int[] arr = {1, 2, 3, 4};
        for (int i = 0; i < arr.length; i++)
        {
            arr[i];//对arr[i]操作
        }
    }
}

//遍历数组中每个元素
public class Test
{
    public static void main(String[] args)
    {
        String[] arr = {"语文", "数学", "英语", "编程"};
        //i:为数组索引 从0开始[0,3]
        //动态表示数组长度：数组名.length
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + "  ");//语文  数学  英语  编程  
        }
    }
}

1.3，数组中的数组

什么是数组中的数组？

• 数组中的每个元素也是一个数组

数组中的数组语法

• 格式：数据类型[][] 数组名 = new 数据类型[外层数组长度][内层数组长度]
• 范例：int[][] score = new int[3][5]

public class Test
{
    public static void main(String[] args)
    {
        int[][] score = new int[3][5];
        //第一个班级五个学生成绩
        score[0][0] = 80;
        score[0][1] = 67;
        score[0][2] = 45;
        score[0][3] = 50;
        score[0][4] = 88;
    }
}

数组中的数组内存图

数组中的数组遍历

public class Test
{
    public static void main(String[] args)
    {
        int[][] score = new int[3][5];
        //第一个班级五个学生成绩
        score[0][0] = 80;
        score[0][1] = 67;
        score[0][2] = 45;
        score[0][3] = 50;
        score[0][4] = 88;
        //第一个班级的5个学生成绩
        for (int i = 0; i < score[0].length; i++)
        {
            score[0][i];//对score[0][i]操作
        }
        //第二个班级的5个学生成绩
        for (int i = 0; i < score[1].length; i++)
        {
            score[1][i];//对score[1][i]操作
        }
        //第三个班级的5个学生成绩
        for (int i = 0; i < score[2].length; i++)
        {
            score[2][i];//对score[2][i]操作
        }
    }
}

数组中的数组遍历

1.4，数组的排序

什么是排序？

• 是指将数组元素按照从小到大或者从大到小的重新排列。
• 对于元素较多的数组，排序算法的优劣至关重要。
• 一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣
• 常用的排序算法有：插入排序，冒泡排序，快速排序等。

数组冒泡排序算法

• 冒泡排序的原则：比较相邻的元素，如果违反最后的顺序准则，则交换

冒泡排序可以简单理解为：

• 第一次找到所有元素中最大的放在最后一个位置，不再变动。
• 第二次找到剩余所有元素中最大的放在倒数第二个位置上，不再变动。
• 以此类推，直到排序完成。

数组冒泡排序分析

public class ArrayDemo4
{
    public static void main(String[] args)
    {
        int[] arr = {89, 50, 84, 57, 21};
        for (int j = 1; j < arr.length; j++)//表示轮数
        {
            //第一轮 比较4次
            for (int i = 0; i < arr.length - j; i++)//j=1 4 j=2 3 j=3 2 //表示一轮中要比较的次数
            {
                //如果前面的那个数大于后面的数就交换位置
                if (arr[i] > arr[i + 1])
                {
                    //引入中间变量以交换数值
                    int t = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = t;
                }
            }
        }
        //遍历输出数组中的元素
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");//21 50 57 84 89 
        }
    }
}

1.5，数组的最大最小过滤重复

数组的最大值

• 定义一个变量存放最大值，假设数组中的第一个元素为该变量的初始值，该变量跟数组中的其他数进行比较，如果遇到比该值更大的就重新赋值，比较完之后，最后该变量里面存放的就是数组中的最大值。

public class ArrayMaxDemo
{
    public static void main(String[] args)
    {
        //定义一个数组 arr
        int[] arr = {1, 2, 3, 4, 5};
        //定义 max 变量存放最大值，假设数组 arr 的第一个元素为最大值
        int max = arr[0];
        //初始最大值跟数组中的其他元素进行比较，如果有比该值更大的就替换
        for (int i = 1; i < arr.length; i++)
        {
            if (max < arr[i])
            {
                //进行替换操作
                max = arr[i];
            }
        }
        //输出最大值
        System.out.println(max);
    }
}

数组的最小值

• 定义一个变量存放最小值，假设数组中的第一个元素为该变量的初始值，该变量跟数组中的其他数进行比较，如果遇到比该值更小的就重新赋值，比较完之后，最后该变量里面存放的就是数组中的最小值。

public class ArrayMinDemo
{
    public static void main(String[] args)
    {
        int[] arr = {5, 4, 3, 2, 1};
        //定义一个变量来存放最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++)
        {
            //如果下一个元素更小，则替换
            if (min > arr[i])
            {
                min = arr[i];
            }
        }
        //输出最小值
        System.out.println(min);//1
    }
}

数组的过滤重复

• 去掉数组中重复的数据，给每个元素一个标记，每个元素跟数组中其他元素进行比较，如果完全相同就改变原有标记，将没有改变标记的元素重新放入一个新的数据，并统计其个数，最终将新的数组的数据复制到另一个新的数组中。
• 使用System.arraycopy()方法可以实现数组的复制。

public class ArrayCopy
{
    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
    {
        //src，源数组
        //srcPos，源数组中的起始位置
        //dest，目标数组
        //destPos，目标数组中的起始位置
        //length，要复制的数组元素的数量
    }
}

import java.util.Arrays;

public class Test
{
    public static void main(String[] args)
    {
        int[] arr = {12, 34, 23, 12, 45, 57, 45, 89};
        int t = 0;
        int[] tempArr = new int[arr.length];//临时数组
        for (int i = 0; i < arr.length; i++)//遍历原数组
        {
            boolean isTrue = true;//声明一个标记
            for (int j = i + 1; j < arr.length; j++)//内层循环将原数组的元素逐个比较
            {
                if (arr[i] == arr[j])//发现重复的数据改变其标记并结束程序
                {
                    isTrue = false;
                    break;
                }
            }
            if (isTrue)//判断标记是否被改变如果没有被改变就是没有重复元素
            {
                tempArr[t] = arr[i];//没有元素就将原数组的元素赋值给临时数组
                t++;//记录没有重复的数字个数
            }
        }
        int[] newArr = new int[t];
        System.arraycopy(tempArr, 0, newArr, 0, t);
        System.out.println(Arrays.toString(newArr));//[34, 23, 12, 57, 45, 89]
    }
}

1.6，数组的常用类Arrays

Arrays类常用方法

• Arrays类包含用于操作数组的各种方法

import java.util.Arrays;

public class ArrayDemo8
{
    public static void main(String[] args)
    {
        int[] arr = {12, 3, 45, 67, 44, 2};
        //Arrays.toString(数组)：按照一定格式输出数组中的每个元素
        System.out.println(Arrays.toString(arr));//[12, 3, 45, 67, 44, 2]

        //Arrays.sort(数组)：按照数字从小到大的顺序排列数组里的元素
        Arrays.sort(arr);
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[2, 3, 12, 44, 45, 67]

        //Arrays.copyOf(原数组，新数组长度)：实现数组的复制
        arr = Arrays.copyOf(arr, 7);
        //给最后一个元素赋值
        arr[6] = 10;
        System.out.println(Arrays.toString(arr));//[2, 3, 12, 44, 45, 67, 10]
    }
}