java第二章数组
数组的概念和特点
数组的概念
- 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个 名字命名，并通过编号的方式对这些数据进行统一管理。
数组的特点
-
特点
-
是一个可以存储同一种数据类型元素的容器，对于同一个数组而言，里面的元素类型都是一样。
-
数组具有索引概念，从左向右，从0开始。
-
数组本身是
引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。 -
创建数组对象会在内存中开辟一整块
连续的空间。占据的空间的大小，取决于数组的长度和数组中元素的类型。 -
数组中的元素在内存中是依次紧密排列的，有序的。
-
数组名中引用的是这块连续空间的首地址。
-
数组，一旦初始化完成，其长度就是确定的。数组的
长度一旦确定，就不能修改。 -
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快
-
如何去定义一个一维数组
一维数组
- 语句定义格式：数组类型[] 数组名；
如何对一维数组进行初始化？
-
动态初始化
语句定义格式： 数据类型[] 数组名 = new 数据类型[m];
获取数组中的第一个元素 数据类型 赋值名 = 数组名[0]
int[] arr1 = new int[3]public class shuzu {public static void main(String[] args) {int[] arr1=new int[3];System.out.println(arr1);int res1 = arr1[0]System.out.println(res1); -
每运行一个java程序相当于是一个进程，一个进程系统会对此独立分配内存和cpu
JVM将内存划分为5各区域：
- 栈：存放的是方法上或方法内部定义的变量，方法的调用是栈中调用运行
- 堆：存放的都是一些new出来的东西
- 方法区：存放一些静态的，常量值，class文件对象，定义的方法初始化
- 本地方法区：和操作系统有关
- 寄存器：和CPU运行有关
-
静态初始化
-
一维数组的静态初始化
-
语句格式
-
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，......}；
-
简化写法：
数据类型[] 数组名 = {元素1，元素2，......};
-
-
int[] arr = new int[]{1,2,3,4,5};//正确
//或
int[] arr;
arr = new int[]{1,2,3,4,5};//正确
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分成两个语句写
- 例如，定义存储1，2，3，4，5整数的数组容器
int[] arr = {1,2,3,4,5};//正确int[] arr;
arr = {1,2,3,4,5};//错误
一维数组的遍历
- 搭配for 循环
public class Arraydemo1{ public static void main(String[] args) {int[] arr = new int[]{1,2,3,4,5};//遍历输出数组中的元素for(int i=0; i<arr.length; i++){//length表示数组长度 System.out.println(arr[i]);}}
}
默认值
- 如果说可以把一维数组当成几何中的
线性图形，那么二维数组就相当于是一个表格，像Excel中的表格、围棋棋盘一样。 - 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
- 小技巧：二维数组的两个中括号[][]中，第一个可以看做控制行数，第二个可以看做控制列数。
int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组
数组两种初始化方式的区别
静态初始化：int[] arr = {1,2,3,4,5};
动态初始化：int[] arr = new int[3];
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
使用场景
只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。
已经明确了要操作的所有数据，推荐使用静态初始化。
举例：
-
使用数组来存储键盘录入的5个整数。
int[] arr = new int[5];
-
将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100
int[] arr = new int[5];
arr[0] = 66;
arr[1] = 77;
所以建议使用静态初始化
数组常见的问题
越界：当访问了数组中不存在的索引，就会引发索引越界异常。
如何避免：
针对于任意一个数组，索引的范围： 最小索引：0 最大索引：数组的长度 - 1 数组名.length - 1
public class ArrDemo6 {public static void main(String[] args) {int[] arr = {1,2,3,4,5,5,5,5,5};//用索引来访问数组中的元素System.out.println(arr[1]);System.out.println(arr[10]);//ArrayIndexOutOfBoundsException}
}
二维数组
- 如果说可以把一维数组当成几何中的
线性图形，那么二维数组就相当于是一个表格，像Excel中的表格、围棋棋盘一样。 - 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
- 小技巧：二维数组的两个中括号[][]中，第一个可以看做控制行数，第二个可以看做控制列数。
int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组
二维数组的初始化
//推荐
元素的数据类型[][] 二维数组的名称;
//不推荐
元素的数据类型 二维数组名[][];
//不推荐
元素的数据类型[] 二维数组名[];
静态初始化
- 格式
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
- 例子
int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};int[][] arr;
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字public class TwoDimensionalArrayInitialize {public static void main(String[] args) {//存储多组成绩int[][] grades = {{89,75,99,100},{88,96,78,63,100,86},{56,63,58},{99,66,77,88}};}
}
格式2：不规则：每一行的列数不一样**
//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];//此时只是确定了总行数，每一行里面现在是null//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];//此时已经new完的行的元素就有默认值了，没有new的行还是null//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
int[][] arr = new int[3][];
- 二维数组中有3个一维数组。
- 每个一维数组都是默认初始化值null (注意：区别于格式1）
- 可以对这个三个一维数组分别进行初始化：arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
- 注：
int[][]arr = new int[][3];//非法
二维数组遍历
- 例子
双重for 循环
for(int i=0; i<二维数组名.length; i++){ //二维数组对象.lengthfor(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.lengthSystem.out.print(二维数组名[i][j]);}System.out.println();
}
//1、声明二维数组，并确定行数和列数int[][] arr = new int[4][5];//2、确定元素的值for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr.length; j++) {arr[i][j] = i + 1;}}
public class Test{public static void main(String[] args) {//存储3个小组的学员的成绩，分开存储，使用二维数组。int[][] scores = {{85,96,85,75},{99,96,74,72,75},{52,42,56,75}};System.out.println("一共有" + scores.length +"组成绩.");for (int i = 0; i < scores.length; i++) {System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下：");for (int j = 0; j < scores[i].length; j++) {System.out.print(scores[i][j]+"\t");}System.out.println();}}
}
数组的常见题目以及代码
例子1：数组统计：求总和、均值
public class TestArrayElementSum {public static void main(String[] args) {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;System.out.println("sum = " + sum);System.out.println("avg = " + avg);}
}
例子2：求数组元素的总乘积
public class TestArrayElementMul {public static void main(String[] args) {int[] arr = {4,5,6,1,9};//求总乘积long result = 1;//因为1乘以任何数都不影响结果for(int i=0; i<arr.length; i++){result *= arr[i];}System.out.println("result = " + result);}
}
例子3：求数组元素中偶数的个数
public class TestArrayElementEvenCount {public static void main(String[] args) {int[] arr = {4,5,6,1,9};//统计偶数个数int evenCount = 0;for(int i=0; i<arr.length; i++){if(arr[i]%2==0){evenCount++;}}System.out.println("evenCount = " + evenCount);}
}
例子4：求数组元素的最大值
public class TestArrayMax {public static void main(String[] args) {int[] arr = {4,5,6,1,9};//找最大值int max = arr[0];for(int i=1; i<arr.length; i++){//此处i从1开始，是max不需要与arr[0]再比较一次了if(arr[i] > max){max = arr[i];}}System.out.println("max = " + max);}
}
例子5：找最值及其第一次出现的下标:
public class TestMaxIndex {public static void main(String[] args) {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;}}System.out.println("max = " + max);System.out.println("index = " + index);}
}
数组元素的反转
实现思想：数组对称位置的元素互换。
public class TestArrayReverse1 {public static void main(String[] args) {int[] arr = {1,2,3,4,5};System.out.println("反转之前：");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}//反转/*思路：首尾对应位置的元素交换（1）确定交换几次次数 = 数组.length / 2（2）谁和谁交换for(int i=0; i<次数; i++){int temp = arr[i];arr[i] = arr[arr.length-1-i];arr[arr.length-1-i] = temp;}*/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;}System.out.println("反转之后：");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}}
双指针
public class TestArrayReverse2 {public static void main(String[] args) {int[] arr = {1,2,3,4,5};System.out.println("反转之前：");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}//反转//左右对称位置交换for(int left=0,right=arr.length-1; left<right; left++,right--){//首 与 尾交换int temp = arr[left];arr[left] = arr[right];arr[right] = temp;}System.out.println("反转之后：");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}
数组的元素查找
1、顺序查找
public class TestArrayOrderSearch {//查找value第一次在数组中出现的indexpublic static void main(String[] args){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[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true;
int value = 256;
//int value = 25;
int head = 0;//首索引位置
int end = arr3.length - 1;//尾索引位置
while(head <= end){int middle = (head + end) / 2;if(arr3[middle] == value){System.out.println("找到指定的元素，索引为：" + middle);isFlag = false;break;}else if(arr3[middle] > value){end = middle - 1;}else{//arr3[middle] < valuehead = middle + 1;}
}
if(isFlag){System.out.println("未找打指定的元素");
}排序算法
冒泡排序
排序思想：
-
比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
-
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
动态演示：https://visualgo.net/zh/sorting
/*
1、冒泡排序（最经典）
思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），就交换它们，经过多轮比较，最终实现排序。（例如：从小到大） 每一轮可以把最大的沉底，或最小的冒顶。过程：arr{6,9,2,9,1} 目标：从小到大第一轮：第1次，arr[0]与arr[1]，6>9不成立，满足目标要求，不交换第2次，arr[1]与arr[2]，9>2成立，不满足目标要求，交换arr[1]与arr[2] {6,2,9,9,1}第3次，arr[2]与arr[3]，9>9不成立，满足目标要求，不交换第4次，arr[3]与arr[4]，9>1成立，不满足目标要求，交换arr[3]与arr[4] {6,2,9,1,9}第一轮所有元素{6,9,2,9,1}已经都参与了比较，结束。第一轮的结果：第“一”最大值9沉底（本次是后面的9沉底），即到{6,2,9,1,9}元素的最右边第二轮：第1次，arr[0]与arr[1]，6>2成立，不满足目标要求，交换arr[0]与arr[1] {2,6,9,1,9}第2次，arr[1]与arr[2]，6>9不成立，满足目标要求，不交换第3次：arr[2]与arr[3]，9>1成立，不满足目标要求，交换arr[2]与arr[3] {2,6,1,9,9}第二轮未排序的所有元素 {6,2,9,1}已经都参与了比较，结束。第二轮的结果：第“二”最大值9沉底（本次是前面的9沉底），即到{2,6,1,9}元素的最右边
第三轮：第1次，arr[0]与arr[1]，2>6不成立，满足目标要求，不交换第2次，arr[1]与arr[2]，6>1成立，不满足目标要求，交换arr[1]与arr[2] {2,1,6,9,9}第三轮未排序的所有元素{2,6,1}已经都参与了比较，结束。第三轮的结果：第三最大值6沉底，即到 {2,1,6}元素的最右边
第四轮：第1次，arr[0]与arr[1]，2>1成立，不满足目标要求，交换arr[0]与arr[1] {1,2,6,9,9}第四轮未排序的所有元素{2,1}已经都参与了比较，结束。第四轮的结果：第四最大值2沉底，即到{1,2}元素的最右边*/
public class Test19BubbleSort{public static void main(String[] args){int[] arr = {6,9,2,9,1};//目标：从小到大//冒泡排序的轮数 = 元素的总个数 - 1//轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套//外循环控制 轮数，内循环控制每一轮的比较次数和过程for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮/*假设arr.length=5i=1,第1轮，比较4次arr[0]与arr[1]arr[1]与arr[2]arr[2]与arr[3]arr[3]与arr[4]arr[j]与arr[j+1]，int j=0;j<4; j++i=2,第2轮，比较3次arr[0]与arr[1]arr[1]与arr[2]arr[2]与arr[3]arr[j]与arr[j+1]，int j=0;j<3; j++i=3,第3轮，比较2次arr[0]与arr[1]arr[1]与arr[2]arr[j]与arr[j+1]，int j=0;j<2; j++i=4,第4轮，比较1次arr[0]与arr[1]arr[j]与arr[j+1]，int j=0;j<1; j++int j=0; j<arr.length-i; j++*/for(int j=0; j<arr.length-i; j++){//希望的是arr[j] < arr[j+1]if(arr[j] > arr[j+1]){//交换arr[j]与arr[j+1]int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}//完成排序，遍历结果for(int i=0; i<arr.length; i++){System.out.print(arr[i]+" ");}}
}
