【JavaSE_06】Java中的数组（array）

矫情吗；* 2022-06-18 10:28 201阅读 0赞

\#1.什么是数组？  
顾名思义，即为数据的组合或集合，数组就是用来表示一组数据的。  
比如没有数组之前，我们要存储多个姓名的信息  
String name1;  
String name2;  
String name3;  
有了数组之后，我们可以这样  
String\[\] names;

\#2.数组的特点：  
（1）数组是用来存储一组相同数据类型的数据结构。  
（2）数组中的元素可以是任何数据类型(基本类型和引用类型)。

> int\[\] ints  
> double\[\] doubles  
> String\[\] names

（3）数组有一个对应的索引，可以通过索引访问数组中的每个元素。（0 –-- n-1）

（4）数组被创建好之后，它的大小（数组长度）是不能改变的，但是数组中的各个元素是可以被改变的。  
int\[\] ages = \{1,2,3,4,5,6\};  
总结：

（5）数组变量属于引用数据类型。// 所有的任何数组都是继承了Object  
int\[\] a ; a是引用数据类型（关于引用数据类型的细节，面向对象部分再来补充说明）

\#3.掌握数组的基本用法  
\#\#3.1.一维数组的声明  
一维数组声明有两种方式：  
数据类型 变量名 = 变量值  
数据类型\[\] 数组变量名;（推荐）  
数据类型 数组变量名\[\];  
注意：声明数组时不能指定数组长度。例如下面写法是错误的。  
int\[5\] array;//语法错误，编译不通过。  
int\[\] array;//正确写法  
\#\#3.2.一维数组的创建  
一维数组的创建，采用new来申请内存空间  
Java中使用关键字new 创建数组对象，指定数组的大小，给数组元素的存储分配空间  
格式：数组变量名 = new 数组元素的类型 \[数组元素的个数\];  
array = new int\[5\];  
例如：  
int\[\] a; //声明一个int类型的数组  
a = new int\[5\]; //创建一个int类型的数组，长度为5（存储5个int整数的数组）,并让变量a指向该数组;  
\#\#3.3.一维数组的赋值  
静态初始化是指，在创建数组对象的同时对数组进行初始化。  
静态初始化有两种方式：  
1、int\[\] a = new int\[\]\{1, 2, 3\}; //定义并创建数组，并初始化数组的元素为 1、2、3，同时数组的长度也被限定为为3。  
2、int\[\] a = \{1, 2, 3\}; //效果同上  
注意：不能这么写 int\[\] a = new int\[3\]\{1,2,3\};  
以上两种方式均不需要定义数组的长度，数组的长度由初始化时元素的个数来决定。

动态初始化是指把数组的创建和数组的初始化分开完成。  
例如：  
int\[\] a = new int\[3\];  
a\[0\] = 3; //通过元素索引(下标)来给数组元素赋值  
a\[1\]=4;  
a\[2\]=5;  
问题：动态赋值和静态赋值怎么选择？  
\#\#3.4.访问数组的元素  
通过下标访问数组元素，上述案例已经有了，注意一点：数组的下标从0开始以及数组的边界问题  
\#\#3.5.一维数组的遍历  
需掌握两种方式，并知道他们的区别  
1，采用最初学习for循环方式，这种方式可以打印出数组的元素  
2，采用一种新的循环遍历方式，增强for循环，这种方式只能输出数组元素，但访问不到下标  
\#\#3.6.练习1  
声明一个数组，并向其存储“5,8,1,7,6,19,10,3”这几个数字，  
分别采用静态和动态的方式进行数据的初始化  
最后采用两种循环方式打印出数组的数据。  
创建方法，用于打印数组的元素，方便后续调用  
\#\#3.7.练习2  
开发一个随机抽取学员回答问题的程序  
\#\#3.8.总结  
要求掌握的技能如下：  
数组的声明及初始化  
数组的遍历  
数组的下标特点

\#4.算法阶段（查找+排序）  
下面进入算法阶段：  
分两个步骤来学习：  
第一：分析这种算法的规律（最关键）-画图来说明  
第二：采用程序的方式来描述这种规律  
每讲完一种算法，练习一次

\#\#4.1.难点一：数组的查找  
\#\#\#4.1.1.顺序查找（简单）  
应用场景：数组的元素是没有顺序的，挨个找  
\#\#\#4.1.2.二分法查找  
应用场景：二分法查找的前提是数组已经排好序了  
查找的策略，就好比我们猜数字游戏的策略。  
基本思想：每次都猜中间的那个数字，猜大了或小了，就少了一半的元素，然后继续猜中间的数字

首先要明确一个查找的规则，就是先假设是中间的数字，如果是，那就找到了。  
如果不是，则分两种情况考虑  
–中间的数大了，则继续取前面一排数字的中间数来比较，规则同上  
–中间的数小了，则继续取后面一排数字的中间数来比较，规则同上  
规律是，根据情况，改变的是三个索引的值

min=0;  
max=array.length-1;  
mid=(max+min)/2;

关键条件，循环条件，根据两种情况来分析和找结论  
max>=min

\#\#4.2.求数组的最大数和最小数  
求最大值  
求最小值

> public class Test5MaxMin\{  
> public static void main(String\[\] args)\{  
> int\[\] nums = \{1,5,6,11,88,33,99,10,2,-1,-9\};  
> //max  
> int max = nums\[0\];  
> for(int i=1;i<nums.length;i++)\{  
> //目的：找比我大的值  
> if(max < nums\[i\])\{  
> max = nums\[i\];  
> \}  
> \}  
> System.out.println(max);

//min
    	int min = nums[0];
    	for(int i=1;i<nums.length;i++){
    		//目的：找比我更小的值
    		if(min > nums[i]){
    			min = nums[i];
    		}
    	}
    	System.out.println(min);
    }

\#\#4.3.难点二：数组的排序

\#\#\#4.3.1.冒泡排序（最重要）  
5,8,1,7,6 ,3  
？？？？？8  
？？？？7，8  
1,3,5,6,7,8  
冒泡排序，就是每次比较，大的元素往后挪，比较完第一遍后，最大的元素排到了数组的最后一位  
第二次比较，还是从第一个元素开始和后面的比较，把剩余的最大的元素拍到数组的倒数第二位，第一轮比较的最大元素不参与比较  
依次类推。

总结：相邻两个元素两两比较，大的往后挪，第一次比较结束后，最大的元素在数组的最大索引处。

> 第一步：  
> int\[\] source = \{5,8,1,7,6 ,3 \};  
> if(source\[0\]>source\[1\])\{  
> int temp = source\[0\];  
> source\[0\]=source\[1\];  
> source\[1\]=temp;  
> \}  
> if(source\[1\]>source\[2\])\{  
> int temp = source\[1\];  
> source\[1\]=source\[2\];  
> source\[2\]=temp;  
> \}  
> 第二步：  
> 将上述代码变成一个循环结构  
> for(int i=0;i<=nums.length-2;i++)\{  
> if(nums\[i\] > nums\[i+1\])\{  
> int temp = nums\[i\];  
> nums\[i\] = nums\[i+1\];  
> nums\[i+1\] = temp;  
> \}  
> \}  
> 第三步：每一次都是在改变临界条件  
> for(int i=0;i<=source.length-2-0;i++)\{//-0是为了总结出后面的外层循环规律  
> if(source\[i\]>source\[i+1\])\{  
> int temp = source\[i\];  
> source\[i\]=source\[i+1\];  
> source\[i+1\]=temp;  
> \}  
> \}  
> 第四步：  
> 再嵌套一层循环来改变这个值  
> for(int j=0;j<=source.length-2;j++)\{  
> for (int i = 0; i <= source.length - 2 - j; i++) \{  
> if (source\[i\] > source\[i + 1\]) \{  
> int temp = source\[i\];  
> source\[i\] = source\[i + 1\];  
> source\[i + 1\] = temp;  
> \}  
> \}  
> \}

\#\#\#4.3.2.选择排序（选择一个位置来存放最小的元素）  
基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

> 第一轮：  
> int k = 0;  
> for(int i=1;i<=ints.length-1;i++)\{  
> if(ints\[k\]>ints\[i\])\{  
> k = i;  
> \}  
> \}  
> int temp = ints\[0\];  
> ints\[0\] = ints\[k\];  
> ints\[k\] = temp;  
> 第二轮：  
> 就是将k新增1，即从1开始  
> k = 1;  
> for(int i=2;i<=ints.length-1;i++)\{  
> if(ints\[k\]>ints\[i\])\{  
> k = i;  
> \}  
> \}  
> temp = ints\[1\];  
> ints\[1\] = ints\[k\];  
> ints\[k\] = temp;  
> 以此类推，所以通过外层循环来控制即可  
> for(int j=0;j<=ints.length-2;j++)\{  
> int k = j;  
> for(int i=j+1;i<=ints.length-1;i++)\{  
> if(ints\[k\]>ints\[i\])\{  
> k = i;  
> \}  
> \}  
> int temp = ints\[j\];  
> ints\[j\] = ints\[k\];  
> ints\[k\] = temp;  
> \}

\#5.扩展  
可变参数  
继续认识main方法–args  
数组专家Arrays