一、 一维数组
1 .一维数组基础知识
定义：存储一组相同类型数据的空间
数组和变量的区别：
（1）变量中只能存储一个数据
（2）数组中可以存储多个相同类型的数据
注意：数组属于引用数据类型
2.数组组成成份
数据类型：描述的是数组中的元素类型，数组的数据元素是一组相同类型的数据
数组名：数组名的命名规则和变量名的命名规则相同
元素下标：因为数组在内存中是连续的空间，所以会给数组里的元素按照顺序进行编号，编 号从0 开始，我们把这个编号叫下标(索引)
数组长度：数组中元素的数量
3.数组名的命名规则
（1） 由字母、数字、下划线( _ )、美元符号($)组成
（2）不能以数字开头，不建议使用美元符号($)开头
（3） 不能是关键字
（4） 严格区分字母大小写
（5）采用小驼峰命名法
（6）数组命名要做到见名知意，见到数组名就知道代表的具体含义
4.数组格式
数组的声明： 数据类型[ ] 数组名；或 数据类型 数组名[ ]；
作用：声明数组元素的类型
分配存储空间：数组名 = new 数据类型[数组长度];
作用：分配用来存储数据的空间
赋值：数组名[下标] = 数据;
作用：将数据存储到数组中
操作数据：通过数组名[下标]来操作数据对数据进行加减乘除等操作
数组的声明数组、分配空间合并写格式
数据类型[] 数组名 = new 数据类型[数组长度]
数据类型 数组名[] = new 数据类型[数组长度]
数组的 声明数组、分配空间、赋值合并写的简写格式
数据类型[ ] 数组名 = new 数组类型[ ]{数据元素1，数据元素2，数据元素3，数据元素n}
数据类型 数组名[ ] = new 数组类型[ ]{数据元素1，数据元素2，数据元素3，数据元素n
数据类型[ ] 数组名 = {数据元素1，数据元素2，数据元素3，数据元素n}
数据类型 数组名[ ] = {数据元素1，数据元素2，数据元素3，数据元素n
数据类型元素默认值
| 数据类型 | 默认初始值 |
| byte、short、in、long | 0 |
| float、double | 0.0 |
| char | 一个空字符，即 '\u0000' |
| boolean | false |
| 引用数据类型 | null,表示不引用任何对象 |
.
5.遍历数组：
定义：将数组中元素按照下标顺序依次输出
（1）普通for循环遍历数组
格式：
for(int i = 0;i<数组名.length;i++){
System.out.println(数组名[i]);
}
（2）增强for循环遍历数组
格式：
for(元素类型 变量名:数组名){
System.out.println(变量名);
}
执行规律：
将数组或集合中的元素依次取出存入到变量中，然后操作变量就等同于操作数组或集合中的元素数据
注意：
1. 增强for循环执行效率要比普通for循环要高！
2.数组每把一个元素存入到变量，变量会立即输出这个数组元素的值
6.数组的应用
1. 求数组中的最大值/最小值
思路：
（1）假设数组中第一个元素（下标为0的元素）为最大值/最小值。
（2）然后依次将后面元素和假设的最大值/最小值进行比较。
（3）如果后续元素比假设的最大值/最小值大/小的话，就取代假设的最大值/最小值，成为新的最大值/最小值。
（4）比较完数组里所有的元素后，获得最大值/最小值。
例：有一组数据{ 56 ，73 ，60 ，87 ，90 ， 110， 21} 要求：选出最大值和最小值
package test;
public class Subject11 {
public static void main(String[] args) {
//例：有一组数据{ 56 ，73 ，60 ，87 ，90 ， 110， 21}要求：选出最大值和最小值
int[] nums = {56,73,60,87,90,110,21}; //定义数组存放数据
//求最大值
int max = nums[0]; //设置变量max初始值
for(int i=0;i < nums.length; i++){ //普通for循环
if(nums[i]>max){ //数组元素与变量max进行比较
max = nums[i]; //把数组元素的最大值赋值给变量max
}
}
System.out.println("数组元素的最大值:"+max);
//求最小值
int min = nums[0]; //设置变量min初始值
for(int i=0;i < nums.length; i++){ //普通for循环
if(nums[i]<min){ //数组元素与变量min进行比较
min = nums[i]; //把数组元素的最小值赋值给变量min
}
}
System.out.println("数组元素的最大值:"+min);
}
}
2.数组中添加元素问题·
思路：
（1）声明一个长度比原来数组长度大1的数组
（2）将原来数组里元素按照顺序存入到新的数组中
（3）使用Scanner类获取你要增加的学员成绩
（4）通过循环比较获取增加的学员成绩的插入位置
（5）插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始倒着移动）
（6）将要插入的成绩存储到插入位置
例：有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。
要求： 要增加一个学员的成绩，将它插入成绩序列，并保持降序
package test;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
/*有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。
*
* 要增加一个学员的成绩，将它插入成绩序列，并保持降序*/
int[] scores = {90,85,82,63,60,50};
//声明一个长度比原来数组长度大1的数组
int[] newScores = new int[scores.length+1];
//将原来数组里元素按照顺序存入到新的数组中
for(int i=0;i<scores.length;i++){
newScores[i]=scores[i];
}
//使用Scanner类获取你要增加的学员成绩
Scanner xs = new Scanner(System.in);
//从键盘输入要插入的数据
System.out.println("请输入要插入的学生成绩：");
int insert = xs.nextInt();
// 设置插入的成绩插入的位置，默认将其插入在数组最后位置
int index=newScores.length-1;
//通过循环比较获取增加的学员成绩的插入位置
for(int i = 0;i<newScores.length;i++){
if(newScores[i]<insert){
index=i;
break;
}
}
//从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
for (int i = newScores.length - 1; i > index; i--) {
newScores[i] = newScores[i - 1];
}
//将要插入的成绩存储到插入位置
newScores[index] = insert;
//遍历数组 输出数组里的所有元素，看一下是否满足了需求
for (int j :newScores) {
System.out.print(j+" ");
}
}
}
3.冒泡排序法
思路：
（1）将数组中元素两两比较，大的数往后排（小的数）往后排（往前排）
（2）每一轮将大数（小数）排在最后面（最前面）位置。
（3）多轮比较后，得出升序（降序）排列的数组。
例：现有一个数组{20,80,60,85,90,60.98}需要进行升序排序
package test;
public class MoPo {
public static void main(String[] args) {
//定义数组
int[] nums = {20,80,60,85,90,60,98};
//外循环控制比较的轮数
for(int i=0;i<nums.length-1;i++){
//内循环控制每一轮比较的次数
for(int j=0;j<nums.length-1-i;j++){
//比较相邻的两个元素，如果前面的元素比后面的元素大交换元素位置
if(nums[i]>nums[i+1]){
//设置一个变量，存储数值大的元素，用来交换位置
int temp = nums[i];
nums[i] = nums[i+1];
nums[i+1] = temp;
}
}
}
//遍历数组，输出排序后的结果
for(int k:nums){
System.out.print(k+" ");
}
}
}
二 、二维数组
定义：元素为一维数组的一维数组
1.语法格式:
数组声明：
数据类型[ ] [ ] 数组名；
分配空间：
数组名 = new 数据类型[数组长度][数组长度];
数组名 = new 数据类型[数组长度][ ];
赋值：
数组名[下标][下标] = 数据;
二维数组声明、分配空间合并写格式：
数据类型[ ][ ] 数组名 = new 数据类型[长度][长度];
数据类型[ ][ ] 数组名 = new 数据类型[长度][ ];
二维数组声明、分配空间、赋值合并写：
数组类型[ ][ ] 数组名 = { {元素1,元素2,元素n},{元素1,元素2,元素n},···,{元素1,元素2,}，{元素1,元素2,元素n} };
数组类型[ ][ ] 数组名 = new 数组类型[ ][ ] { {元素1,元素2,元素n},{元素1,元素2,元素n},···,{元素1,元素2,}，{元素1,元素2,元素n} };
注意：二为数组本质上还是一个一维数组，只是这个一维数组里的元素还是一个一维数组
2、遍历数组
（1）普通for循环结构遍历二维数组
格式：
for(int i = 0;i<数组名.length;i++){
for(int j = 0;j<元素数组名[i].length;j++){
System.out.println(数组名[i][j]);
}
}
（2）增强for循环结构遍历二维数组
格式：
for( 数据类型[ ] 一维数组名 ：二维数组名 ){
for（数据类型 变量名 ：一维数组名 ）{
System.out.println(变量名);
}
}
执行规律：
（1）先定义一个一维数组，把二维数组中的元素值存入到一维数组当中
（2）将数组或集合中的元素依次取出存入到变量中，然后操作变量就等同于操作数组或集合中的元素数据
3.多维数组
（1）Java中操作多维数组的语法与一维数组类似。
（2）在实际应用中，三维以上的数组很少使用，主要使用二维数组。
（3）二维数组是一个元素为一维数组的一维数组。
（4）从语法上Java支持多维数组，但从内存分配原理的角度看，Java中只有一维数组，没有多维数组。或者说，从表面上是多维数组，实质上都是一维数组。
例：已知有3个班级各5名学员，请使用 二维数组计算各个班级的总成绩
思路：
（1）根据题意先创建二维数组
（2）因为是从键盘输入数据，所以要创建键盘输入对象
（3）利用嵌套for控制班级的数量和每个班级的人数，从键盘输入每个班级学生成绩
（4）利用变量存储每个班级的总成绩，最后输出每个班级学生的总成绩
package homework;
import java.util.Scanner;
public class Xscj {
public static void main(String[] args) {
double[][] scores = new double[3][5]; //根据题意定义数组
Scanner xs = new Scanner(System.in); //创建键盘输入对象
double sum=0; //初始值
for(int i=0;i<3;i++){ //外层for循环控制班级的数量
for(int j=0;j<5;j++){ //内层for循环控制需要输入成绩的人数
System.out.println("请输入第"+(i+1)+"班,第"+(j+1)+"位同学考试成绩：");
scores[i][j]= xs.nextDouble(); //由键盘输入学生成绩
sum+=scores[i][j]; //每个班级的学生成绩进行累加
}
System.out.println("第"+(i+1)+"班,考试成绩总成绩："+sum);
if(sum>0){
sum=0; //求出每个班级的总成绩，进行清零,方便统计下一个班级的总成绩
}
System.out.println("------------------------------------------------------");
}
}
}
例：从键盘上输入一个 3*4 的整型数组，求出其中的最大值和最小值，并显示输出
思路：
（1）根据题意先创建二维数组
（2）因为是从键盘输入数据，所以要创建键盘输入对象
（3）二维数组是分行和列，所以利用嵌套for循环结构从键盘输入二维数组元素的值
（4）利用嵌套for循环结构，遍历二维数组里的元素，把元素放在同一行转换成一维数组求最值问题
（5）假设二维数组第一个元素最大和最小，把元素存入到变量max和min 利用嵌套for循环，外层for循环控制比较轮数，内层for循环控制每一轮的比较次数，进行元素数值大小的比较
package homework;
import java.util.Scanner;
public class Subject {
public static void main(String[] args) {
//定义数组
int[][] nums = new int[3][4];
//创建键盘输入对象
Scanner sc = new Scanner(System.in);
for(int i=0;i<nums.length;i++) { //外层for循环控制行数
for(int j=0;j<nums[i].length;j++) { //内层for循环控制行数
System.out.println("请输入第"+(i+1)+"行第"+(j+1)+"列数组的值: ");
nums[i][j]=sc.nextInt(); //从键盘输入数值
}
}
//增强for循环结构遍历二维数组
//定义一维数组，把二维数组的元素存入一维数组
for(int[] k :nums) {
// 一维数组中每存入一个元素到变量中，变量就会立即输出这一个元素
for(int n :k) {
System.out.print(n+" "); //输出二维数组元素
}
}
System.out.println(); //换行操作
int max = nums[0][0]; //初始值
int min = nums[0][0]; //初始值
for (int i = 0; i < nums.length; i++) { //外层for循环控制比较的轮数
for (int j = 0; j < nums.length; j++) { //内层for循环控制每一轮比较的次数
if (nums[i][j] > max) { //元素数值大小的比较
max = nums[i][j]; //把最大的二维数组元素存入到变量max中
}
if (nums[i][j] < min) { //元素数值大小的比较
min = nums[i][j]; //把最小的二维数组元素存入到变量min中
}
}
}
System.out.println("数组中的最大值是：" + max); //输出二维数组最大值
System.out.println("数组中的最小值是：" + min); //输出二维数组最小值
}
}