1. 数组遍历：依次输出数组中的每一个元素
2. 数组元素查找(查找指定元素第一次在数组中出现的索引，不存在返回-1)
3. 定义一个int[] a =｛4，2，0，-1，-8，23，9｝，求数组元素的最大值、最小值、平均数、总和、数组的复制、反转
4. 某百货商场当日消费积分最高的八名顾客，他们的积分分别是：18，25，7，36，13，2，89和63，编写程序找出最低的积分及它在数组中的原始位置（索引）
5. 有30个0-9之间的数字，分别统计0~9这10个数字分别出现了多少次
6. 定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！
7. 定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数
8. 现在定义如下的一个数组：intoldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5},要求将以上数组中值为0的去掉，将不为0的值存入一个新的数组，生成的新数组为：intnewArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
9. 给出10个老师的打分，对10个老师的打分获取最高分
10. 给定一个整型数组，数组成员10个,求该数组中第二大的数的下标
11. B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分
12. 提取一个方法，将指定数组中的数组元素进行反转， 例如：{10,23,2,45,6}—>{6,45,2,23,10}
13. 给数组中插入元素
14.定义一个包含10个元素的数组，对其进行赋值，使每个元素的值等于其下标，然后输出；最后将这个数组倒置后输出
15. 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，计算并输出学生的平均成绩
16. 给定一个有序数组{10,20,40,50} ， 在[9 60]之间随机一个数字,将该数字添加到有序数组中,并且得保证数组还是有序的 (不准加进来之后再排序)
17. 有30个0-9之间的随机数，分别统计0~9这10个数字分别出现了多少次
18. 编写程序求1！+2！+.........30！的和并显示
19. 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，统计各成绩等级（90分以上为‘A’，80-89分为‘B’，70-79分为‘C’，60~69分为‘D’，60分以下为E）学生人数， 并将其放入到数组count中， 其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。
20. 现在给出两个数组： 数组A：1，7，9，11，13，15，17，19 数组b：“2，4，6，8，10”两个数组合并为数组c
21. 比较两个数组的内容是否一样（两个数组所有对应位置的值是否相等）
22. 删除数组中的某一个元素第一次出现的位置
23. 删除数组中某一个元素最后一次出现的位置
24. 定义一个int型数组，从控制台输入一个数字，如果从控制台输入的是正数n，元素整体向右平移n位,例如 元素为 1 2 3 控制台输入2 向右平移两位变为 2 3 1,如果控制台输入的是负数，元素整体向左平移
25. 从键盘输入8个整数存放在一个数组中，然后将奇数和偶数分别存入到两个不同的数组中，并按奇数、偶数交替的顺序输出这两个数组中的所有数据（先交替输出，如果奇数个数多，则再输出剩下的奇数，如果偶数个数多，则再输出剩下的偶数）。（提示与要求：
（1）定义一个数组存储从键盘输入的8个整数， 先判断这8个整数中奇数和偶数的个数，才能定义存储奇数和偶数的数组的长度；
（2）把一个大的数组分别存放在奇数和偶数数组中并交替输出的过程定义为方法）
package demo;
import java.util.Arrays;
import java.util.Scanner;
/**
* 数组习题
* @author Amid
*
*/
public class ArraysPractice{
static Scanner scanner = new Scanner(System.in);//从控制台获取数据的工具
public static void main(String[] args){
//
// /**
// * 1. 数组遍历：依次输出数组中的每一个元素
// */
// int[] arr = {2,3,6,7,1};//定义一个数组
// printArrays(arr);//调用printArrays方法遍历数组
// /**
// * 2. 数组元素查找(查找指定元素第一次在数组中出现的索引，不存在返回-1)
// */
// System.out.println("请输入你要查找的元素值");
// int index = findArraysIndex(arr,scanner.nextInt());//调用findArraysIndex方法，获得元素下标值
// if(index == -1) {
// System.out.println("查找失败");
// }else {
// System.out.println("你所查找的元素下标为" + index);
// }
//
// /**
// * 定义一个int[] a =｛4，2，0，-1，-8，23，9｝
// * 求数组元素的最大值、最小值、平均数、总和、数组的复制、反转
// */
// int[] a = {4,2,0,-1,-8,23,9};
// //求数组元素最大值
// System.out.println("数组内元素最大值是" + findArraysMaxNum(a));
// //求数组元素最小值
// System.out.println("数组内元素最小值是" + findArraysMinNum(a));
// //求数组元素平均数
// System.out.println("数组内元素平均值是" + findArraysAverageNum(a));
// //求数组元素总和
// System.out.println("数组内元素总和是" + findArraysSumNum(a));
// //数组的复制
// printArrays(copyArrays(a));//打印得到的新数组
//
// System.out.println();
//
// //数组的反转
// printArrays(reverseArrays(a));//打印得到的新数组
//
// System.out.println();
//
// /**
// * 某百货商场当日消费积分最高的八名顾客，
// * 他们的积分分别是：18，25，7，36，13，2，89和63.
// * 编写程序找出最低的积分及它在数组中的原始位置（索引）
// */
// int[] b = {18,25,7,36,13,2,89,63};
// //求数组元素最小值
// System.out.println("最低积分是" + findArraysMinNum(b));
// System.out.println("最低积分在数组中的索引是" + findArraysIndex(b, findArraysMinNum(b)));
//
// /**
// * 有30个0-9之间的数字，分别统计0~9这10个数字分别出现了多少次
// */
// int[] c = {0,1,2,3,4,5,6,7,8,9,
// 0,1,2,3,4,5,6,7,8,9,
// 0,1,2,3,4,5,6,7,8,9};
// //统计数组内元素出现次数
// findArraysNumOccurrences(c);
//
//
// System.out.println();
//
// /**
// * 定义一个整型数组，保存10个数据，
// * 利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！
// */
// int[] d = {23,77,89,112,9,33,26,11,0,5};
// printArrays(d);//打印原数组
//
// System.out.println();
//
// printArrays(findArraysMaxNumAndExchangeFirstToMax(d));//打印新数组
//
// System.out.println();
//
// /**
// * 定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数
// */
// int[] e = {2,4,5,1,8,10,3,7};//偶数4个，奇数4个
// findArraysOddAndEvenNum(e);
//
// System.out.println();
//
// /**
// * 现在定义如下的一个数组：intoldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5},
// * 要求将以上数组中值为0的去掉，将不为0的值存入一个新的数组，
// * 生成的新数组为：intnewArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
// */
// int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
// printArrays(deleteArraysOneNum(oldArr, 0));
//
// System.out.println();
//
// /**
// * 给出10个老师的打分，对10个老师的打分获取最高分
// */
// int[] achievement = new int[10];
// System.out.println("10个老师的分数分别为：");
// printArrays(fromControlGiveNum(achievement));//十个老师的分数分别为
//
// System.out.println();
//
// System.out.println("最高分是：" + findArraysMaxNum(achievement));//最高分
//
// /**
// * 给定一个整型数组，数组成员10个,求该数组中第二大的数的下标
// */
// int[] f = {100,44,1,78,9,33,6,0,2,1};
// System.out.println("数组中第二大的数的下标为" + findArraysSecondMaxNum(f));
//
// /**
// * B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分
// */
// int[] g = {55,78,90,40,88,100,20,80,67,70};
// System.out.println(deleteArraysMaxAndMinNumToFindAverage(g));
//
// /**
// * 提取一个方法，将指定数组中的数组元素进行反转
// * 例如：{10,23,2,45,6}—>{6,45,2,23,10}
// */
// int[] h = {10,23,2,45,6};
// printArrays(h);
//
// System.out.println();
//
// printArrays(reverseArrays(h));
//
// /**
// * 给数组中插入元素
// */
// int[] m = new int[10];
// fromControlGiveNum(m);//从控制台给数组m内元素赋值
// arraysBubbleSort(m);//给数组m按照升序排序
// System.out.println("请输入你要插入的元素值");
// int num = scanner.nextInt();
// int index = findNumInOrderSortIndex(m,num);//找到插入位置
// printArrays(insertNumToArrays(m, index, num));//打印插入元素后的新数组
//
// /**
// * 定义一个包含10个元素的数组，对其进行赋值，
// * 使每个元素的值等于其下标，然后输出；最后将这个数组倒置后输出
// */
// int[] n = new int[10];
// printArrays(arraysIndexEqualToNum(n));//打印数组内每个元素的值等于其下标的数组
// System.out.println();
// printArrays(reverseArrays(arraysIndexEqualToNum(n)));//打印反转后的数组
//
// /**
// * 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，
// * 计算并输出学生的平均成绩
// */
// int[] p = {72,89,65,58,87,91,53,82,71,93,76,68};
// System.out.println("学生的平均成绩是" + findArraysAverageNum(p));
//
// /**
// * 给定一个有序数组{10,20,40,50}
// * 在[9 60]之间随机一个数字,将该数字添加到有序数组中,
// * 并且得保证数组还是有序的 (不准加进来之后再排序)
// */
// int[] q = {10,20,40,50};
// int num = (int)(Math.random() * 52) + 9;//在[9 60]之间随机一个数字
// int index = findNumInOrderSortIndex(q, num);//找到随机数要插入在有序数组内的下标值
// printArrays(insertNumToArrays(q, index, num));
//
// /**
// * 有30个0-9之间的随机数，分别统计0~9这10个数字分别出现了多少次
// */
// int[] r = new int[30];
// for(int i = 0; i < r.length; i++) {
// r[i] = (int)(Math.random()* 10);//将0~9的随机数赋值给数组内元素
// }
// printArrays(r);
// System.out.println();
// findArraysNumOccurrences(r);
//
// /**
// * 编写程序求1！+2！+.........30！的和并显示
// */
// double endSum = 0;
// for(int i = 1; i <= 30; i++) {
// double sum = 1;
// for(int j = 1; j <= i; j++) {
// sum = sum * j;
// }
// endSum = endSum + sum;
// }
// System.out.println(endSum);
//
// /**
// * 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，
// * 统计各成绩等级（90分以上为‘A’，80-89分为‘B’，
// * 70-79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，
// * 并将其放入到数组count中，
// * 其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。
// */
// int[] s = {72,89,65,58,87,91,53,82,71,93,76,68};
// int[] count = new int[5];//放E D C B A五个等级的人数
// for(int i = 0; i < s.length; i++) {
// if(s[i] >= 90) {//A等级
// count[4]++;
// }else if(s[i] >= 80) {
// count[3]++;
// }else if(s[i] >= 70) {
// count[2]++;
// }else if(s[i] >= 60) {
// count[1]++;
// }else {
// count[0]++;
// }
// }
// printArrays(count);
//
// /**
// * 现在给出两个数组：
// * 数组A：1，7，9，11，13，15，17，19
// * 数组b：“2，4，6，8，10”
// * 两个数组合并为数组c
// */
// int[] A = {1,7,9,11,13,15,17,19};
// int[] B = {2,4,6,8,10};
// printArrays(addTwoArrays(A, B));
//
// /**
// * 比较两个数组的内容是否一样（两个数组所有对应位置的值是否相等）
// */
// int[] a = {1,2,3,4,5};
// int[] b = {1,2,3,4,5,6};
// findTwoArraysIsSameOrDiffer(a, b);
//
// /**
// * 删除数组中的某一个元素第一次出现的位置
// */
// int[] a = {1,2,35,66,12,43,35,77};
// System.out.println("请输入你要删除的元素值");
// int num = scanner.nextInt();
// int index = findArraysIndex(a, num);
// printArrays(deleteNumFirstIndex(a, index, num));
//
// /**
// * 删除数组中某一个元素最后一次出现的位置
// */
// int[] a = {1,2,35,66,12,43,35,77};
// System.out.println("请输入你要删除的元素值");
// int num = scanner.nextInt();
// deleteNumLastIndex(a, num);
//
// /**
// * 定义一个int型数组，从控制台输入一个数字，如果从控制台输入的是正数n，
// * 元素整体向右平移n位,例如 元素为 1 2 3 控制台输入2 向右平移两位变为 2 3 1,
// * 如果控制台输入的是负数，元素整体向左平移
// */
// int[] a = {1,2,3,4,5};
// System.out.println("请输入一个数字");
// int num = scanner.nextInt();
// moveArrays(a, num);
//
// /**
// * 从键盘输入8个整数存放在一个数组中，
// * 然后将奇数和偶数分别存入到两个不同的数组中，
// * 并按奇数、偶数交替的顺序输出这两个数组中的所有数据
// * （先交替输出，如果奇数个数多，则再输出剩下的奇数，如果偶数个数多，则再输出剩下的偶数）。
// * （提示与要求：
// * （1）定义一个数组存储从键盘输入的8个整数，
// * 先判断这8个整数中奇数和偶数的个数，才能定义存储奇数和偶数的数组的长度；
// * （2）把一个大的数组分别存放在奇数和偶数数组中并交替输出的过程定义为方法）
// */
// int[] arr = {2,6,4,1,7,0,5,22,11,77,46,55,2,8};
// oddAndEvenPrintArrays(arr);
}
/**
* 从键盘输入8个整数存放在一个数组中，
* 然后将奇数和偶数分别存入到两个不同的数组中，
* 并按奇数、偶数交替的顺序输出这两个数组中的所有数据
*/
static void oddAndEvenPrintArrays(int[] arrays) {
//得到旧数组内奇数和偶数的个数
int oddCount = 0;//标识奇数
int evenCount = 0;//标识偶数
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] % 2 == 0) {//偶数
evenCount++;
}else {
oddCount++;
}
}
System.out.println("偶数个数" + evenCount);
System.out.println("奇数个数" + oddCount);
int[] oddArrays = new int[oddCount];//奇数数组
int[] evenArrays = new int[evenCount];//偶数数组
int[] arraysNew = new int[oddCount + evenCount];//奇偶交替的新数组
//奇数偶数数组各自赋值
int m = 0;//偶数数组下标移动标记
int n = 0;//奇数数组下标移动标记
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] % 2 == 0) {//偶数
evenArrays[m] = arrays[i];
m++;
}else {
oddArrays[n] = arrays[i];
n++;
}
}
System.out.println("偶数数组");
printArrays(evenArrays);//打印偶数数组
System.out.println();
System.out.println("奇数数组");
printArrays(oddArrays);//打印奇数数组
System.out.println();
//放进新数组
if(oddCount > evenCount) {//奇数数组元素 > 偶数数组元素
int j = 0;
for(int i = 0; i < evenCount; i++) {
arraysNew[j] = oddArrays[i];
j++;
arraysNew[j] = evenArrays[i];
j++;
}
for( ;j < arraysNew.length; j++) {
arraysNew[j] = oddArrays[evenCount];
evenCount++;
}
}else if(oddCount < evenCount) {//偶数数组元素 > 奇数数组元素
int j = 0;
for(int i = 0; i < oddCount; i++) {
arraysNew[j] = oddArrays[i];
j++;
arraysNew[j] = evenArrays[i];
j++;
}
for( ;j < arraysNew.length; j++) {
arraysNew[j] = evenArrays[oddCount];
oddCount++;
}
}else {
int j = 0;
for(int i = 0; i < oddCount; i++) {
arraysNew[j] = oddArrays[i];
j++;
arraysNew[j] = evenArrays[i];
j++;
}
}
System.out.println("奇偶交替的新数组");
printArrays(arraysNew);
}
/**
* 如果传入的是正数n，元素整体向右平移n位
* 如果传入的是负数，元素整体向左平移
*/
static void moveArrays(int[] arrays, int num) {
if(num > 0) {//正数，向右移num
for(int i = 0; i < num; i++) {//移动次数
int temp = arrays[arrays.length - 1];//把最右边的值存起来
for(int j = arrays.length - 2; j >= 0; j--) {
arrays[j + 1] = arrays[j];
}
arrays[0] = temp;
}
}else if(num < 0) {//负数，向左移
for(int i = 0; i < (-num); i++) {//移动次数
int temp = arrays[0];//把最左边的值存起来
for(int j = 1; j < arrays.length; j++) {
arrays[j - 1] = arrays[j];
}
arrays[arrays.length - 1] = temp;
}
}
printArrays(arrays);
}
/**
* 删除数组中某一个元素最后一次出现的位置
*/
static void deleteNumLastIndex(int[] arrays, int num) {
int index = -1;
for(int i = 0; i < arrays.length; i++) {
if(num == arrays[i]) {
index = i;
}
}
if(index == -1) {
System.out.println("数组内没有你想要的元素值");
return;
}else {
printArrays(deleteNumFirstIndex(arrays, index, num));
}
}
/**
* 删除数组中的某个位置的元素
*/
static int[] deleteNumFirstIndex(int[] arrays, int index, int num) {
int[] arraysNew = new int[arrays.length - 1];
for(int i = 0; i < arraysNew.length; i++) {
if(i < index) {
arraysNew[i] = arrays[i];
}else {
arraysNew[i] = arrays[i + 1];
}
}
return arraysNew;
}
/**
* 比较两个数组的内容是否一样（两个数组所有对应位置的值是否相等）
*/
static void findTwoArraysIsSameOrDiffer(int[] arrays1, int[] arrays2) {
if(arrays1.length != arrays2.length) {
System.out.println("两个数组不一样");
}else {
for(int i = 0; i < arrays1.length; i++) {
if(arrays1[i] != arrays2[i]) {
System.out.println("两个数组不一样");
return;
}
}
System.out.println("两个数组一样");
}
}
/**
* 将两个数组合并为一个数组
*/
static int[] addTwoArrays(int[] arrays1, int[] arrays2) {
int[] arraysNew = new int[arrays1.length + arrays2.length];
for(int i = 0; i < arrays1.length; i++) {
arraysNew[i] = arrays1[i];//把第一个数组的值都赋进新数组
}
for(int i = 0; i < arrays2.length; i++) {
arraysNew[arrays1.length + i] = arrays2[i];
}
return arraysNew;
}
/**
* 快慢索引给有序数组去重
*/
static int[] quicklyAndSlowIndexToDeleteRepeat(int[] arrays) {
int slowIndex = 0;
int quicklyIndex = 1;
while(quicklyIndex < arrays.length) {
if(arrays[slowIndex] != arrays[quicklyIndex]) {
slowIndex++;
arrays[slowIndex] = arrays[quicklyIndex];
}
quicklyIndex++;
}
return Arrays.copyOfRange(arrays, 0, slowIndex + 1);
}
/**
* 数组内每个元素的值等于其下标
*/
static int[] arraysIndexEqualToNum(int[] arrays) {
for(int i = 0; i < arrays.length; i++) {
arrays[i] = i;
}
return arrays;
}
/**
* 给数组插入一个数字，生成新的数组
*/
static int[] insertNumToArrays(int[] arrays, int index, int num) {
int[] arraysNew = new int[arrays.length + 1];
for(int i = 0; i < arrays.length; i++) {
if(i < index) {//插入位置之前的元素，原封不动挪进新数组里面
arraysNew[i] = arrays[i];
}else {
arraysNew[i + 1] = arrays[i];
}
}
arraysNew[index] = num;
return arraysNew;
}
/**
* 给一个元素值，找到它要插入在有序数组内的下标值
*/
static int findNumInOrderSortIndex(int[] arrays, int num) {
int index = 0;
for(int i = 0; i < arrays.length; i++) {
if(num >= arrays[i]) {
index = i + 1;
}
}
return index;//num的值比数组中任何一个元素值都小
}
/**
* 冒泡排序
* 给数组进行排序，升序
*/
static int[] arraysBubbleSort(int[] arrays) {
for(int i = 0; i < arrays.length - 1; i++) {
for(int j = 0; j < arrays.length - i - 1; j++) {
if(arrays[j] > arrays[j + 1]) {
int temp = arrays[j + 1];
arrays[j + 1] = arrays[j];
arrays[j] = temp;
}
}
}
return arrays;
}
/**
* 数组内元素，去掉最高和最低，求剩余元素平均值
*/
static double deleteArraysMaxAndMinNumToFindAverage(int[] arrays) {
int min = findArraysMinNum(arrays);//找到最小值
int max = findArraysMaxNum(arrays);//找到最大值
int minIndex = findArraysIndex(arrays, min);//找到数组内最小值的下标
int maxIndex = findArraysIndex(arrays, max);//找到数组内最大值的下标
double sum = 0;
for(int i = 0; i < arrays.length; i++) {
if(i != minIndex && i != maxIndex) {
sum = sum + arrays[i];
}
}
return (sum / (arrays.length - 2));
}
/**
* 求数组中第二大的数的下标
*/
static int findArraysSecondMaxNum(int[] arrays) {
int max = 0;
int secondMax = 0;
for(int i = 0; i < arrays.length; i++) {//找到最大的
if(arrays[i] > arrays[max]) {
max = i;
}
}
if(secondMax == max) {
secondMax++;
}
for(int i = 0; i < arrays.length; i++) {
if(i != max) {//除掉最大的，再找剩下的里面的最大的
if(arrays[i] > arrays[secondMax]) {
secondMax = i;
}
}
}
return secondMax;
}
/**
* 从控制台给数组内元素赋值
*/
static int[] fromControlGiveNum(int[] arrays) {
for(int i = 0; i < arrays.length; i++) {
System.out.println("请输入第"+ (i + 1) + "个老师的分数");
arrays[i] = scanner.nextInt();
}
return arrays;
}
/**
* 将数组中某个值去掉（这个值有可能重复），剩余的元素生成新数组
*/
static int[] deleteArraysOneNum(int[] arrays, int num) {
int[] arraysNew = new int[arrays.length];
int count = 0;
int index = 0;
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] == num) {
count++;
}else {
arraysNew[index] = arrays[i];
index++;
}
}
return Arrays.copyOfRange(arraysNew, 0, arrays.length-count);//前包含后不包含
}
/**
* 统计数组中的奇数个数和偶数个数
*/
static void findArraysOddAndEvenNum(int[] arrays) {
int oddCount = 0;//标识奇数
int evenCount = 0;//标识偶数
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] % 2 == 0) {//偶数
evenCount++;
}else {
oddCount++;
}
}
System.out.println("偶数个数是：" + evenCount);
System.out.println("奇数个数是：" + oddCount);
}
/**
* 将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置
*/
static int[] findArraysMaxNumAndExchangeFirstToMax(int[] arrays) {
int max = 0;
//找到最大值下标
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] > arrays[max]) {
max = i;
}
}
//交换
int temp = arrays[0];
arrays[0] = arrays[max];
arrays[max] = temp;
return arrays;
}
/**
* 统计数组内元素出现次数
*/
static void findArraysNumOccurrences(int[] arrays) {
int[] arraysNew = new int[arrays.length];
int index = 0;
for(int i = 0; i < arrays.length; i++) {//原数组
boolean flag = false;
int count = 0;
//判断这个数组是否已经被统计
for(int j = 0; j < index; j++) {
if(arrays[i] == arraysNew[j]) {
flag = true;
break;
}
}
if(flag) {
continue;
}
arraysNew[index] = arrays[i];
index++;
for(int k = i; k < arrays.length; k++) {
//这里k == i是现在能拿到的数字，肯定在之前没有出现过，所以只需要统计后面的就好
if(arrays[i] == arrays[k]) {
count++;
}
}
System.out.println(arrays[i] + "出现了" + count + "次");
}
}
/**
* 数组的反转
*/
static int[] reverseArrays(int[] arrays) {
for(int i = 0; i < arrays.length / 2; i++) {
int temp = arrays[i];
arrays[i] = arrays[arrays.length - 1 - i];
arrays[arrays.length - 1 - i] = temp;
}
return arrays;
}
/**
* 数组的复制
*/
static int[] copyArrays(int[] arrays) {
int[] arraysNew = new int[arrays.length];
for(int i = 0; i < arrays.length; i++) {
arraysNew[i] = arrays[i];
}
return arraysNew;
}
/**
* 求数组元素总和
*/
static int findArraysSumNum(int[] arrays) {
int sum = 0;
for(int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
return sum;
}
/**
* 求数组元素平均数
*/
static double findArraysAverageNum(int[] arrays) {
double sum = 0;
for(int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
return (sum / arrays.length);
}
/**
* 求数组元素的最小值
*/
static int findArraysMinNum(int[] arrays) {
int min = 0;
for(int i = 1; i < arrays.length; i++) {
if(arrays[i] < arrays[min]) {
min = i;
}
}
return arrays[min];
}
/**
* 求数组元素的最大值
*/
static int findArraysMaxNum(int[] arrays) {
int max = 0;
for(int i = 1; i < arrays.length; i++) {
if(arrays[i] > arrays[max]) {
max = i;
}
}
return arrays[max];
}
/**
* 数组元素查找(查找指定元素第一次在数组中出现的索引，不存在返回-1)
*/
static int findArraysIndex(int[] arrays, int num) {
for(int i = 0; i < arrays.length; i++) {
if(arrays[i] == num) {
return i;
}
}
return -1;
}
/**
* 数组遍历
*/
static void printArrays(int[] arrays) {
for(int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
}
代码内有的变量名称可能重复定义，这是因为我在写的时候是写一个注释一个，所以可能导致下面的命名和上面的相同。
刚开始学java，这些代码都是自己写的，有什么不对的地方，还请指正，我们共同学习、共同进步，谢谢！
再补充一个习题：给定一个年月日，计算该日期是该年的第几天
/*
*给定一个年月日，计算该日期是该年的第几天
*/
int[] months = {31,28,31,30,31,30,31,31,30,31,30,31};
int year = 1987;
int month = 4;
int day = 8;
//判断闰年
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
months[1] = 29;
}
//判断月份是否正确
if(month > 12 || month < 1){
System.out.println("月份输入有误");
return;
}
//判断日期是否正确
//一月天数就是下标为0的元素
if(day < 1 || day > months[month-1]){
System.out.println("日期输入有误");
return;
}
//月份-1就是对应的下标
for(int i = 0; i < month-1; i++){
sum = sum + months[i];
}
System.out.println("是该年的第" + sum + "天");
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）