例题
public class ArrayTest9 {
public static void main(String[] args) {
System.out.println("--------------------------------欢迎来到成绩管理系统--------------------------------");
Scanner sc = new Scanner(System.in);
System.out.println("请输入班级人数：");
int classNum = sc.nextInt();
System.out.println("请输入录入的科目：");
String course = sc.next();
// 定义数组存储班级成绩,长度为录入的人数
double[] achievement = new double[classNum];
// 循环遍历数组录入成绩
for (int x = 0; x < achievement.length; x++) {
System.out.println("请输入第" + (x + 1) + "位同学的" + course + "成绩");
achievement[x] = sc.nextDouble();
}
// 排名
Arrays.sort(achievement);// 从小到大
// 倒序，从大到小排序
reverse(achievement);
System.out.println("--------------------------------成绩录入完毕--------------------------------");
w: while (true) {
System.out.println("输入：");
System.out.println("1：查询所有成绩\t 2：查询最高成绩\t 3：查询该成绩的排名\t 0：退出");
int function = sc.nextInt();
switch (function) {
case 1:
printArray(achievement);
break;
case 2:
System.out.println("最高成绩是：" + getMax(achievement));
break;
case 3:
System.out.println("请输入你要查询的成绩：");
double value = sc.nextDouble();
int index = getIndex(achievement, value);
if (index >= 0) {
System.out.println("该成绩是第" + (index + 1) + "名");
} else {
System.out.println("该成绩不存在");
}
break;
case 0:
System.out.println("欢迎下次使用本系统");
break w;
default:
System.out.println("请输入正确的功能");
break;
}
System.out.println("----------------------------------------------");
}
}
/*
* 遍历数组的方法
*
* 参数列表：int[] arr 返回值类型：void
*/
public static void printArray(double[] arr) {
for (int x = 0; x < arr.length; x++) {
System.out.println("第" + (x + 1) + "名的同学成绩：" + arr[x]);
}
}
/*
* 数组逆序方法
*
* 参数列表：double[] arr 返回值类型：void
*/
public static void reverse(double[] arr) {
for (int x = 0; x < arr.length / 2; x++) {
double temp = arr[x];
arr[x] = arr[arr.length - 1 - x];
arr[arr.length - 1 - x] = temp;
}
}
/*
* 数组获取最大值
*
* 参数列表：double[] arr 返回值类型：double
*/
public static double getMax(double[] arr) {
// 定义参照物
double max = arr[0];
for (int x = 0; x < arr.length; x++) {
// 和参照物进行比较
if (arr[x] > max) {
max = arr[x];
}
}
return max;
}
/*
* 数组元素查找（查找指定元素第一次在数组中出现索引）
*
* 参数列表：double[] arr,int value 返回值类型：int
*/
public static int getIndex(double[] arr, double value) {
// 定义一个索引，如果找不到数据，我们一般直接返回一个负数
int index = -1;
for (int x = 0; x < arr.length; x++) {
if (arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
键盘录入同学数量32
再键盘录入成绩
…
功能如下：
1查询第一名成绩
2 查询成绩为98的同学索引
---------------------------------------欢迎来到成绩管理系统---------------------------------------
请输入班级人数：
请输入第1位同学的成绩…
输入：1.查询第一名成绩 2.查询指定成绩同学的索引3.输入3退出
1：第一名的成绩是：
2：请输入要查找的成绩
该成绩所在的索引位置是：
输入：1.查询第一名成绩 2.查询指定成绩同学的索引3.输入3退出
3：结束程序
数组的遍历：
基础遍历：
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
改进：
for (int x = 0; x < arr.length; x++) {
if(x == arr.length-1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+",");
}
}
用方法改进：
/*
* 遍历数组的方法
*
* 参数列表：int[] arr
* 返回值类型：void
*/
public static void printArray(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ",");
}
}
System.out.println();
}
数组获取最大值
/*
- 需求：数组获取最大值
- 分析：
- a.定义一个数组，并对数组的元素进行静态初始化
- b.从数组中任意的找一个元素作为参照物（一般取第一个），默认他就是最大值
- c.然后遍历其他的元素，依次获取和参照物进行比较，如果大就是擂主 ，如果小就离开
- d.最后参照物保存的就是最大值
- */
public class ArrayTest2 {
public static void main(String[] args) {
// a.定义一个数组，并对数组的元素进行静态初始化
int[] arr = { 12, 45, 78, 11, 78 };
// b.从数组中任意的找一个元素作为参照物（一般取第一个），默认他就是最大值
int max = arr[0];
// c.然后遍历其他的元素，依次获取和参照物进行比较，如果大就是擂主 ，如果小就离开
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) {
max = arr[x];
}
}
System.out.println("max:" + max);
}
}
数组元素逆序
/*
- 需求：数组元素逆序
- 分析：
- a.定义一个数组，并对数组的元素进行静态初始化
- b.把0索引和arr.length-1进行交换
- 把1索引和arr.length-2进行交换
- 到arr.length/2的时候就停止
- */
public class ArrayTest3 {
public static void main(String[] args) {
// a.定义一个数组，并对数组的元素进行静态初始化
int[] arr = { 12, 45, 78, 11, 78 };
System.out.println("逆序前：");
printArray(arr);
// int temp = arr[0];
// arr[0] = arr[arr.length-1-0];
// arr[arr.length-1] = temp;
//
// int temp1 = arr[1];
// arr[1] = arr[arr.length-1-1];
// arr[arr.length-1-1] = temp;
reverse(arr);
System.out.println("逆序后：");
printArray(arr);
}
/*
* 数组逆序方法
*
* 参数列表：int[] arr
* 返回值类型：void
* */
public static void reverse(int[] arr){
for(int x=0;x<arr.length/2;x++){
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
}
/*
* 遍历数组的方法
*
* 参数列表：int[] arr
* 返回值类型：void
*/
public static void printArray(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ",");
}
}
System.out.println();
}
}
数组元素查找
基本查找
/*
- 需求：数组元素查找（查找指定元素第一次在数组中出现索引）
- 基本查找：从头找到尾
- 分析：
- a.定义一个数组，并对数组的元素进行静态初始化
- b.遍历数组，依次获取数组中每一个元素，和要找的数据进行比较
- 如果相等：就返回当前索引
- */
public class ArrayTest4 {
public static void main(String[] args) {
// a.定义一个数组，并对数组的元素进行静态初始化
int[] arr = { 12, 45, 78, 11, 78 };
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数据：");
int value = sc.nextInt();
int index = -1;
// b.遍历数组，依次获取数组中每一个元素，和要找的数据进行比较
// for (int x = 0; x < arr.length; x++) {
// if (arr[x] == value) {
// index = x;
// break;
// }
// }
System.out.println("index:" + getIndex(arr,value));
}
/*
* 数组元素查找（查找指定元素第一次在数组中出现索引）
*
* 参数列表：int[] arr,int value
* 返回值类型：int
*/
public static int getIndex(int[] arr, int value) {
// 定义一个索引，如果找不到数据，我们一般直接返回一个负数
int index = -1;
for (int x = 0; x < arr.length; x++) {
if (arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
二分查找（折半查找）
/*
- 二分数组查找
- 分析：
- a.定义最大索引，最小索引
- b.计算出中间索引 最大索引+最小索引/2
- c.拿中间值和要查找的值进行比较
-
相等：就返回当前中间索引 -
大于：左边找，max = mid-1 -
小于：右边找，min = mid+1 - 重写计算中间索引，回到b
- */
public class ArrayTest5 {
public static void main(String[] args) {
int[] arr = { 12, 45, 54, 65, 87 };
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数据：");
int value = sc.nextInt();
System.out.println("mid:" + getIndex(arr,value));
}
/*
* 二分数组查找
*
* 参数列表：int[] arr,int value
* 返回值类型：int
* */
public static int getIndex(int[] arr,int value){
// a.定义最大索引，最小索引
int max = arr.length - 1;
int min = 0;
// b.计算出中间索引 最大索引+最小索引/2
int mid = (max + min) / 2;
while (arr[mid] != value) { // false
if (arr[mid] > value) {
max = mid - 1;
} else if (arr[mid] < value) {
min = mid + 1;
}
if(min>max){
return -1;
}
mid = (max + min) / 2;
}
return mid;
}
}
数组查表法
public static void main(String[] args) {
// 定义一个字符串数组
String[] strArray = { "星期天", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数据（0~6）");
int index = sc.nextInt();
System.out.println("今天的日期是：" + strArray[index]);
}
数组排序：
数组选择排序：
/*
* 数组选择排序
*
* 两个明确：
* 参数列表：int[] arr
* 返回值：void
* */
public static void selectSort(int[] arr){
for(int x=0;x<arr.length-1;x++){// 比较的轮次
for (int y = x+1; y < arr.length; y++) {// 和谁进行比较
if(arr[x] > arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
数组冒泡排序：
/*
* 数组冒泡排序
*
* 两个明确：
* 参数列表：int[] arr
* 返回值：void
* */
public static void bubbleSort(int[] arr){
for (int x = 0; x < arr.length - 1; x++) {// 轮次
for (int y = 0; y < arr.length - 1 - x; y++) {
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}
Array工具类
Sort（）方法：对数组元素进行排序
toString（）方法：返回该对象的字符串
binarySearch（）方法：进行二分查找
-3》-1
80》-6
23》-5
不存在，一定是一个负数
Arrays.方法调用
总结：
无序查找：普通查找
有序查找：二分查找
二维数组
二维数组：其实激素一个元素为一维数组的数组
数组里面的元素可以是什么类型的？
基本数据类型，引用数据类型
数组又是一个引用类型的
格式一：
数据类型[][] 数组名（变量名）
定义一个二维数组类型的变量
格式二：
数据类型[] 数组名[]
int[] x[]
定义一个一维数组类型的一堆数组
初始化：
动态初始化
数据类型[][] 数组名 = new 数据类型[m][n]
m代表的是这个二维数组由多少个一维数组
n代表的是每一个一维数组的元素个数
静态初始化
数据类型[][] 数组名 = {{1，2}，{1，2，3}，{2，3}}
1871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
