自学Java第四章——《数组》

4.1 数组的相关概念和名词（了解）

1、数组(array)：

一组具有相同数据类型的数据的按照一定顺序排列的集合。

把有限的几个相同类型的变量使用一个名称来进行统一管理。

2、数组名：

（1）这个数组名，代表的是一组数

（2）这个数组名中存储的整个数组的“首地址”

3、下标(index)：

我们使用编号、索引、下标来区别表示一组数当中某一个。

范围：[0,数组长度-1]

例如：for(int i = 0; i<arr.length; i++){}

4、元素(element)：

这一组中的的每一个数据都是元素。

如何表示数组元素？ 数组名[下标]

5、数组的长度(length)

数组中元素的总个数。

如何获取数组长度？ 数组名.length

注意：名称是为了沟通的方便，概念不用一字不落背下来

4.2 数组的相关语法

4.2.1 数组的声明

语法格式：

 //推荐元素的数据类型[] 数组名;​ //也对，但是不推荐元素的数据类型  数组名[];

示例：

//要存储一组整数int[] array;​//要存储一组单字符char[] array;​//要存储一组字符串String[] array;

4.2.2 数组的初始化

初始化的目的：（1）确定数组的长度（2）为元素赋值

两种初始化方式：

1、动态初始化

语法格式：

//指定数组长度数组名 = new 元素的数据类型[长度];​//为元素赋值数组名[下标] = 值; //这个值可以是个常量值，也可以是个表达式的计算结果，也可以是键盘输入的​//如果每个元素的赋值比较有规律，通常使用for循环赋值for(int i=0; i<长度; i++){    数组名[下标] = 值;}

问：如果只指定数组长度，没有为元素手动赋值，那么元素有值吗？

有默认值

（1）基本数据类型

byte,short,int,long：0

float,double：0.0

char：\u0000

boolean：false

（2）引用数据类型

统统都是null

 

2、静态初始化

语法格式：

数组名 = new 元素的数据类型[]{值列表};​//int[] arr = new int[5]{1,2,3,4,5};//错误的​//更简洁//当声明与静态初始化一起完成时，可以简化元素的数据类型[] 数组名 = {值列表};

适用场合：

当数组的元素是已知的有限个时，可以使用静态初始化。

示例代码：

String[] weeks = {"monday","tuesday","wednesday","thursday","friday","saturday","sunday"};​int[] daysOfMonths = {31,28,31,30,31,30,31,31,30,31,30,31};​char[] letters = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

 

4.2.3 数组的遍历

for循环遍历数组：

for(int i=0; i<数组名.lenght; i++){    //或赋值    数组名[i] = 值;    //或显示    System.out.println(数组名[i])；    //或其他操作    //例如：判断是否是偶数    if(数组名[i]%2==0){          //...    }}

 

4.2.4 数组的内存分析

元素是基本数据类型的一维数组内存分析：

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

 

int[] arr = new int[5];for(int i=0; i<arr.length; i++){    arr[i] = i+1;}

 

 

4.3 数组的相关算法

4.3.1 数组找最值

1、数组中找最值

思路：

（1）先假设第一个元素最大/最小

（2）然后用max/min与后面的元素一一比较

示例代码：

int[] arr = {4,5,6,1,9};//找最大值int max = arr[0];for(int i=1; i<arr.length; i++){    if(arr[i] > max){        max = arr[i];    }}

2、数组中找最值及其下标

情况一：找最值及其第一次出现的下标

思路：

（1）先假设第一个元素最大/最小

（2）然后用max/min与后面的元素一一比较

示例代码：

int[] arr = {4,5,6,1,9};//找最大值int max = arr[0];int index = 0;for(int i=1; i<arr.length; i++){    if(arr[i] > max){        max = arr[i];        index = i;    }}

或

int[] arr = {4,5,6,1,9};//找最大值int maxIndex = 0;for(int i=1; i<arr.length; i++){    if(arr[i] > arr[maxIndex]){        maxIndex = i;    }}System.out.println("最大值：" + arr[maxIndex]);

 

情况二：找最值及其所有最值的下标（即可能最大值重复）

思路：

（1）先找最大值

①假设第一个元素最大

②用max与后面的元素一一比较

（2）遍历数组，看哪些元素和最大值是一样的

示例代码：

int[] arr = {4,5,6,1,9};//找最大值int max = arr[0];for(int i=1; i<arr.length; i++){    if(arr[i] > max){        max = arr[i];    }}​//遍历数组，看哪些元素和最大值是一样的for(int i=0; i<arr.length; i++){    if(max == arr[i]){        System.out.print(i+"\t");    }}

 

4.3.2 数组统计：求总和、均值、统计偶数个数等

思路：遍历数组，挨个的累加，判断每一个元素

示例代码：

int[] arr = {4,5,6,1,9};//求总和、均值int sum = 0;//因为0加上任何数都不影响结果for(int i=0; i<arr.length; i++){    sum += arr[i];}double avg = (double)sum/arr.length;

示例代码2：

int[] arr = {4,5,6,1,9};​//求总乘积long result = 1;//因为1乘以任何数都不影响结果for(int i=0; i<arr.length; i++){    result *= arr[i];}

示例代码3：

int[] arr = {4,5,6,1,9};//统计偶数个数int even = 0;for(int i=0; i<arr.length; i++){    if(arr[i]%2==0){        even++;    }}

 

4.3.3 反转

方法有两种：

1、借助一个新数组

2、首尾对应位置交换

第一种方式示例代码：

int[] arr = {1,2,3,4,5,6,7,8,9};​//(1)先创建一个新数组int[] newArr = new int[arr.length];​//(2)复制元素int len = arr.length;for(int i=0; i<newArr.length; i++){    newArr[i] = arr[len -1 - i];}​//(3)舍弃旧的，让arr指向新数组arr = newArr;//这里把新数组的首地址赋值给了arr​//(4)遍历显示for(int i=0; i<arr.length; i++){    System.out.println(arr[i]);}

第二种方式示例代码：

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
    //首  与  尾交换
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

4.3.4 复制

应用场景：

1、扩容

2、备份

3、截取

示例代码：扩容

int[] arr = {1,2,3,4,5,6,7,8,9};​//如果要把arr数组扩容，增加1个位置//(1)先创建一个新数组，它的长度 = 旧数组的长度+1int[] newArr = new int[arr.length + 1];​//(2)复制元素//注意：i<arr.length   因位arr比newArr短，避免下标越界for(int i=0; i<arr.length; i++){    newArr[i] = arr[i];}​//(3)把新元素添加到newArr的最后newArr[newArr.length-1] = 新值;​//(4)如果下面继续使用arr，可以让arr指向新数组arr = newArr;​//(4)遍历显示for(int i=0; i<arr.length; i++){    System.out.println(arr[i]);}

示例代码：备份

int[] arr = {1,2,3,4,5,6,7,8,9};​//1、创建一个长度和原来的数组一样的新数组int[] newArr = new int[arr.length];​//2、复制元素for(int i=0; i<arr.length; i++){    newArr[i] = arr[i];}​//3、遍历显示for(int i=0; i<arr.length; i++){    System.out.println(arr[i]);}

示例代码：截取

int[] arr = {1,2,3,4,5,6,7,8,9};​int start = 2;int end = 5;​//1、创建一个新数组，新数组的长度 = end-start + 1;int[] newArr = new int[end-start+1];​//2、赋值元素for(int i=0; i<newArr.length; i++){    newArr[i] = arr[start + i];}​//3、遍历显示for(int i=0; i<newArr.length; i++){    System.out.println(newArr[i]);}

4.3.5 查找

查找分为两种：

1、顺序查找：挨个看

对数组没要求

2、二分查找：对折对折再对折

对数组有要求，元素必须有大小顺序的

顺序查找示例代码：

int[] arr = {4,5,6,1,9};int value = 1;int index = -1;​for(int i=0; i<arr.length; i++){    if(arr[i] == value){        index = i;        break;    }}​if(index==-1){    System.out.println(value + "不存在");}else{    System.out.println(value + "的下标是" + index);}

二分查找示例代码：

/*2、编写代码，使用二分查找法在数组中查找 int value = 2;是否存在，如果存在显示下标，不存在显示不存在。已知数组：int[] arr = {1,2,3,4,5,6,7,8,9,10};*/class Exam2{    public static void main(String[] args){        int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的        int value = 2;                int index = -1;        int left = 0;        int right = arr.length - 1;        int mid = (left + right)/2;        while(left<=right){            //找到结束            if(value == arr[mid]){                index = mid;                break;            }//没找到            else if(value > arr[mid]){//往右继续查找                //移动左边界，使得mid往右移动                left = mid + 1;            }else if(value < arr[mid]){//往左边继续查找                right = mid - 1;            }                        mid = (left + right)/2;        }                if(index==-1){            System.out.println(value + "不存在");        }else{            System.out.println(value + "的下标是" + index);        }            }}

使用for

class Exam2{    public static void main(String[] args){        int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的        int value = 2;                int index = -1;                for(int left=0,right=arr.length-1,mid = (left+right)/2; left<=right; mid = (left + right)/2){             //找到结束            if(value == arr[mid]){                index = mid;                break;            }//没找到            else if(value > arr[mid]){//往右继续查找                //移动左边界，使得mid往右移动                left = mid + 1;            }else if(value < arr[mid]){//往左边继续查找                right = mid - 1;            }        }                                if(index==-1){            System.out.println(value + "不存在");        }else{            System.out.println(value + "的下标是" + index);        }            }}

 

4.3.6 排序

数组的排序算法有千万种，我们只讲了两种：

1、冒泡排序

2、简单的直接排序

示例代码：冒泡：从小到大，从左到右两两比较

int[] arr = {5,4,6,3,1};for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1    /*    第1轮，i=1,从左到右两两比较，arr[0]与arr[1]。。。。。arr[3]与arr[4]    第2轮，i=2,从左到右两两比较，arr[0]与arr[1]。。。。。arr[2]与arr[3]    ...                    arr[j]与arr[j+1]比较    找两个关键点：（1）j的起始值：0（2）找j的终止值，依次是3,2,1,0，得出j<arr.length-i    */    for(int j=0; j<arr.length-i; j++){        //两两比较        //从小到大，说明前面的比后面的大，就交换        if(arr[j] > arr[j+1]){            int temp = arr[j];            arr[j] = arr[j+1];            arr[j+1] = temp;        }    }}

示例代码：从大到小，从右到左

char[] arr = {'h','e','l','l','o','j','a','v','a'};for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1    /*    第1轮，i=1，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[1]与arr[0]    第2轮，i=2，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[2]与arr[1]    ...    第8轮，i=8，从右到左两两比较，arr[8]与arr[7]               arr[j]与arr[j-1]    找两个关键点：（1）j的起始值：8（2）找j的终止值，依次是1,2,3,。。。8，得出j>=i    */    for(int j=8; j>=i; j--){        //从大到小，后面的元素 > 前面的元素，就交换        if(arr[j]>arr[j-1]){            int temp = arr[j];            arr[j] = arr[j-1];            arr[j-1] = temp;        }    }}   

示例代码：简单的直接选择排序

int[] arr = {3,2,6,1,8};​for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1    //（1）找出本轮未排序元素中的最值    /*    未排序元素：    第1轮：i=1,未排序，[0,4]    第2轮：i=2,未排序，[1,4]    ...        每一轮未排序元素的起始下标：0,1,2,3，正好是i-1的    未排序的后面的元素依次：    第1轮：[1,4]  j=1,2,3,4    第2轮：[2,4]  j=2,3,4    第3轮：[3,4]  j=3,4    第4轮：[4,4]  j=4    j的起点是i，终点都是4    */    int max = arr[i-1];    int index = i-1;    for(int j=i; j<arr.length; j++){        if(arr[j] > max){            max = arr[j];            index = j;        }    }        //（2）如果这个最值没有在它应该在的位置，就与这个位置的元素交换    /*    第1轮，最大值应该在[0]    第2轮，最大值应该在[1]    第3轮，最大值应该在[2]    第4轮，最大值应该在[3]    正好是i-1的值    */    if(index != i-1){        //交换arr[i-1]与arr[index]        int temp = arr[i-1];        arr[i-1] = arr[index];        arr[index] = temp;    }}​​​//显示结果for(int i=0; i<arr.length; i++){    System.out.print(arr[i]);}

 

4.4 二维数组

二维数组的标记：[][]

4.4.1 相关的表示方式

（1）二维数组的长度/行数：

二维数组名.length

（2）二维数组的其中一行：

二维数组名[行下标]

行下标的范围：[0, 二维数组名.length-1]

（3）每一行的列数：

二维数组名[行下标].length

因为二维数组的每一行是一个一维数组

（4）每一个元素

二维数组名[行下标][列下标]

4.4.2 二维数组的声明和初始化

1、二维数组的声明

  //推荐  元素的数据类型[][] 二维数组的名称;​ //不推荐 元素的数据类型  二维数组名[][]; //不推荐  元素的数据类型[]  二维数组名[];

面试：

int[] x, y[];//x是一维数组，y是二维数组

 

2、二维数组的初始化

（1）静态初始化

二维数组名 = new 元素的数据类型[][]{            {第一行的值列表},             {第二行的值列表},            ...            {第n行的值列表}        };        //如果声明与静态初始化一起完成元素的数据类型[][] 二维数组的名称 = {            {第一行的值列表},             {第二行的值列表},            ...            {第n行的值列表}        };

（2）动态初始化（不规则：每一行的列数可能不一样）

//（1）先确定总行数二维数组名 = new 元素的数据类型[总行数][];​//（2）再确定每一行的列数二维数组名[行下标] = new 元素的数据类型[该行的总列数];​//(3)再为元素赋值二维数组名[行下标][列下标] = 值;

（3）动态初始化（规则：每一行的列数是相同的）

//（1）确定行数和列数二维数组名 = new 元素的数据类型[总行数][每一行的列数];​//（2）再为元素赋值二维数组名[行下标][列下标] = 值;

 

4.4.3 二维数组的遍历

for(int i=0; i<二维数组名.length; i++){    for(int j=0; j<二维数组名[i].length; j++){        System.out.print(二维数组名[i][j]);    }    System.out.println();}

 

来源：https://www.cnblogs.com/wlx6/p/12300644.html