日常代码分享(Java)
都是详解，好好看，肯定有收获，不是我吹自己，详细看了就清楚了
分享1:
随机生成用户指定的个整数(1-100)保存到数组
并倒叙打印出来以及求平均值、求最大值和最大值下标
并查找里面是否有 8
思路分析
由于此次代码比较简单，以及化繁为简以及先死后活一体讨论
1. 首先提示用户输入需要打印的随机数个数
2. 定义数组
3. 随机产生用户指定的随机数个数，并保存到数组当中
4. 倒叙排序并打印
5. 求平均值、最大值和最大值下标、最小值和最小值下标
6. 判断并查找里面是否有客户指定的随机数，给出提示
import java.util.Scanner;
public class HomeWorkSix
{
public static void main(String[] args)
{
/*
随机生成用户指定的个整数(1-100)保存到数组
并倒叙打印出来以及求平均值、求最大值和最大值下标
并查找里面是否有 8
思路分析
由于此次代码比较简单，以及化繁为简以及先死后活一体讨论
1. 首先提示用户输入需要打印的随机数个数
2. 定义数组
3. 随机产生用户指定的随机数个数，并保存到数组当中
4. 倒叙排序并打印
5. 求平均值、最大值和最大值下标、最小值和最小值下标
6. 判断并查找里面是否有客户指定的随机数，给出提示
*/
byte[] arr; // 定义数组
System.out.print("请输入需要产生的随机数个数:");
Scanner mydScanner = new Scanner(System.in); // 定义扫描仪从键盘接收
byte individual = mydScanner.nextByte(); // 定义-接收开空间大小
arr = new byte[individual]; //开空间
for(byte i=0;i<arr.length;i++)
{
arr[i] = (byte) (Math.random() * 100 + 1); // 产生用户指定的随机个数
}
byte Maxnum = arr[0]; // 必须赋初值
byte Minnum = arr[0]; // 必须赋初值
byte temp = 0; // 统计次数，用于控制每行个数
byte Maxindex = 0, Minindex = 0; // 下标
float And = 0; // 求和 注意：byte最大存储 -124～123 之间的数用于求和属实不妥
// 排序 注意，由于有i+1，故会少进行一步，需要注意，应为 i < individual-1;
for (byte i = 0; i < arr.length-1; i++) 外层循环是(Array.length - 1)
{
for (byte j = 0; j < arr.length - 1 - i; j++) // 内层比较 = (Array.length - 1 - i)次比较
{
// 如果前面一个数小于后面一个数，就交换
if (arr[j] < arr[j + 1]) // 将最小的放到最后
{
// 注意：此处强转需要整体强转，不可以单独全部(个别)或者单个进行强转
arr[j] = (byte) (arr[j] ^ arr[j + 1]);
arr[j + 1] = (byte) (arr[j] ^ arr[j + 1]); // 注意：应该为内层 arr[j] 不是外层 arr[i]
arr[j] = (byte) (arr[j] ^ arr[j + 1]);
}
}
}
System.out.println("===排序后的数组如下===");
for (byte i = 0; i < individual; i++)
{
System.out.print("arr[" + i + "]=" + arr[i] + "\t");
temp++;
if (temp % 5 == 0)
System.out.println(); // 每输出5个就换行
}
for (byte i = 0; i < individual; i++)
{
And += (byte)arr[i]; // 求和
if (arr[i] > Maxnum) // 求最大值和最大值下标、最小值和最小值下标
{
Maxnum = arr[i];
Maxindex = i;
}
if (arr[i] < Minnum) // 注意；此处不可以用 else。一点一点需要注意
{
Minnum = arr[i];
Minindex = i;
}
}
System.out.println("\n平均数为:" + (And / arr.length));
System.out.print("最大值为:" + Maxnum + "\t最大值下标为:" + Maxindex + "\n最小值为:" + Minnum + "\t最小值下标为:" + Minindex);
}
}
分享2:
定义数组 可以采取 用户输入 + 排序，也可以采取随机生成 + 排序，本次采取 用户输入 + 排序，更加接近生活习惯
面临的问题有：
1. 用户有原始数组，原始数组的输入问题，主要是如何开空间
2. 如何没有原始数组，直接插入，开空间的问题
3. 主要问题就是客户开空间问题
4. 未能使用函数的调用
5. byte[] Array = null;
if (Array == null || Array.length == 0) 必须需要初始化数组问题
解决方案：
1. 目前使用较为好的方法，使用 (do + while) 循环 + (if + else) 完成客户的持续输入，决定权在客户手里
思路分析:
先死后活
1. 先使得客户端输入原始数组，当然也可以直接插入，这对初始来说，意义不大，不必钻牛角尖
2. 如果硬要钻牛角尖，可以采取 swith 来实现效果，这里不在啰嗦
拓展
更多细节请看下一篇博客
提示：采取 arraylist 的方法，更加灵活
注意：初始化数组且未使用数据库，程序每次重新启动 arr都为 null
import java.util.Scanner;
public class HomeWorkFive
{
public static void main(String[] args)
{
Scanner mysScanner = new Scanner(System.in);
/*
定义数组 可以采取 用户输入 + 排序，也可以采取随机生成 + 排序，本次采取 用户输入 + 排序，更加接近生活习惯
面临的问题有：
1. 用户有原始数组，原始数组的输入问题，主要是如何开空间
2. 如何没有原始数组，直接插入，开空间的问题
3. 主要问题就是客户开空间问题
4. 未能使用函数的调用
5. byte[] Array = null;
if (Array == null || Array.length == 0) 必须需要初始化数组问题
解决方案：
1. 目前使用较为好的方法，使用 (do + while) 循环 + (if + else) 完成客户的持续输入，决定权在客户手里
思路分析:
先死后活
1. 先使得客户端输入原始数组，当然也可以直接插入，这对初始来说，意义不大，不必钻牛角尖
2. 如果硬要钻牛角尖，可以采取 swith 来实现效果，这里不在啰嗦
拓展
更多细节请看下一篇博客
提示：采取 arraylist 的方法，更加灵活
注意：初始化数组且未使用数据库，程序每次重新启动 arr都为 null
*/
byte[] arr;
arr = null;
System.out.print("是否需要给数组随机生成数(Y/N):");
char tempnum = mysScanner.next().charAt(0);
if(tempnum=='Y')
{
System.out.print("请输入需要随机生成数的个数:");
byte temp = mysScanner.nextByte();
for (byte i = 0; i < temp; i++)
{
arr = new byte[temp];
arr[i] = (byte) (Math.random() * 100 + 1);
System.out.print("arr[" + (i + 1) + "]=" + arr[i] + " ");
}
}
// else
// {
// arr = null;
// }
if (arr == null || arr.length == 0)
{
do {
byte temp = 0;
System.out.print("\n请输入需要输入数的个数:");
byte Usernum = mysScanner.nextByte(); // Usernum 初始化数组的长度
arr = new byte[Usernum]; // 给数组开空间
for (byte i = 0; i < arr.length; i++)
{
System.out.print("请输入第" + (i + 1) + "个数:");
byte Uservalue = mysScanner.nextByte(); // Uservalue 为数组赋值
arr[i] = Uservalue;
}
System.out.println("输入完毕!感谢使用");
// System.out.println("===输入后,对arr排序===");
// 输入后,对arr排序
for (byte i = 0; i < arr.length; i++) // 外层循环是(Array.length - 1)
{
for (byte j = 0; j < arr.length - i - 1; j++) // 内层比较 = (Array.length - 1 - i)次比较
{
// 如果前面一个数大于后面一个数，就交换
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
/*
System.out.println("\t\t\t\t===第" + (i + 1) + "轮===");
for (byte j = 0; j < arr.length; j++)
{
System.out.print("arr[" + (j + 1) + "]=" + arr[j] + "\t");
}
System.out.println();
*/
}
System.out.println("=====排序后,arr数组的情况=====");
for (byte i = 0; i < arr.length; i++) {
System.out.print("arr[" + (i + 1) + "]=" + arr[i] + " ");
}
System.out.println("\n是否需要重复输入(Y/N):" + " ");
char tempnumber = mysScanner.next().charAt(0);
if (tempnumber == 'N') {
System.out.println("欢迎下次使用!");
break;
}
} while (true);
}
do
{
/*
已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
比如：[10,12,45,90],添加 23 后，该数组为[10,12,23,45,90]
思路分析
本质 数组扩容 + 定位
1. 我们先确定 添加数应该插入到那个索引
2. 然后扩容
*/
byte index = -1; // index就是要插入到位置
/*
定位
遍历 arr 数组，如果发现 insernum <= arr[i],说明 i 就是要插入的位置
使用 index 保留 index = -i；
如果遍历完后，没有发现 insernum <= arr[i]，说明 index = arr.length
即：添加到 arr 到最后
*/
System.out.print("\n请输入需要插入的个数:");
byte num=mysScanner.nextByte();
for (byte count = 1; count <= num; count++)
{
System.out.print("请输入需要插入的第" + count + "个数:");
byte Userinsert = mysScanner.nextByte(); // Uservalue 为数组赋值
for (byte i = 0; i < arr.length; i++)
{
if (Userinsert < arr[i]) {
index = i;
break; // 找到就退出，因为数组为升序排列
}
}
// 判断 index 到值，以确定输入到数的位置
if (index == -1) // 说明还没有找到位置，则insernum大于整个数组元素，位置在最后一个
{
index = (byte) arr.length;
}
// 扩容
// 创建一个新的数组，大小 arr.length + 1
byte[] arrnew = new byte[arr.length + 1];
/*
下面将 arr 的元素拷贝到 arrnew，并且要跳过 index 位置
分析
byte[] arr = { 10, 12, 45, 90 };
arrnew = {[10],[12],[ ],[45],[90]};
*/
// i 用来控制 arrnew的下标，j 用来控制 arr的下标
for (byte i = 0, j = 0; i < arrnew.length; i++)
{
if (i != index) // 说明可以把 arr 的元素拷贝到 arrnew
{
arrnew[i] = arr[j];
j++;
}
else // i 这个位置就是要插入的数
{
arrnew[i] = Userinsert;
}
}
// 让 arr 指向 arrnew，原来的数组，就成为垃圾，被销毁
arr = arrnew;
}
System.out.println("=====插入后,arr数组的情况=====");
for (byte i = 0; i < arr.length; i++)
{
System.out.print("arr[" + (i + 1) + "]=" + arr[i] + " ");
}
System.out.println("\n是否需要重复输入(Y/N):" + " ");
char tempnumber = mysScanner.next().charAt(0);
if (tempnumber == 'N') {
System.out.println("欢迎下次使用!");
break;
}
} while (true);
}
}
分享3:
已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
比如：[10,12,45,90],添加 23 后，该数组为[10,12,23,45,90]
思路分析
本质 数组扩容 + 定位
1. 我们先确定 添加数应该插入到那个索引
2. 然后扩容
public class HomeWorkFour
{
public static void main(String[] args)
{
/*
已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
比如：[10,12,45,90],添加 23 后，该数组为[10,12,23,45,90]
思路分析
本质 数组扩容 + 定位
1. 我们先确定 添加数应该插入到那个索引
2. 然后扩容
*/
// 先定义原数组
byte[] arr = { 10, 12, 45, 90 };
byte insernum = 23;
byte index = -1; // index就是要插入到位置
/*
定位
遍历 arr 数组，如果发现 insernum <= arr[i],说明 i 就是要插入的位置
使用 index 保留 index = -i；
如果遍历完后，没有发现 insernum <= arr[i]，说明 index = arr.length
即：添加到 arr 到最后
*/
for(byte i=0;i<arr.length;i++)
{
if(insernum<arr[i])
{
index = i;
break; // 找到就退出，因为数组为升序排列
}
}
// 判断 index 到值，以确定输入到数的位置
if(index==-1) // 说明还没有找到位置，则insernum大于整个数组元素，位置在最后一个
{
index = (byte) arr.length;
}
// 扩容
// 创建一个新的数组，大小 arr.length + 1
byte[] arrnew = new byte[arr.length + 1];
/*
下面将 arr 的元素拷贝到 arrnew，并且要跳过 index 位置
分析
byte[] arr = { 10, 12, 45, 90 };
arrnew = {[10],[12],[ ],[45],[90]};
*/
// i 用来控制 arrnew的下标，j 用来控制 arr的下标
for(byte i=0,j=0;i<arrnew.length;i++)
{
if (i != index) // 说明可以把 arr 的元素拷贝到 arrnew
{
arrnew[i] = arr[j];
j++;
}
else // i 这个位置就是要插入的数
{
arrnew[i] = insernum;
}
}
// 让 arr 指向 arrnew，原来的数组，就成为垃圾，被销毁
arr = arrnew;
System.out.println("=====插入后,arr数组的情况=====");
for (byte i = 0; i < arr.length;i++)
{
System.out.print("arr[" + (i + 1) + "]=" + arr[i]+" ");
}
}
}
注：本期文主要为读者自己看，希望读者可以好好读读
喜欢来个一键三连，让我们一起期待下一篇博客
感谢各位🙏
扫一扫
113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
