首先说一下自己的一些思考吧，最近边复习考试边学习有很多东西没有及时记录下来，今天考完试正好来回忆一下：
首先，自己对于Comparable接口作用的感想，最近学习了很多排序算法，发现其中很多排序算法都是用到了一个固定的API就是
你会发现他使用的次数最多然后我还有一个疑惑就是这个Comparable接口,第一次接触，很好奇他是干什么用的，通过查找资料发现，这个接口其实就是sort方法的本质，我们在使用sort方法然后点击进去以后查看源码就会发现这个
public final class String
implements Serializable, Comparable, CharSequence｛
...
｝
显而易见，sort也实现了这个接口，但是sort我们知道只是对于数组排序，但是这个Comparable接口却是一个泛型，所以说我们可以通过调用Comparable的接口，实现自己更多的功能。顺带介绍一下这个接口里面只有一个comparable.to，用于作比较并且返回0，-1，1三个值，但是如果是字符串的话就是返回字符串的长度差，这里我们可以选择通过查看源码的方式发现：
首先，写一个测试类
然后我们叫鼠标放到compareTo后点击ctrl同时左击鼠标进入这个接口：
然后ctrl+f查找compareTo记得T要大写
然后我们就可以显而易见的看懂这个方法，然后我们测一下字符串：
String str1 = "Strings";
String str2 = "Strings";
String str3 = "Strings123";
int result = str1.compareTo( str2 );
System.out.println(result);
result = str2.compareTo( str3 );
System.out.println(result);
result = str3.compareTo( str1 );
System.out.println(result);
结果：
同样的方式进入源码：
我们可以看到和刚刚进入看到的不太一样，这里是字符串的实现方法，也是可以一下子看明白滴！
分割线·························································································
说一下第二个就是自己最近实现的单链表：
写这些算法自己感觉代码其实都是从后往前写，你一开始写的其实是最下面的代码，随着功能的增多慢慢浮现到上面 。
package 单链表;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-06 8:50
*/
public class SingleLinkListDemo {
public static void main(String[] args) {
// 进行测试
//先创建节点
HeroNode hero1 = new HeroNode(1, "松江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建一个链表
SingleLinkList singleLinkList = new SingleLinkList();
//加入
// singleLinkList.add(hero1);
// singleLinkList.add(hero2);
// singleLinkList.add(hero3);
// singleLinkList.add(hero4);
//加入按照编号的顺序
singleLinkList.addByOrder(hero1);
singleLinkList.addByOrder(hero4);
singleLinkList.addByOrder(hero2);
singleLinkList.addByOrder(hero3);
//显示(修改之前)
singleLinkList.list();
//测试修改节点的代码
HeroNode newHeroNode = new HeroNode(2, "小卢", "小尾巴~~");
singleLinkList.update(newHeroNode);
System.out.println("修改后的链表结构");
singleLinkList.list();
//删除一个节点
singleLinkList.del(1);
System.out.println("删除后链表的情况~~~");
singleLinkList.list();
}
//定义一个SingleLinkList
static class SingleLinkList {
//先初始化一个头节点,头节点不要动,并且不放具体的数据
private HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//当不考虑编号顺序时，找到当前这个链表最后这个节点，将最后这个节点的next域指向新的节点
public void add(HeroNode heroNode) {
// 因为head节点不能动，因此我们需要一个辅助变量，temp，
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到链表的最后
if (temp.next == null) {
break;
}
//如果没有找到最后,就将temp后移
temp = temp.next;
}
//当退出while循环时，temp指向链表的最后
temp.next = heroNode;
}
//第二种添加方式，根据排名插入到指定位置
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动，因此任然通过一个辅助指针（变量）来帮助找到添加的位置
//因为是单链表，因此我们找的这个temp是位于添加位置的天一阁节点，否则插入不了
HeroNode temp = head;
boolean flag = false; //标识添加的编号是否存在，默认为false
while (true) {
if (temp.next == null) {
//说明temp已经在链表的最后
break;
}
if (temp.next.no > heroNode.no) {
//位置找到，就在temp的后面插入
break;
} else if (temp.next.no == heroNode.no) {
// 说明希望添加的heronode的编号已经存在
flag = true; // 说明编号存在
break;
}
temp = temp.next; // 后移，遍历当前链表
}
// 判断flag的值
if (flag){
//不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在，不能加入\n",heroNode.no);
}else {
//插入到链表中，temp后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点信息,根据编号来修改，即no编号不能改
// 1:根据newHeroNode的no来修改即可
public void update(HeroNode newHeroNode){
if (head.next == null){
System.out.println("链表为空");
return;
}
//找到需要修改的这个节点,根据no编号
//定义一个辅助变量
HeroNode temp = head.next;
boolean flag = false; // 标识是否找到该节点
while (true){
if (temp == null){
break; //已经遍历完这个链表
}
if (temp.no == newHeroNode.no){
//找到了
flag = true;
break;
}
temp = temp.next;
}
//根据flag判断是否找到需要修改的节点
if (flag){
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else {
//没有找到
System.out.printf("没有找到编号%d的节点 \n",newHeroNode.no);
}
}
//删除节点
//1:head节点不能动 因此我们需要一个temp辅助接点找到待删除节点的前一个节点
//2:在比较时，是temp.next.no和需要删除的节点都no比较
public void del(int no){
HeroNode temp = head;
boolean flag = false; //标识是否周到待删除节点的前一个结点
while (true){
if (temp.next == null){
//已经到链表的最后
break;
}
if (temp.next.no == no){
//找到待删除结点的前一个节点temp
flag = true;
break;
}
temp = temp.next; //temp后移
}
//判断flag
if (flag){
//找到
//可以删除
temp.next = temp.next.next;
}else {
System.out.printf("要删除的%d这个节点不存在\n",no);
}
}
//显示链表【遍历】
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点不能动，因此我们需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
//判断是否都链表最后
if (temp == null) {
break;
}
//输出这个节点的信息
System.out.println(temp);
//将next后移
temp = temp.next;
}
}
}
//定义HeroNode，每一个HeroNode，对象就是一个节点
static class HeroNode {
public int no;
public String name;
public String nickname;
public HeroNode next; //指向下一个节点
//构造器
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
// 为了显示方便，我们重写一个tostring方法
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
}
运行结果：
就先快速度过这个单链表吧他不是重点，接下来说一下插入排序和冒泡排序：
冒泡排序：（如果冒泡排序没有看懂就看一下下面的插入排序，讲解的很清晰！）
让最大的元素到最后的位置，第二大的到到倒数第二个位置，依次重复，把所有的相邻元素都比较一次
首先我们需要将这三个方法写好：
package 冒泡排序;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-04 18:44
*/
public class Bubble {
/**
* 对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
}
/**
* 比较元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return false;
}
/**
* 数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
}
}
然后实现这三个方法，首先是先第一个比较v和w大小：
/**
* 比较元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
然后数组i和j交换位置：
/**
* 数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j]=temp;
}
然后写最一开始的对数组a进行排序
/**
* 对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
for (int i = a.length-1;i>0;i--) {
for (int j = 0; j <i; j++) {
// 比较索引j和索引j+1处的值
if (greater(a[j],a[j+1])){
exch(a,j,j+1);
}
}
}
}
编写测试类：
package 冒泡排序;
import java.util.Arrays;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-04 18:57
*/
public class BubbleTest {
public static void main(String[] args) {
Integer[] arr = {
4,5,6,2,8,7,9,3};
Bubble.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
涉及到的知识：Java compareTo() 方法
语法
public int compareTo( NumberSubClass referenceName )
参数
referenceName – 可以是一个 Byte, Double, Integer, Float, Long 或 Short 类型的参数。
返回值
-
如果指定的数与参数相等返回0。
-
如果指定的数小于参数返回 -1。
-
如果指定的数大于参数返回 1。
举例：
public class Test{
public static void main(String args[]){
Integer x = 5;
System.out.println(x.compareTo(3));
System.out.println(x.compareTo(5));
System.out.println(x.compareTo(8));
}
}
1
0
-1
只要是这些排序算法，其实都是有一个目的那就是排序和比较，所以说他们之间很类似，因为都要比较，都要通过比较交换两个数字的位置，因此他们代码中的相同点就是greater和exch方法：
/**
* 比较v元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
/**
* 数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j]=temp;
}
然后在这两个方法的基础上，通过调用实现各自的功能
这个插入排序的原理就是我们假设一开始的第一个元素4是已经排序了的，然后后面的元素3是未排序的，所以我们要将未排序的元素3插入进去，我们需要遍历已排序的数组，记得是倒序，这样就可以放到正确的位置。
所以说这个排序就很简单了：
首先把两个固定方法一写，然后根据自己的理解开始写核心代码：首先你需要写一个循环吧！也就是最外层的循环，一般都是数组中有n个数字就会循环n-1次，所以说最外层就这样写：
for (int i = 1; i < a.length-1; i++) {
... }//确定了等待排序的元素
然后写里面：里面就是具体到两两交换了，因为我们是插入排序嘛，原理就是把第一个姑且认为是已经排序好的，然后用第一个去和第一个的下一个比较嘛，如果第一个大于他后面那个，那就交换一下他两，然后第二层循环的条件-1，再来比较，这里可能我说的有点乱我就举个最最简单的例子吧：
比如一个数组a[]=3，2，1，我们要使用插入排序，那么我们就先第一步认为3是已经排序好了的（因为我们当做一个数组只有一个数字去排序，无论如何都直接一开始就排好了哈哈），然后我们现在是要想办法去插入2，那么就用a[0]和a[1]作比较也就是所谓的3和2，很明显3比2大，然后交换他两，调用exch方法,对吧，交换了以后，我们再次执行内层循环，但是记住，内存循环的for三个语句和外层有个不同，外层循环是正方向前进i++这种，执行到数组长度-1停止，内循环是逆方向倒退，因为我们是不断地把最小的数字往前面插入，也就是j–，
for (int i = 0; i < a.length-1; i++) {
//确定了等待排序的元素
for (int j = i;j >=0;j--) {
//比较索引j处的值和j-1处的值。如果索引j-1处的值比索引j处的值大则交换数据，如果不大则说明找到了合适的位置退出循环即可
if (greater(a[j],a[j+1])){
exch(a,j,j+1);
}else{
break;
}
}
}
好啦接住上面所说，执行第二次内循环，比较a[0]和a[1],但是由于交换了所以a[0]（2）确实小于a[1]（3），（括号里面是实际值），此时数组变成了2，3，1，那么就执行else情况break跳到外循环，i变成了1，然后紧接着进入内循环，比较a[1]（3）和a[2]（1），发现3>1，然后交换他两，此刻数组变成了2，1，3，然后j–再次执行内循环比较a[0]和a[1]，发现2>1于是交换2和1然后重复了刚刚的步骤，所以说全部代码就是：
方法类：
package 插入排序;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-04 20:01
*/
public class Insertion {
/**
* 对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
for (int i = 0; i < a.length-1; i++) {
//确定了等待排序的元素
for (int j = i;j >=0;j--) {
//比较索引j处的值和j-1处的值。如果索引j-1处的值比索引j处的值大则交换数据，如果不大则说明找到了合适的位置退出循环即可
if (greater(a[j],a[j+1])){
exch(a,j,j+1);
}else{
break;
}
}
}
}
/**
* 比较v元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
/**
* 数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j]=temp;
}
}
测试类：
package 插入排序;
import java.util.Arrays;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-04 20:14
*/
public class InsertionTest {
public static void main(String[] args) {
Integer[] a = {
4,3,2,10,12,1,5,6};
Insertion.sort(a);
System.out.println(Arrays.toString(a));
}
}
看是不是很简单？
分割线，这里我讲解一下怎样使用debug去排错把，自己在插入排序的时候写错了一个地方导致一直出错：
这是我一开始的时候，我们发现报错了，数组越界了，然后同时下面提示了第17行和第十三行有错误于是我们就debug:将这两行点上红点：
然后运行debug并点击这个蓝色小按钮，变点边去看右边控制台的变化：
在点击了和多下以后就会出现这个报错：
很明显我们在外循环的时候传入i=8的值然后内循环接收到使得j也等于8以后，j+1越界了，所以我们可以就发现了是自己外循环的判断少了一个a.length-1
OK完结，其实自己上面该总结的已经说的很全了哦。接下来说一下快速排序把：
原理：
这就是一个很明显的图图：
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
package 快速排序;
import java.util.Arrays;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-05 19:21
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {
-9, 78, 0, 23, -567, 70,66,47,12,16 };
quickSort(arr, 0, arr.length - 1);
System.out.println("arr=" + Arrays.toString(arr));
}
public static void quickSort(int[] arr, int left, int right) {
int l = left; //左下标
int r = right; //右下标
//中轴
int pivot = arr[(left + right) / 2];
int temp = 0; //临时变量，交换时使用
while (l < r) {
//while循环的目的，是让比pivot值小的放到他的左边，比pivot大的放到他的右边
//在pivot的左边一直找，直到找到大于或者等于pivot的值才退出
while (arr[l] < pivot) {
l += 1;
}
//在pivot的右边一直找，直到找到大于或者等于pivot的值才退出
while (arr[r] > pivot) {
r -= 1;
}
//如果l>=r成立，说明pivot左右两边的值，已经按照左边是全部小于等于pivot的值，右边全部是大于等于pivot的值
if (l >= r) {
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后，发现arr[l]等于pivot的值，那么r--,前移
if (arr[l] == pivot) {
r -= 1;
}
//如果交换完后，发现arr[r]等于pivot的值，那么l++,后移
if (arr[r] == pivot) {
l += 1;
}
}
//如果说l==r必须让l++，r--，否则会栈溢出
if (l == r) {
l += 1;
r -= 1;
}
//向左递归
if (left<r){
quickSort(arr,left,r);
}
//向右递归
if (right>l){
quickSort(arr,l,right);
}
}
}
文章有很详细的注释哈
分割线------------------------------------------------------------
接下来我们来到了最后一道大题：也就是实际中的排序应用：
先说一下自己在做这个题的时候遇到的一个小困难，就是题目要求倘若你什么都没有输入的话，只按了回车，那么就会执行输出员工排名，这样我们第一想法肯定是Scanner里面的nextline对吧，首先第一个让输入姓名你可以使用，第三个让你输入星期你可以使用，但是中间让你输入的是订单数，订单数是scanner.nextint，这个你要是不去输入一个int类型的值，你怎么都不会跳到下一步，我再解决这个问题的时候去查找资料了解一下buffereader这个类：java中可以使用buffereader类来获得控制台输入的回车键，示例如下：
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Test {
public static void main(String args[]) throws Exception {
System.out.println("输入：");
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String str = "";
do {
str = bf.readLine();
if (str.length() == 0) {
// 如果输入的字符串为空，则说明只输入了一个回车
System.out.println("输入的是回车！");
} else {
System.out.println("输入内容是：" + str);
}
} while (str.length() != 0);
}
}
这样可以在输入回车后提示“输入的是回车！”并结束程序
知识小节：
1.必要的知识：in.nextLine();不能放在in.nextInt();代码段后面
2.否则in.nextLine();会读入"\n"字符，但"\n"并不会成为返回的字符
3.next();这个函数会扫描从有效字符起到空格，Tab，回车等结束字符之间的内容并作为String返回。
4.nextLine();这个函数在你输入完一些东西之后按下回车则视为输入结束，输入的内容将被作为String返回。
5.next();这个函数与之不同在于,next();什么都不输入直接敲回车不会返回，而nextLine()即使不输入东西直接敲回车也会返回。
这个操作帮我解决了这个问题：
然后我们紧接着去实现最终代码：
首先说一下自己遇到过的坑：就是==与equals的区别：
“java”中使用“if”语句判断字符串是否相等的方法是：可以使用“”或者“equals”方法，两者都可以比较字符串是否相等，但是不同的是，“”比较的是两个字符串的地址是否相等，“equals”方法比较的是字符串对象的内容是否相同。
还有一个坑：
next() 与 nextLine() 区别
next():
1、一定要读取到有效字符后才可以结束输入。以空格、回车、Tab键都会视为结束符。。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
注意：建议能不使用就尽量不要使用nextLine()。尽量使用next。因为有时会出现吃回车现象。
这道题真的是动了很大的脑子，首先这个任务，我们一开始先去直接上手这个打印薪资的题，当时做了一通马马虎虎其实自己也乱代码也乱，然后通过一系列算法的学习，最后一个子任务又遇到了这个题，索性从第一行开始重新做一遍！因为我第一次做这个任务的时候，基本上就是if流派，一大堆if语句整整写了240行代码，然后很多东西都写到了一起，根本无法实现最后的排序任务，这是第一篇博客的链接：https://blog.csdn.net/justleavel/article/details/121043512?spm=1001.2014.3001.5501
但是通过上面的算法学习，我懂得了什么是方法调用，我们要学会去调用方法从而将代码简化，自己在输入回车的这个地方困扰了很久，理解了java缓存区，倘若你刚刚输入了一个回车那么这个回车就会在缓存区中，你接下来如果想在输入一个回车就是不行的，刚刚看了一篇文章讲的挺好：
在编写java程序的时候，我们想通过输入回车来完成这一行的输入，这是一个非常常见的问题，但是如果我们是用Scanner ，然后通过nextInt（）方法调用的时候，不会停止输入，回打出一个空行，然后等着你继续输入下一个数字。下边提供解决办法：
我们可以设置两个Scanner 第一个以行为单位读取数据，这样就相当于是用回车（enter）当作结束符，
然后把读取到的字符串传入第二个Scanner， 然后在进行处理
ArrayList<Integer> arr = new ArrayList() ;
System.out.println("Enter a space separated list of numbers:");
Scanner in = new Scanner(System.in);
String line = in.nextLine();
Scanner in2 = new Scanner(line);
while(in2.hasNextInt()){
arr.add(in2.nextInt());
}
System.out.println("The numbers were:"+arr.toString());
只需要把nextInt 或者hasnextint等函数改成你所需要的函数名就可以实现 不同的输入，但是是以回车（enter）为结尾了。
花费了一个多小时重写了一次这个题：
通过对比我们可以发现，第二个截图是直接输入空格就可以直接打印一周的总输入！
代码实现：
package 新版薪资计算系统;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
/**
* @author ${范涛之}
* @Description
* @create 2021-11-08 18:40
*/
public class Function {
//获取名字与订单数目返回一周的收入值
public static double names () throws IOException {
double basic = 0.0;
double pay = 0.0;
double pay2 = 0.0;
double pay3 = 0.0; //指代单纯计算订单数所得的薪资
double num2 = 1.5;
double num3 = 2.2;
double num4 = 3.2;
System.out.println("请输入外卖小哥的姓名：");
String[] wnames = {
"李雷", "张伟", "钱枫", "吴谦", "赵男", "孙冬", "夏岚", "胡宇"};
Scanner scanner = new Scanner(System.in);
String human = scanner.nextLine();
if (human.equals(wnames[0])) {
basic = 3000;
}
if (human.equals(wnames[1])) {
basic = 3000;
}
if (human.equals(wnames[2])) {
basic = 2500;
}
if (human.equals(wnames[3])) {
basic = 4000;
}
if (human.equals(wnames[4])) {
basic = 2500;
}
if (human.equals(wnames[5])) {
basic = 3000;
}
if (human.equals(wnames[6])) {
basic = 3500;
}
if (human.equals(wnames[7])) {
basic = 3500;
}
System.out.println("请输入已经完成的订单数");
int number = scanner.nextInt();
if (number >= 0 && number <= 100) {
pay = basic;
pay3 = 0;
}
if (number >= 101 && number <= 300) {
pay = basic + number * num2;
pay3 = number * num2;
}
if (number >= 301 && number <= 500) {
pay = basic + number * num3;
pay3 = number * num3;
}
if (number > 500) {
pay = basic + number * num4;
pay3 = number * num4;
}
Scanner scanner1 = new Scanner(System.in);
System.out.println("请输入当前星期");
// BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String data = scanner1.nextLine();
switch (data) {
case "周一":
// 周一的早班
if (human.equals(wnames[0]) || human.equals(wnames[2]) || human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周一的收入是:" + (pay3 + 500));
}
// 周一的中班
if (human.equals(wnames[1]) || human.equals(wnames[4]) || human.equals(wnames[6]) || human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周一的收入是:" + (pay3 + 400));
}
// 周一的晚班
if (human.equals(wnames[3])) {
System.out.println("[" + human + "]" + "周一的收入是:" + (pay3 + 300));
}
// 周一的大夜 :无
break;
case "周二":
// 周二的早班
if (human.equals(wnames[2]) || human.equals(wnames[4]) || human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周二的收入是:" + (pay3 + 500));
}
// 周二的中班
if (human.equals(wnames[0]) || human.equals(wnames[6])) {
System.out.println("[" + human + "]" + "周二的收入是:" + (pay3 + 400));
}
// 周二的晚班:无
// 周二的大夜:无
break;
case "周三":
// 周三的早班
if (human.equals(wnames[0]) || human.equals(wnames[3]) || human.equals(wnames[5])) {
System.out.println("[" + human + "]" + "周三的收入是:" + (pay3 + 500));
}
// 周三的中班
if (human.equals(wnames[4]) || human.equals(wnames[6])) {
System.out.println("[" + human + "]" + "周三的收入是:" + (pay3 + 400));
}
// 周三的晚班:无
// 周三的大夜
if (human.equals(wnames[1]) || human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周三的收入是:" + (pay3 + 400));
}
break;
case "周四":
// 周四的早班
if (human.equals(wnames[4]) || human.equals(wnames[5])) {
System.out.println("[" + human + "]" + "周四的收入是:" + (pay3 + 500));
}
// 周四的中班
if (human.equals(wnames[0]) || human.equals(wnames[6])) {
System.out.println("[" + human + "]" + "周四的收入是:" + (pay3 + 400));
}
// 周四的晚班:
if (human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周四的收入是:" + (pay3 + 300));
}
// 周四的大夜
if (human.equals(wnames[2]) || human.equals(wnames[3])) {
System.out.println("[" + human + "]" + "周四的收入是:" + (pay3 + 400));
}
break;
case "周五":
// 周五的早班
if (human.equals(wnames[0]) || human.equals(wnames[2]) || human.equals(wnames[3])) {
System.out.println("[" + human + "]" + "周五的收入是:" + (pay3 + 500));
}
// 周五的中班
if (human.equals(wnames[1]) || human.equals(wnames[4]) || human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周五的收入是:" + (pay3 + 400));
}
// 周五的晚班:
if (human.equals(wnames[6])) {
System.out.println("[" + human + "]" + "周五的收入是:" + (pay3 + 300));
}
// 周五的大夜:无
break;
case "周六":
// 周六的早班 ：无
// 周六的中班
if (human.equals(wnames[1])) {
System.out.println("[" + human + "]" + "周六的收入是:" + (pay3 + 400));
}
// 周六的晚班
if (human.equals(wnames[7])) {
System.out.println("[" + human + "]" + "周六的收入是:" + (pay3 + 300));
}
// 周六的大夜
if (human.equals(wnames[3]) || human.equals(wnames[5])) {
System.out.println("[" + human + "]" + "周六的收入是:" + (pay3 + 300));
}
break;
default:
break;
}
System.out.println("【" + human + "】" + "一周的收入总共是" + pay + "元");
return pay;
}
public static void main(String[] args) throws IOException {
names();
// Double[] arr = {10578.2,9694.4,9940.0,10329.6,9271.2,10420.3,9978.5,10241.3};
// Bub.sort(arr);
}
}