如何存储100名学生的成绩?
如何让100名学生成绩全部+1?
概念:一组连续的存储空间,存储多个数据类型相同或兼容的值。
特点: 1.数据类型相同或兼容 2.长度固定
使用步骤: 1.声明 2.初始化(静态/动态) 3.具体使用
数组的声明和声明变量类似, 有两种方式
Java中的数组必须先初始化,初始化就是为数组中的数组元素分配内存空间,并为每个数组元素赋初始值。
Java 有两种方式:静态初始化 和 动态初始化
初始化时由程序员指定每个数组元素的初始值,由系统计算数组长度。
语法:
数组元素类型[] 数组名 = new 数组元素类型[]{元素0,元素1,....};
可简写为:数组元素类型[] 数组名 = {元素0,元素1,....};
eg:
int[] arr1 = new int[]{10,8,28,15,12};
int[] arr2 = {10,8,28,15,12};
String[] names1= new String[]{"张三","李四","王五"};
String[] names2={"张三","李四","王五"};
注意: 简写静态初始化只能一条语句完成,不能分割成两条语句。
初始化时只指定数组长度【大于等于0整数】,由系统为数组元素分配默认值。
语法:
数组元素类型[] 数组名 = new 数组元素类型[数组长度];
默认值分配规则如下:整数型为0 浮点型为0.0 字符型为‘\u0000’ 布尔类型为false 引用类型为null
eg:
int[] nums = new int[5];
String[] cities= new String[3];
char[] chars= new char[10];
注意:初始化数组时,不要静态初始化和动态初始化同时使用,也就是说,不要在进行数组初始化时,既指定数组的长度,也为每个数组元素分配初始值。
//内存
array[]: 5 | 9 | 0 | 6 | 2 | 5 | 7 //数组元素
0 1 2 3 4 5 6 //数组下标
//访问元素时,需要使用“下标”(从0开始,依次+1,自动生成)
数组中的每个数据被称为“数组元素”, 可以使用length属性获取“数组长度”
语法:
数组名[下标];
eg:
//修改:a[0]=10; 获取:a[0];
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组的使用
* @date 2023/12/26 14:38
*/
public class demo01 {
public static void main(String[] args) {
//创建数组
int[] a = new int[5];
//依次赋值
a[0] = 1;
a[1] = 1;
a[2] = 1;
a[3] = 1;
a[4] = 1;
//依次输出
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}
下标范围:
//有效下标范围:0 ~ 数组长度-1
int[] a = new int[5];
//访问无效下标,会导致数组下标越界
a[5] = 1;
报错:Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException
若数组的大小过大,再依次赋值就会很麻烦,因此我们使用循环遍历数组,以简化操作步骤
eg:
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 遍历数组
* @date 2023/12/26 15:30
*/
public class demo02 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] a = new int[10];
//遍历赋值
for (int i=0; i<a.length-1; i++) {
System.out.println("请输入第"+(i+1)+"个数组元素(int):");
a[i] = in.nextInt();
}
//遍历输出
for (int i = 0; i < a.length - 1; i++) {
System.out.println(a[i]);
}
}
}
JDK1.5之后,Java提供了增强for简化数组或集合的遍历。
语法:
for(数组元素类型 n : 数组){
//n代表数组中每个元素
}
优点:语法简洁;缺点:不能使用下标,不能改变数组元素;
eg:
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 给定一个整型数组,统计数组中所有元素的平均值。
* @date 2023/12/26 16:19
*/
public class demo03 {
public static void main(String[] args) {
int num = 0;
int[] nums = {89,23,455,6453,123,453};
for (int j : nums) {
num = num + j;
}
System.out.println("平均值为:"+(double)(num/nums.length));
}
}
eg:
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 给定一个整型数组,输入一个整数n,如果n在数组中存在,输出下标,不存在则输出-1
* @date 2023/12/26 16:19
*/
public class demo04 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个整数:");
int num = in.nextInt();
boolean flag = true;
int[] nums = {342,543,1231,12,547,756,432,124};
for (int i = 0; i < nums.length; i++) {
if (num == nums[i]) {
System.out.println("下标为"+i);
flag = false;
}
}
if (flag) {
System.out.println("-1");
}
}
}
eg:
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 控制台输入5个城市的名称,使用数组保存,并遍历输出。
* @date 2023/12/26 16:20
*/
public class demo05 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String[] cities = new String[5];
for (int i = 0; i < cities.length; i++) {
System.out.println("请输入第"+(i+1)+"个城市名称");
cities[i] = input.next();
}
for (String city : cities) {
System.out.println(city);
}
}
}
程序运行中有两块重要的存储空间,栈 、堆;
栈:
堆:
eg:
创建数组时,必须显示指定长度,并在创建之后不可更改长度。
扩容的思路:创建大于原数组长度的新数组。将原数组中的元素依次复制到新数组中。把新数组的地址赋值给原数组。
内存图:
eg:
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组扩容
* @date 2023/12/26 17:05
*/
public class demo07 {
public static void main(String[] args) {
int[] nums_1 = {98,23,44,65,23,41};//长度 5
System.out.println("-------扩容前-------");
for (int i : nums_1) {
System.out.print(i+" ");
}
//扩充思路
//1、创建大于原数组长度的新数组
int[] nums_2 = new int[nums_1.length*2];//默认值 0
//2、将原数组中的元素依次复制到新数组中
for (int i = 0; i < nums_1.length; i++) {
nums_2[i] = nums_1[i];
}
//3、把新数组的地址赋值给原数组
nums_1 = nums_2;
System.out.println();
System.out.println("-------扩容后-------");
for (int i : nums_1) {
System.out.print(i+" ");
}
}
}
当方法参数是数组时,调用方法会将 实参 中的地址赋值给 形参,此时二者指向同一个数组。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组类型的参数
* @date 2023/12/27 9:41
*/
public class demo01 {
public static void main(String[] args) {
int a=10,b=20;
swap(a,b);
System.out.println("a: "+ a +" b: "+b);
System.out.println("===========================");
int[] arr = {10,15,20,25,30};
printArray(arr);
System.out.println("===========================");
for (int i : arr) {
System.out.print(i+" ");
}
}
//基本数据类型作为方法的参数
public static void swap(int x, int y) {
System.out.println("交换前:x:"+ x + " y:" + y);
int t = x;
x = y;
y = t;
System.out.println("交换后:x:"+ x + " y:" + y);
}
//引用类型(数组)作为方法的参数
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] += 5;
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
结果:
交换前:x:10 y:20
交换后:x:20 y:10
a: 10 b: 20
===========================
15 20 25 30 35
===========================
15 20 25 30 35
传递参数时:基本类型传递的是变量中的数据;引用类型传递的是变量中的地址。
调用基本类型返回值的方法时,方法执行后,返回的是数据。
调用引用类型返回值的方法时,方法执行后,返回的是地址。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 引用数据类型(数组)作为方法参数
* @date 2023/12/27 10:09
*/
public class demo02 {
public static void main(String[] args) {
int x=5,y=8;
System.out.println(add(x,y));
System.out.println("======================");
int[] nums = {1,2,3,4,5};
System.out.print("原数组:");
for (int num : nums) {
System.out.print(num+" ");
}
System.out.println();
nums = expend(nums);
System.out.print("新数组:");
for (int num : nums) {
System.out.print(num+" ");
}
}
//基本数据类型作为方法参数
public static int add(int x, int y) {
return x + y;
}
//引用数据类型(数组)作为方法参数
public static int[] expend(int[] nums) {
//1. 创建一个比原数组大的新数组
int[] newArr = new int[nums.length*2];
//2. 将原数组的元素复制到新数组中
for (int i = 0; i < nums.length; i++) {
newArr[i] = nums[i];
}
//3. 返回新数组的地址
return newArr;
}
}
概念:可以接收多个同类型实参,个数不限,使用方式类似于数组
语法:数组元素类型… 形参名
优点:灵活,可以接收多个同类型的实参
特点:只能有一个可变长参数,必须在参数列表的最后
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 可变长参数
* @date 2023/12/27 11:13
*/
public class demo03 {
public static void main(String[] args) {
int[] nums = {1,2,4,5,6};
printArray(nums);
System.out.println("=======================");
printArray(9,nums);
System.out.println("=======================");
printArray(1.6,nums);
}
public static void printArray(int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
}
public static void printArray(int x, int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
System.out.println(x);
}
public static void printArray(double x, int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
System.out.println(x);
}
}
结果:
1 2 4 5 6
=======================
1 2 4 5 6
9
=======================
1 2 4 5 6
1.6
排序:把一组无序的数据,按照有序的顺序进行排列。
冒泡排序:相邻的两个数值比较大小,互换位置。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 冒泡排序
* @date 2023/12/27 11:51
*/
public class demo04 {
public static void main(String[] args) {
int[] arrays = {10,8,6,20,2};
bubbleSort(arrays);
System.out.println("=========================");
System.out.print("最终的顺序:");
printArrays(arrays);
}
public static void bubbleSort(int[] arrays){
for (int i=0; i < arrays.length-1; i++) {
System.out.println("第"+ (i+1)+"轮");
printArrays(arrays); //输出,本轮次最初的数组顺序
for (int j=0; j < arrays.length-i-1; j++) {
System.out.print("第"+ (j+1)+"次比较:\t");
for (int array : arrays) {
System.out.print(array+" ");
}
//判段大小,交换数据
if (arrays[j] > arrays[j+1]) {
arrays[j] = arrays[j] ^ arrays[j+1];
arrays[j+1] = arrays[j] ^ arrays[j+1];
arrays[j] = arrays[j] ^ arrays[j+1];
}
System.out.print("\t结果:\t");
printArrays(arrays); //输出,每次比较交换完后的顺序
}
}
}
//方法:遍历数组并输出
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
System.out.println();
}
}
结果:
第1轮
10 8 6 20 2
第1次比较: 10 8 6 20 2 结果: 8 10 6 20 2
第2次比较: 8 10 6 20 2 结果: 8 6 10 20 2
第3次比较: 8 6 10 20 2 结果: 8 6 10 20 2
第4次比较: 8 6 10 20 2 结果: 8 6 10 2 20
第2轮
8 6 10 2 20
第1次比较: 8 6 10 2 20 结果: 6 8 10 2 20
第2次比较: 6 8 10 2 20 结果: 6 8 10 2 20
第3次比较: 6 8 10 2 20 结果: 6 8 2 10 20
第3轮
6 8 2 10 20
第1次比较: 6 8 2 10 20 结果: 6 8 2 10 20
第2次比较: 6 8 2 10 20 结果: 6 2 8 10 20
第4轮
6 2 8 10 20
第1次比较: 6 2 8 10 20 结果: 2 6 8 10 20
=========================
最终的顺序: 2 6 8 10 20
选择排序:选择固定值与其他值依次比较大小,互换位置。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 选择排序
* @date 2023/12/27 14:46
*/
public class demo05 {
public static void main(String[] args) {
int[] nums = {8,6,2,10,1};
selectSort(nums);
System.out.print("最终的顺序:\t");
printArrays(nums);
}
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
int min = i;//最小下标
System.out.println("第"+ (i+1)+"轮");
printArrays(arr); //输出,本轮次最初的数组顺序
System.out.println();
int count = 1;
for (int j = i+1; j < arr.length; j++) {
System.out.print("第"+ (count)+"次比较:\t");
System.out.print(arr[min]+"\t"+arr[j]+"\t");
if (arr[min] > arr[j]) {
min = j;
}
System.out.println("当前最小值是:\t"+arr[min]);
count++;
}
//互换
if (min!=i) {
System.out.println("将"+arr[min]+"和"+arr[i]+"交换");
arr[i] = arr[i] ^ arr[min];
arr[min] = arr[i] ^ arr[min];
arr[i] = arr[i] ^ arr[min];
}
System.out.print("当前结果为:\t");
System.out.println("==========================================");
printArrays(arr); //输出,每轮比较交换完后的顺序
System.out.println();
}
}
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
}
}
结果:
第1轮
8 6 2 10 1
第1次比较: 8 6 当前最小值是: 6
第2次比较: 6 2 当前最小值是: 2
第3次比较: 2 10 当前最小值是: 2
第4次比较: 2 1 当前最小值是: 1
将1和8交换
当前结果为: 1 6 2 10 8
==========================================
第2轮
1 6 2 10 8
第1次比较: 6 2 当前最小值是: 2
第2次比较: 2 10 当前最小值是: 2
第3次比较: 2 8 当前最小值是: 2
将2和6交换
当前结果为: 1 2 6 10 8
==========================================
第3轮
1 2 6 10 8
第1次比较: 6 10 当前最小值是: 6
第2次比较: 6 8 当前最小值是: 6
当前结果为: 1 2 6 10 8
==========================================
第4轮
1 2 6 10 8
第1次比较: 10 8 当前最小值是: 8
将8和10交换
当前结果为: 1 2 6 8 10
==========================================
最终的顺序: 1 2 6 8 10
插入排序:从第二元素开始,向前插入合适位置,保证元素前面有顺序。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 插入排序
* @date 2023/12/27 15:22
*/
public class demo06 {
public static void main(String[] args) {
int[] nums = {10,5,8,15,2};
insertSort(nums);
System.out.print("最终的顺序:\t");
printArrays(nums);
}
public static void insertSort(int[] arr) {
int count = 1;
for (int i=1; i < arr.length; i++) {
int pos = i-1;
int t = arr[i];
//输出解释说明
System.out.println("第"+ (count)+"轮");
printArrays(arr); //输出,本轮次最初的数组顺序
System.out.println("\t当前 t 的值:"+t);
System.out.println();
System.out.print("第1次 当前 pos 的位置为 "+pos+"\t值为: "+arr[pos]);
int count2 = 1;
System.out.print("\t"+arr[pos]+" "+t+" 比较"+"\t");
System.out.print(arr[pos]>t);
if(!(arr[pos]>t)){
System.out.println();
}
while (pos>=0&&arr[pos]>t) {
System.out.println("\t将"+arr[pos]+"后移一位");
arr[pos+1] = arr[pos];
pos--;
count2++;
//输出解释说明
printArrays(arr);
System.out.println();
if(pos>=0){
System.out.println();
System.out.print("第"+count2+"次 当前 pos 的位置为 "+pos+"\t"+"值为: "+arr[pos]);
System.out.print("\t"+arr[pos]+" "+t+" 比较"+"\t");
System.out.print(arr[pos]>t);
if(!(arr[pos]>t)){
System.out.println();
}
}
}
//把 t 插入 pos+1 的位置
arr[pos+1] = t;
//输出解释说明
System.out.println();
if (!(pos>=0)) {
System.out.println("当前 pos 的位置为 "+ pos +" 将"+t+"插入到第"+(pos+2)+"位");
}
System.out.print("本轮排序结果为:\t");
printArrays(arr);
System.out.println();
System.out.println("===========================================");
count++;
}
}
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
}
}
结果:
第1轮
10 5 8 15 2 当前 t 的值:5
第1次 当前 pos 的位置为 0 值为: 10 10 5 比较 true 将10后移一位
10 10 8 15 2
当前 pos 的位置为 -1 将5插入到第1位
本轮排序结果为: 5 10 8 15 2
============================================================================
第2轮
5 10 8 15 2 当前 t 的值:8
第1次 当前 pos 的位置为 1 值为: 10 10 8 比较 true 将10后移一位
5 10 10 15 2
第2次 当前 pos 的位置为 0 值为: 5 5 8 比较 false
本轮排序结果为: 5 8 10 15 2
============================================================================
第3轮
5 8 10 15 2 当前 t 的值:15
第1次 当前 pos 的位置为 2 值为: 10 10 15 比较 false
本轮排序结果为: 5 8 10 15 2
============================================================================
第4轮
5 8 10 15 2 当前 t 的值:2
第1次 当前 pos 的位置为 3 值为: 15 15 2 比较 true 将15后移一位
5 8 10 15 15
第2次 当前 pos 的位置为 2 值为: 10 10 2 比较 true 将10后移一位
5 8 10 10 15
第3次 当前 pos 的位置为 1 值为: 8 8 2 比较 true 将8后移一位
5 8 8 10 15
第4次 当前 pos 的位置为 0 值为: 5 5 2 比较 true 将5后移一位
5 5 8 10 15
当前 pos 的位置为 -1 将2插入到第1位
本轮排序结果为: 2 5 8 10 15
============================================================================
最终的顺序: 2 5 8 10 15
顺序查找:从第一个元素遍历到最后一个元素,查找符合要求的。
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 顺序查找
* @date 2023/12/27 16:07
*/
public class demo07 {
public static void main(String[] args) {
int[] nums = {2,4,6,10,13,16,38,46,89,100};
System.out.println(sequenceSearch(nums,89));
System.out.println("=======================");
System.out.println(sequenceSearch(nums,7));
}
public static int sequenceSearch(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
return i;
}
}
return -1;
}
}
二分查找
eg:
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 二分查找
* @date 2023/12/27 16:07
*/
public class demo08 {
public static void main(String[] args) {
int[] nums = {2,4,6,10,13,16,38,46,89,100};
System.out.println(binarySearch(nums,89));
System.out.println("=======================");
System.out.println(binarySearch(nums,7));
}
public static int binarySearch(int[] arr, int key) {
int low = 0;
int high = arr.length-1;
while (low <= high) {
int mid = (low + high) >>> 1;
if (key < arr[mid]) {
high = mid - 1;
} else if (key > arr[mid]) {
low = mid + 1;
} else {
return mid;
}
}
return -1;
}
}
结果:
当前的 low 位于 0 当前的 high 位于 9 当前的 mid 位于 4
当前数组范围是 2 4 6 10 13 16 38 46 89 100
当前的 low 位于 5 当前的 high 位于 9 当前的 mid 位于 7
当前数组范围是 16 38 46 89 100
当前的 low 位于 8 当前的 high 位于 9 当前的 mid 位于 8
当前数组范围是 89 100
8
===========================================================
当前的 low 位于 0 当前的 high 位于 9 当前的 mid 位于 4
当前数组范围是 2 4 6 10 13 16 38 46 89 100
当前的 low 位于 0 当前的 high 位于 3 当前的 mid 位于 1
当前数组范围是 2 4 6 10
当前的 low 位于 2 当前的 high 位于 3 当前的 mid 位于 2
当前数组范围是 6 10
当前的 low 位于 3 当前的 high 位于 3 当前的 mid 位于 3
当前数组范围是 10
-1
作用:主要用于对数组进行排序,查找,填充,复制等的操作
导包:import java.util.Arrays;
eg:
package StageOne.day07.demo;
import java.util.Arrays;
/**
* @author 胡昊龙
* @version 1.0
* @description: TODO
* @date 2023/12/27 16:45
*/
public class demo09 {
public static void main(String[] args) {
//Arrays 工具类
//1. toString(); 把数组转成字符串形式输出
int[] nums = {5,2,8,15,13,20,12};
String s = Arrays.toString(nums);
System.out.println(s);
//2. sort(); 排序,效率更高
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
//3. binarySearch(); 二分查找
System.out.println(Arrays.binarySearch(nums, 9));
System.out.println(Arrays.binarySearch(nums, 2));
//4. copyOf(); 指定长度的复制
int[] nums2 = Arrays.copyOf(nums,nums.length*2);
System.out.println(Arrays.toString(nums2));
int[] nums3 = Arrays.copyOf(nums,5);
System.out.println(Arrays.toString(nums3));
//5. copyOfRange(); 指定范围的复制, from 开始的位置, to 结束的位置 含头不含尾
int[] nums4 = Arrays.copyOfRange(nums,2,5);
System.out.println(Arrays.toString(nums4));
//6. equals(); 比较两个数组的元素是否相等
int[] arr1 = {1,3,5};
int[] arr2 = {1,3,5};
System.out.println(Arrays.equals(arr1,arr2));
//7. fill(); 用指定元素填充数组
Arrays.fill(nums,0);
System.out.println(Arrays.toString(nums));
}
}