个人笔记，仅供参考

1、数组

1.2、定义

数组是可以存储多个相同数据类型的数据结构

1.3、数组的声明

数据类型[] 数组的名称 int[] ages;
数据类型 数组的名称[] String names[];

1.4、数组的初始化

静态初始化：

声明同时赋值：

int[] ages = {18,19,20};

取出数组中的元素应该通过下标，下标从0开始

第一个元素为ages[0]

数组长度数组名称.length

动态初始化：

1、先声明，再初始化，最后赋值

int[] ages;//数组的声明
ages = new int[3];//数组的初始化，必须指定数组元素的个数,默认值为0
ages[0] = 18;
ages[1] = 19;
ages[2] = 20

2、声明同时初始化，最后赋值

int[] ages = new int[3];
age[0] = 18;

3、声明同时初始化并赋值

int[] ages = new int[] {18,19,20};

1.5、数组的求和

int[] ages = {23,12,56,78,34,22,11,45,34,56};
int sum = 0;//用来存储数组元素的和值
for(int i=0;i<ages.length;++i)
{
    sum += ages[i];
}
System.out.println(sum/ages.length);

1.6、冒泡排序

以升序为例

冒泡排序会将相邻的两个数进行比较，将较大的放在后面，执行一轮后会将最大的数放在最后面，然后进行下一轮，把第二大的数放在倒数第二位，以此类推，总共要执行数组长度-1轮。

int[] ages = {19,16,15,17,10,5};
            /**
             * 对当前数组进行升序排列
             * 冒泡排序
             * 第一轮:将数组中的最大值放到了最后
             * 16 19 15 17 10 5 (1-2)
             * 16 15 19 17 10 5 (2-3)
             * 16 15 17 19 10 5 (3-4)
             * 16 15 17 10 19 5 (4-5)
             * 16 15 17 10 5 19 (5-6)
             * 
             */

for(int i=0;i<ages.length-1;++i)
            {//第一轮代码实现
                if(ages[i]>ages[i+1])
                {
                    //交换位置
                    int num = 0;
                    num =ages[i];
                    ages[i] = ages[i+1];
                    ages[i+1] = num;
                }
            }

如果不使用嵌套，整个过程的代码量会非常多

以下是使用循环嵌套的

for(int j=1;j<ages.length;++j)
        { //j表示数组排序要比较的轮数
            for(int i=0;i<ages.length-j;++i){
                if(ages[i]>ages[i+1]){
                    //交换位置
                    int num = 0;
                    num = ages[i];
                    ages[i] = ages[i+1];
                    ages[i+1] = num;
                }
            }
        }

这是一段可以执行整个冒泡排序过程的代码

1.7、数组索引越界问题

在使用数组时索引处理不当，导致使用了不存在的索引，从而引发错误，常见于循环中，对循环的次数把握不好就会出现此问题。

1.8、空指针异常

使用了不存在的数组（未初始化，或复制为null）

1.9、获取数组的长度

使用数组名.length即可

注意：数组的长度初始化后不可改变

如果再次初始化会再创建一个同名的数组（地址不同）并覆盖原来的数组

1.10、数组的反转

例如：原数组{1,2,3,4} 反转后{4,3,2,1}

有多种方法可以实现。

其实就是对称位置的元素交换，需要同时使用两个索引

需要创建一个空变量，然后交换对称位置的元素即可。

int[] array = {10,20,30,40,50};
        //遍历数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("==========");
        /**
         * 初始化语句：int min = 0, max = array.length -1
         * 条件判断： min<max
         * 步进表达式：min++,max++
         * 循环体：三个变量倒手
         */
        for (int min = 0, max = array.length-1;min < max; min++, max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }