1. 概念
数组是一个容器。存储多个相同类型的数据。 空间大小固定。
数组也就是一个变量，引用数据类型，默认值null，2块内存。(一块在堆，存储的是数据。一块是在栈内存，存储变量名称)
2. 一维数组[]
2.1 语法1
创建变量:
[修饰符] 数据类型 变量名 = 数据;
1.数据类型[] 变量/数组名称/引用 = new 数据类型[length]; // 初始化数组变量 开辟空间
开辟length个空间====> 数组中最多存储length个元素/数据
length: 数组元素的个数
public static void main(String[] args) {
//需求: 使用数组维护多个学生的成绩。
//1.创建数组: 数据类型[] 变量/数组名称/引用 = new 数据类型[length];
double[] scoreArray = new double[3]; // 初始化数组变量(已经占据内存)
//length=30 数组的空间大小 或者说数组的元素个数
//有默认值 元素类型的默认值
//int num = 200;
//System.out.println(num);
//System.out.println(scoreArray);
//System.out.println(scoreArray.toString());//[D@3ac3fd8b 16进制的hashcode值
//在数组中 每个数据都有索引 index(0-(length-1))
//访问数组元素: 数组名称[index]
//---------------获得数组的每个元素数据---------------
double firstData = scoreArray[0];
System.out.println("第一个数据:" + firstData);
System.out.println("第2个数据:" + scoreArray[1]);
System.out.println("第3个数据:" + scoreArray[2]);
//java.lang.ArrayIndexOutOfBoundsException 数组索引越界
//System.out.println(scoreArray[3]);
//----------------添加数组数据----------------
System.out.println("-----------------------------");
scoreArray[0] = 100;
scoreArray[1] = 90;
scoreArray[2] = 99;
System.out.println("第一个数据:" + scoreArray[0]);
System.out.println("第2个数据:" + scoreArray[1]);
System.out.println("第3个数据:" + scoreArray[2]);
//--------------修改数组元素-----------
scoreArray[0] = 88;
System.out.println("第一个数据:" + scoreArray[0]);
System.out.println("第2个数据:" + scoreArray[1]);
System.out.println("第3个数据:" + scoreArray[2]);
}
2.2 遍历数组元素
public static void main(String[] args) {
int[] array = new int[5];
array[0] = 100;
array[1] = 200;
//语法: 数组名称.length;
System.out.println("获得数组的长度:" + array.length);
//循环---> while do...while for
//循环遍历数组的元素数据
/*int index = 0;
int length = array.length;
while (index < length) {
System.out.println(array[index++]);
}*/
/* for (int index = 0, length = array.length; index < length; ) {
System.out.println(array[index++]);
}*/
//普通for循环
/* for (int index = 0; index < array.length; index++) {
System.out.println("第" + (index + 1) + "个数组元素是:" + array[index]);
}*/
//新的遍历数组的方式: 增强for循环
/*for(数组元素类型 变量名称:数组名称){//将指定数组里面的每个元素分别赋值给了变量
//循环体
}*/
//弊端: 不能直接获得索引
int count = 1;
for (int a : array) {
System.out.println("第" + count + "个数组元素是:" + a);
count++;
}
}
2.3 语法2
1. 声明数组
数据类型[] 数组名；
2. 赋值
数组名 = new 数据类型[length];
2.4 语法3
一般测试使用
数据类型[] 数组名称 = {数据1,数据2....数据n}； //静态初始化
2.5 语法4
1. 声明数组
数据类型[] 数组名；
2. 赋值
数组名 = new 数据类型[]{数据1,数据2....数据n};
int[] array1 =new int[] {1, 2, 3};
int[] array;
array = new int[]{1, 2, 3};
2.6 案例
1. 动态录入数据
1.使用数组实现: 动态录入学生的个数以及每个的成绩 求得学生成绩总分 打印每个学生的成绩。
public static void main(String[] args) {
//动态录入学生的个数以及每个学生的成绩 求得学生成绩总分 打印每个学生的成绩。
Scanner input = new Scanner(System.in);
System.out.println("学生的个数:");
int num = input.nextInt();
double sum = 0;
double[] scoreArray = new double[num];
for (int i = 1; i <= num; i++) {
System.out.println("请录入第" + (i) + "个学生的成绩:");
double score = input.nextDouble();
sum += score;
//录入的每个成绩存储数组中
scoreArray[i - 1] = score;
}
System.out.println("--------------------------");
System.out.println("学生的总分:" + sum);
//循环遍历打印
int count = 1;
for (double studentScore : scoreArray) {
System.out.println("第" + (count++) + "个学生的成绩:" + studentScore);
}
input.close();
}
2. 数组比较
1.比较2个数组元素是否一致。
public static void main(String[] args) {
//比较2个数组元素是否一致。 == equals
int[] array1 = {1, 2, 3};
int[] array2 = {0, 2, 3};
//=赋值
//基本数据类型 赋值的是数据
//引用数据类型 赋值的是地址值
//==: 比较的是什么？
//局部变量: 基本数据类型 比较的是数据 引用数据类型 比较的是内存地址值
//System.out.println(array1 == array2);//false
//所有的引用数据类型都可以使用equals
//System.out.println(array1.equals(array2));//false
int length1 = array1.length;
int length2 = array2.length;
if (length1 != length2) {
System.out.println("这2个数组的元素肯定是不一致的 false");
return;
}
//比较相同索引下的2个数组数据是否一致
//有1个数值不一样 就不用继续了
for (int index = 0; index < length1; index++) {
if (array1[index] != array2[index]) {
System.out.println("这2个数组的元素肯定是不一致的 false");
return;
}
}
System.out.println("这2个数组的元素肯定是一致的 true");
}
3. 数组元素最值
1.求数组元素最值
public static void main(String[] args) {
//动态录入学生的个数以及每个的成绩 求得学生成绩总分 打印每个学生的成绩。
//最高分 最低分
Scanner input = new Scanner(System.in);
System.out.println("录入学生的个数：");
int num = input.nextInt();
int[] scoreArray = new int[num];
int max = 0;
int min = 0;
//在录入成绩的这个地方 直接求最值
for (int i = 1; i <= num; i++) {
System.out.println("请录入第" + i + "个学生的成绩:");
int score = input.nextInt();
scoreArray[i - 1] = score;
if (i == 1) {
max = score;
min = score;
continue;
}
max = Math.max(max, score);
min = Math.min(min, score);
}
//遍历数组元素
/*for (int score : scoreArray) {
System.out.println("成绩:" + score);
//三元运算符
max = (max > score) ? max : score;
min = (min > score) ? score : min;
}*/
/* for (int index = 1; index < scoreArray.length; index++) {
max = Math.max(max, scoreArray[index]);
min = Math.min(min, scoreArray[index]);
}
*/
//2个数据作比较----> 最大值与后面的元素做比较
System.out.println("成绩最高分:" + max);
System.out.println("成绩最低分:" + min);
}
4. 数组扩容
public static void main(String[] args) {
//数组的元素是连贯的 空间一旦固定 无法改变数组的空间的
//创建2个字符串数组： 将其中一个数组的所有的元素都赋值放入另外一个数组里面。
//String: null
String[] arr1 = new String[5];
arr1[0] = "a";
arr1[1] = "B";
arr1[2] = "c";
String[] arr2 = {"1", "2", "3"};
//需要将arr2的所有的数据都存储到arr1里面
//String数组里面 没有赋值的 当前元素都是null
//核心: 找到第一个null值出现的位置
int length = arr1.length;
int index = 0;
for (; index < length; index++) {
if (arr1[index] == null) {
break;
}
}
//index:就是第一个null的值得索引位置 维护arr1里面有效的元素的个数 3
//判断arr1的剩余空间是否足够
int leftSpace = length - index;//arr1剩余空间
int length2 = arr2.length;
if (length2 > leftSpace) {
//arr1空间不足的-----> 手动扩容----> new ---> 扩大的空间是我们自定义的
String[] newArray = new String[index + length2];
for (int i = 0; i < index; i++) {
newArray[i] = arr1[i];
}
arr1 = newArray;
// arr1 = Arrays.copyOf(arr1,index+length2);
}
for (String s : arr2) {
arr1[index++] = s;
}
//数组的所有的数据: 遍历
//Arrays java.util.Arrays 提供了很多操作数组元素的功能
System.out.println(arr1);
//将数组里面的元素转换成字符串进行打印输出
System.out.println("arr1的元素:" + Arrays.toString(arr1));
}
5. 删除数组元素
public static void main(String[] args) {
//数组元素是连贯的
//数组的空间是固定的
String[] array = {"a", "a", "aaaa", "dhh"};
//删除数组里面的a 删除数据就是把指定的索引的内容变为类型的默认值即可
//找到a元素的索引位置
int length = array.length;
for (int index = 0; index < length; index++) {
if ("a".equals(array[index])) {
//array[index] = null;//可以省略?
//右边元素要循环向左移动位置
for (int j = index; j < length - 1; j++) {
array[j] = array[j + 1];
}
array[length - 1] = null;
if ("a".equals(array[index])) {
index--;
}
}
}
System.out.println("删除之后:" + Arrays.toString(array));
}
2.7 排序(了解)、
数组的元素完全无序的。升序或者降序排列数组的元素。
1. 冒泡排序
将相邻的两个元素进行比较，最大的值放在右端。
流程: N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。
int[] array = {89, 100, 0, 78};
length = array.length;
一共要经过3轮排序
第一轮:
指针指向第一个元素89 89余与100比较 89<100 不交换
指针指向第2个元素100 100与0比较 100>0 交换位置 89 0 100 78
指针指向第3个元素100 100与78 100>78 交换位置 89 0 78 100
第2轮:
指针指向第一个元素89 89与0 交换位置 0 89 78 100
指针指向第2个元素89 89与78 交换位置 0 78 89 100
第3轮:
指针指向第一个元素0 不交换 0 78 89 100
//代码实现
for(int i=1;i<length;i++){
for(int j=0;j<length-i;j++){
if(array[j]>array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
2. 选择排序
交换次数少于冒泡。
从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；重复上述步骤，直到所有的元素都排成由小到大为止
当前元素与最小元素交换。
int[] array = {89, 100, 0, 78};
length = array.length;
一共要经过3轮排序
第一轮:
指针指向第一个元素: 89 min=89
89与100比 89<100 最小值还是89
89与0比较 89>0 最小值为0
0与78比较 0<78 最小值还是0
0与89交换位置 0 100 89 78
第2轮:
指针指向第2个元素100 min=100
100 与89 min=89
89与78 min=78
78与100交换 0 78 89 100
第3轮:
指针指向第3个元素89
89与100 min=89
89与89交换(当前元素与最小值元素正好一致)
for(int i=0;i<length-1;i++){
int min = array[i];
int minIndex = i;
for(int j=i+1;j<length;j++){
if(min>array[j]){
min = array[j];
minIndex = j;
}
}
//交换位置
if(i!=minIndex){
int temp = array[i];
array[i] = min;
array[minIndex] = temp;
}
}
3. 插入排序
将指针指向某个==(第二个)==元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止.
此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；
指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。
int[] array = {89, 100, 0, 78};
第一轮:
指针指向第2个元素:100 89，_,0,78
100与89比较 不需要右移
当前元素填补空位: 89 100 0 78
第2轮:
指针指向第3个元素 0 89 100 _ 78
0与100 100右移 89 _ 100 78
0与89比较 89右移 _ 89 100 78
当前元素填补空位: 0 89 100 78
第3轮:
指针指向第4个元素 78
0 78 89 100
for(int i=1;i<length;i++){
int temp=array[i];//当前第几个元素
int leftIndex =i-1;//左边元素索引
while(leftIndex>=0 && array[leftIndex]>temp){
//左边元素向右移动
array[leftIndex+1] = array[leftIndex];
leftIndex--;
}
//当前元素填补空位
array[leftIndex+1] = temp;
}
3. Arrays
jdk开发工具包里面提供了一个工具类 主要是操作数组元素。封装了很多功能 直接使用即可。
在java.util包里面 因此要在java文件中使用Arrays功能 需要提前导包
常用功能如下：
- Arrays.toString(数组名称); // 将数组转换成字符串操作
- Arrays.copyOf(原数组名称, 新数组的长度); // length>=0 1.1 扩容 1.2 截断
- Arrays.sort(数组名) ; // 默认对数组元素进行升序排列
4. 高维数组(忘记)
二维数组。（[][]）
二维数组的数据是一维数组。其实真实的数据还是在一维数组中。
4.1 语法
1. 语法1
数据类型[][] 变量名/数组名 = new 数据类型[m][n];//初始化二维数组变量
m: 数组的length。 规定二维数组的length，空间大小 元素个数
n: 一维数组的元素个数 一维数组的length
2. 语法2
数据类型[][] 变量名/数组名 = new 数据类型[m][];
3. 语法3
数据类型[][] 变量名/数组名 = {}；//初始化
4.语法4
数据类型[][] 变量名/数组名 = new 数据类型[][]{}；
4.2 案例
需求: 使用二维数组实现 动态录入班级个数 以及每个班级的学生个数 动态录入每个学生的名称 打印输出 每个班级每个学生的姓名。
5.课堂练习
1.一维数组语法
public class ArrayDemo1 {
public static void main(String[] args){
//使用数组维护多个学生的成绩
//创建数组 数据类型[] 变量/数组名称/引用 = new 数据类型[length];
double[] scoreArray = new double[3];
//在数组中，每个数据元素都有索引，index（0-length-1）
//访问（输出）数组元素：数组名称[index]
double firstData = scoreArray[0];
System.out.println("第一个数据" + firstData); //访问第一个数组元素，并打印出.------0.0
System.out.println("第二个数组元素：" + scoreArray[1]);//访问第二个数组元素，并打印出
//添加数组元素(修改同理)
scoreArray[0] = 100;
}
}
2.遍历数组
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arry = new int[5];
arry[0] = 100;
arry[1] = 200;
//获得数组长度 变量.length
System.out.println("获得数组的长度" + arry.length);
//循环遍历数组元素-----while
int index = 0;
while (index < arry.length) {
System.out.println(arry[index++]);
}
//循环遍历数组元素-----for（普通for循环）
for (int index = 0; index < arry.length; index++) {
System.out.println(arry[index++]);
}
/*新的遍历数组的方式：增强for循环
for（数组元素类型 变量名称：数组名称）{ //将指定数组里的每个元素分别赋值给了变量
}
该方法弊端是：不能直接获得索引
*/
int count = 1;
for(int a:arry){
System.out.println("第" + count + "个数据元素是" + a);
count++;
}
}
}
3. 使用数组维护5个学生的姓名
public class ArrayDemo3 {
public static void main(String[] rags){
String[] nameArray = new String[5]; //创建数组
int length = nameArray.length; //获得数组长度
//新增数据
nameArray[0] = "张三";
nameArray[1] = "李四";
nameArray[2] = "王五";
nameArray[3] = "赵六";
nameArray[4] = "陈七";
//遍历查看，优先使用for
/*for(int index = 0;index < nameArray.length;index++){ // nameArray.length.for可直接出来
System.out.println("学生的姓名是：" + nameArray[index]);
}*/
for (String name : nameArray) { //若用增强for，可用nameArray.for
System.out.println("学生的姓名是：" + name);
}
}
}
4.数组的其他语法
public class ArrayDemo4 {
public static void main(String[] args){
//可以两步走创建语法
int[] array;
array = new int[3];
//可静态初始化数组，数组类型[] 数组名称 = {数据1，数据2，...数据n}；
int[] array = {1,2,3};
//对静态初始数组，若两步走,要加new 数据类型[]
int[] array;
array = new int[]{1,2,3};
}
}
5.动态录入学生的个数及每个学生的成绩，求学生总成绩，并打印每个学生的成绩
public class ArrayDemo5 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入学生个数：");
int num = input.nextInt();
double sum = 0;
double[] scoreArray = new double[num];
for (int i = 1; i <= num; i++) {
System.out.println("请录入第" + (i) + "个学生的成绩");
double score = input.nextDouble();
sum += score;
scoreArray[i-1] = score; //录入的每个成绩存入数组中
}
System.out.println("---------------" );
System.out.println("学生的总分为：" + sum);
//循环遍历打印
int count = 1;
for (double studentscore : scoreArray) {
System.out.println("第" + (count++) + "个学生的成绩为：" + studentscore);
}
input.close();
}
}
6.比较数组元素是否一致
public class ArrayDemo6 {
public static void main(String[] args){
//基本数据类型比较的是数据 引用数据类型比较的是内存地址值
//比较2个数组元素是否一致，数组也是引用型，所有的引用数据类型都可以用equals
int[] array1 = new int[]{1,2,3}; //不分两步写可省略new int[]
int[] array2 = {1,2,3};
System.out.println(array1 == array2); //false，因为两个数组的内存地址值不同
System.out.println(array1.equals(array2) ); //false，也不行
int length1 = array1.length;
int length2 = array2.length;
if(length1 != length2){
System.out.println("这2个数组元素不同");
return;
}
//比较相同索引下的元素是否一致
for (int index = 0; index < length1; index++) {
if(array1[index] != array2[index]){
System.out.println("这2个数组元素不同");
return;
}
}
System.out.println("这2个数组元素相同");
}
}
7.动态录入学生个数及每个学生的成绩，求总分，最高分，最低分，打印每个学生的成绩
public class ArrayDemo07 {
//修改class名可直接修改，然后alt+回车，选择rename file。或者快捷键shift+F6
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请录入学生个数:");
int studentNum = input.nextInt();
int[] scoreArray = new int[studentNum];
for (int i = 0; i < studentNum; i++) {
System.out.println("请录入第" + (i+1)+ "个学生成绩:");
int studentscore = input.nextInt();
scoreArray[i] = studentscore;
}
int max = scoreArray[0];
int min = scoreArray[0];
/* //遍历数组 数组名+for-----增强for
for (int score : scoreArray) { //将数组的元素一一赋值给score
System.out.println("成绩" + score);
//三元运算符比较大小
max = (max > score)?max:score;
min = (min > score)?score:min;
}*/
//使用普通for 数组名.length+for
for (int index = 0; index < scoreArray.length; index++) {
max = Math.max(max,scoreArray[index]); //也可不用三元运算符
min = Math.min(min,scoreArray[index]);
}
System.out.println("成绩最高分为：" + max);
System.out.println("成绩最低分为：" + min);
input.close();
}
}
也可直接在一个for里求max min
public class ArrayDemo07methond2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请录入学生个数:");
int studentNum = input.nextInt();
int[] scoreArray = new int[studentNum];
int max = 0;
int min = 0;
for (int i = 0; i < studentNum; i++) {
System.out.println("请录入第" + (i + 1) + "个学生成绩:");
int studentscore = input.nextInt();
scoreArray[i] = studentscore;
if(i == 1){
max = studentscore;
min = studentscore;
continue;
}
max = Math.max(max,scoreArray[i]); //
min = Math.min(min,scoreArray[i]);
}
input.close();
}
}
8.创建两个字符串数组，将其中一个数组的所有元素都赋值放入另外一个数组中
若被转入元素的数组空间充足（要判断）
public class ArrayDemo08 {
public static void main(String[] args){
//数组元素是连贯的
String[] arr1 = new String[5];
arr1[0] = "a";
arr1[1] = "b";
arr1[2] = "c";
String[] arr2 = {"1"};
//需要将arr2的数据存储到arr1里,核心是找到arr1里第一个null值出现的地方
int length = arr1.length;
int index = 0;
for(;index < length;index++){
if(arr1[index] == null){
break;
}
}
//赋值
for (String s : arr2) {
if( s== null){ //数组二若出现null，则后面全是null
break;
}
arr1[index++] = s;
}
//遍历数组的所有元素
//Array java.util.Arrays 提供了很多操作数组元素的功能
//将数组里的元素转换成字符串进行输出 Arrays.toString(数组名)
System.out.println("arr1的元素" + Arrays.toString(arr1));
}
}
若被转入元素的数组空间不充足（要判断）--------------------------------需要手动扩容
public class ArrayDemo08 {
public static void main(String[] args){
//数组元素是连贯的
String[] arr1 = new String[5];
arr1[0] = "a";
arr1[1] = "b";
arr1[2] = "c";
String[] arr2 = {"1","2","3"};
//找到arr1里第一个null值出现的地方
int length = arr1.length;
int index = 0;
for(;index < length;index++){
if(arr1[index] == null){
break;
}
}
//判断arr1剩余空间是否充足
int leftSpace = length - index;
int length2 = arr2.length;
if(length2 > leftSpace){ //空间不足，需要手动扩容，创建新的数组，扩大的空间自己定义
String[] newArray = new String[index+length2];
for(int i = 0;i < index;i++){
newArray[i] = arr1[i]; //把要扩容的数组的元素移到新的数组中
}
arr1 = newArray; //引用类型赋值，赋的是内存地址值，这样就完成了arr1的扩容
}
for (String s : arr2) {
if( s== null){
break;
}
arr1[index++] = s;
}
System.out.println("arr1的元素" + Arrays.toString(arr1));
}
}
9.数组扩容 Arrays.copyOf(原数组名称，新数组长度）;//length>=0
public class ArrayDemo09 {
public static void main(String[] args){
int[] array = {1,2,3,4,5};
/*
int[] newArray = new int[array.length*2]; //新数组长度是上面数组长度的二倍
//这里省略循环遍历，将旧数组元素赋值给新数组的步骤
array = newArray;
*/
//以上手动扩容过程可用一句话执行
array = Arrays.copyOf(array,array.length*2); //数组扩容
System.out.println(Arrays.toString(array)); //数组元素输出
}
}
10.删除数组指定元素数据
public class ArrayDemo10 {
public static void main(String[] args){
//数组元素是连贯的，空间是固定的。删除数组元素后，其后若有非空元素。则向前循环移动。（非空元素前不会有空元素，即连贯）
//如下：若删除数组元素a。
String[] array = {"a","b","c",null};
int length = array.length;
//找到a元素所在的索引位置
for(int index = 0;index < length;index++){
if("a".equals(array[index])){
array[index] = null; //可省略,因为接下来右边的元素要循环向左移动
for(int j = index;j < length - 1;j++){ //遵循数组元素连贯原则，将非空元素左移
array[j] = array[j + 1];
}
array[length-1] = null; //最后一个元素左移之后，把最后一个元素也赋值为空
}
}
System.out.println("删除之后" + Arrays.toString(array));
}
}
11.排序 Arrays.sort(数组名）; //默认升序排序
public class ArrayDemo11 {
public static void main(String[] args){
int[] array = {89,100,0,78};
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}
}
//结果为{0,78,89,100}
12.二维数组语法
public class ArrayDemo12 {
public static void main(String[] args){
//创建二维数组
int[][] array = new int[3][4]; //初始化二维数组，代表array最多有三个元素（一维数组），每个一维数组元素最多4个
//获得数组元素 数组名称[index]
int[] first = array[0]; //二维数组的元素是一维数组
int[] second = array[1];
int[] third = array[2];
System.out.println("获得二维数组的第一个元素：" + Arrays.toString(first)); //[0,0,0,0]
//将二维数组元素转成字符串 Arrays.deepToString(数组名)
System.out.println(Arrays.deepToString(array)); //{[0,0,0,0],[0,0,0,0],[0,0,0,0,]}
//修改第一个一维数组的第一个数据 100
//array[0][0] = 100;
int[] first1 = array[0];
first1[0] = 100; //分两步也可以
//遍历数组
for(int index1 = 0;index1 < array.length;index1++){
for(int index2 = 0;index2 < array[index1].length;index2++){
System.out.println("第" + index1 +"个一维数组的第" + index2 + "个元素为：" + array[index1][index2] );
}
}
//用增强for遍历
int count1 = 1;
for (int[] ints : array) { //array.for
int count2 = 1;
for (int anInt : ints) { //ints.for
System.out.println("第" + count1 +"个一维数组的第" + count2 + "个元素为：" + anInt );
count2++;
}
count1++;
}
}
}
13.二维数组语法2
public class ArrayDemo13 {
public static void main(String[] args) {
String[][] strArray = new String[3][]; //初始化二维数组，并声明3个一维数组。
// 但接下来要初始化每一个一维数组，因为现在每一个一维数组元素为null，要操作会报空指针
strArray[0] = new String[1]; //第一个一维数组为1个长度
strArray[1] = new String[2];
strArray[2] = new String[3];
}
}
14.数组语法三
public class ArrayDemo14 {
public static void main(String[] args){
int[][] a; //先声明
a = new int[][]{ {},{}, {} }; //再赋值
}
15.使用二维数组实现 动态录入班级个数 以及每个班学生个数 动态录入每个学生的名字 打印输出每个班每个学生的名字
public class ArrayDemo15 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("录入班级个数：");
int classroomNum = input.nextInt();
String[][] nameArray = new String[classroomNum][];
for (int num = 1; num <= classroomNum; num++) {
System.out.println("请录入第" + num + "个班级的学生个数：");
int studentNum = input.nextInt();
nameArray[num - 1] = new String[studentNum]; //初始化每一个一维数组！！！很重要
for (int num1 = 1; num1 <= studentNum; num1++) {
System.out.println("请录入第" + num + "个班级第" + num1 + "个学生的姓名：");
String name = input.next();
nameArray[num - 1][num1 - 1] = name;
}
}
//打印输出每个班级每个学生的姓名
for (int index = 0; index < nameArray.length; index++) {
for (int index1 = 0; index1 < nameArray[index].length; index1++) {
System.out.println("第"+(index+1)+"个班级第"+(index1+1) +"个学生的姓名："+nameArray[index][index1] );
}
}
input.close();
}
}
6.数组排序（了解）
1.. 冒泡排序
2. 选择排序
3. 插入排序
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
