数组

数组(array)：

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

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

2、数组名：

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

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

3、下标(index)：

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

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

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

4、元素(element)：

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

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

5、数组的长度(length)

数组中元素的总个数。

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

数组的相关语法

数组的声明

语法格式： 元素的数据类型[] 数组名;

 //或者如下 元素的数据类型  数组名[];

示例：

int[] array; char[] array; ​String[] array;

数组的初始化

初始化的目的：

（1）确定数组的长度

（2）为元素赋值

两种初始化方式：

1、动态初始化

语法格式：

//指定数组长度 数组名 = new 元素的数据类型[长度];

//为元素赋值 数组名[下标] = 值; //这个值可以是个常量值，也可以是个表达式的计算结果，也可以是键盘输入的

//如果每个元素的赋值比较有规律，通常使用for循环赋值 for(int i=0; i<长度; i++){     数组名[下标] = 值; }

2、静态初始化

语法格式：

数组名 = new 元素的数据类型[]{值列表};

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

适用场合：

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

示例代码：

String[] week = {"monday","tuesday","wednesday","thursday","friday"};

int[] day = {31,28,31,31};

char[] letters = {'a','b','c','d','e','f''};

数组的遍历

for循环遍历数组：

for(int i=0; i<数组名.lenght; i++){ //或赋值 数组名[i] = 值; //或显示 System.out.println(数组名[i]); } }

数组的相关算法

数组找最值

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;     } }

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

（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");     } }

反转

方法有两种：

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]); }

复制

应用场景：

1、扩容

2、备份

3、截取

示例代码：扩容

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

//如果要把arr数组扩容，增加1个位置 //(1)先创建一个新数组，它的长度 = 旧数组的长度+1 int[] 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]); }

查找

查找分为两种：

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); }

二分查找示例代码：

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);         }     }

排序

1、冒泡排序

2、简单的直接排序

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

int[] arr = {5,4,6,3,1}; for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1

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;         }     } }

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

int[] arr = {3,2,6,1,8};

for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1

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;         }     }

 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]); }