Javaheima13

Java

Stream流

salary 薪水

bonus 奖金

top performer 优秀员工

punish 处罚

1员工信息至少包含了(名称、性别、工资、奖金、处罚记录)

2开发一部有4个员工、开发二部有5名员工

3分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer

4分别统计出2个部门的平均月收入，要求去掉最高和最低工资。

5统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值。

package com.yu.Day0604Demo;

public class Employee {
    private String name;
    private char sex;
    private double salary;
    private double bonus;
    private String punish;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    @Override
    public String toString() {
        return "topperformer{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}';
    }

    public Employee() {
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }
}

package com.yu.Day0604Demo;

public class Topperformer {
    private String name;
    private double money;//总月薪

    @Override
    public String toString() {
        return "Topperformer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public Topperformer() {
    }

    public Topperformer(String name, double money) {
        this.name = name;
        this.money = money;
    }
}

package com.yu.Day0604Demo;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;

public class topperformerTest {
    public static double allmoney;
    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("猪八戒",'男',30000,25000,null));
        one.add(new Employee("孙悟空",'男',2500,1000,"顶撞上司"));
        one.add(new Employee("沙僧",'男',20000,20000,null));
        one.add(new Employee("小白龙",'男',20000,25000,null));
        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松",'男',15000,9000,null));
        two.add(new Employee("李逵",'男',20000,10000,null));
        two.add(new Employee("西门庆",'男',50000,100000,"被打"));
        two.add(new Employee("潘金莲",'女',3500,1000,"被打"));
        two.add(new Employee("武大郎",'男',20000,0,"下毒"));
        //获取最高员工的工资
//        Employee onefirst = one.stream().max((e1 ,e2)->Double.compare(e1.getBonus()+ e1.getSalary(),e2.getSalary()+ e2.getBonus() )).get();
//        System.out.println(onefirst);
        //将最高工资对象存放在优秀员工里面
        Topperformer Tone = one.stream().max((e1,e2)-> Double.compare(e1.getBonus()+ e1.getSalary(),e2.getBonus()+ e2.getSalary() ))
                .map(e -> new Topperformer(e.getName(), e.getBonus()+e.getSalary())).get();
        System.out.println("一组最高工资为:"+Tone);
        Topperformer Ttwo = two.stream().max((e1,e2)-> Double.compare(e1.getBonus()+ e1.getSalary(),e2.getBonus()+ e2.getSalary() ))
                .map(e -> new Topperformer(e.getName(), e.getBonus()+e.getSalary())).get();
        System.out.println("二组最高工资为:"+Ttwo);
        //获取两个部门的平均工资
        one.stream().sorted(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return Double.compare(o1.getBonus()+ o1.getSalary(), o2.getBonus()+ o2.getSalary());
            }
        }).skip(1).limit(one.size()-2).forEach(employee -> {
            allmoney += (employee.getBonus()+employee.getSalary());
        });
        System.out.println("一组平均工资为:"+allmoney/(one.size()-2));
        //修改静态变量的值
        allmoney = 0;
        System.out.println(allmoney);
        two.stream().sorted(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return Double.compare(o1.getBonus()+ o1.getSalary(), o2.getBonus()+ o2.getSalary());
            }
        }).skip(1).limit(two.size()-2).forEach(employee -> {
            allmoney += (employee.getBonus()+employee.getSalary());
        });
        System.out.println("二组平均工资为:"+allmoney/(two.size()-2));
        //修改静态变量的值//注意清零
        allmoney = 0;
        System.out.println(allmoney);
        Stream.concat(one.stream(),two.stream()).sorted((o1, o2) -> Double.compare(o1.getBonus()+ o1.getSalary(), o2.getBonus()+ o2.getSalary() ))
                .skip(1).limit(one.size()+ two.size()-2).forEach(employee ->
                allmoney += employee.getBonus()+employee.getSalary());
        System.out.println(allmoney/(one.size()+ two.size()-2));
        BigDecimal a = BigDecimal.valueOf(allmoney);
        BigDecimal b = BigDecimal.valueOf(one.size()+two.size()-2);
        System.out.println(a.divide(b,2, RoundingMode.HALF_UP));

    }
}

收集Stream流

收集操作

• 收集Stream流含义:就是把Stream流操作后的结果数据转回到集合或数组中去

• Stream流:方便操作集合/数组的手段

• 集合/数组:才是开放的目的

收集方法

名称	说明
R collect(collector collector)	开始收集Stream流,指定收集器

Collectors工具类提供了具体的收集方式

名称	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中去
Public static Collector toMap(Function keyMapperm,Function valueMapper)	把元素收集到Map集合中去

实例

package com.yu.Day0604Demo;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectStream {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("张无忌");
        names.add("周芷若");
        names.add("张三丰");
        names.add("赵敏");
        names.add("张强");
        names.add("张弓长");
        Stream<String> ss = names.stream().filter(s -> s.startsWith("张"));
        List<String> nameiszhang = ss.collect(Collectors.toList());
        System.out.println(nameiszhang);
        Stream<String> sname = names.stream().filter(s -> s.startsWith("张"));
        Object[] nameiszhang2 = sname.toArray();
        for (int i = 0; i < nameiszhang2.length; i++) {
            System.out.println(nameiszhang2[i]);
        }
    }
}

异常处理

异常概述、体系

什么是异常

• 异常是代码在编译或执行的过程中可能出现的错误

异常分类

• 编译时异常，运行时异常
  • 编译时异常：没有继承RuntimeException的异常，编译阶段就会出错
  • 运行时异常：继承字RuntimeException的异常或其子类，编译阶段不报错，运行可能报错

学习目的

• 避免异常的出现，同时处理可能出现的异常，让代码更健壮

常见运行时异常

运行时异常

• 直接继承自RuntimeException或其子类，编译阶段不会报错，运行时可能出现的错误

运行时异常示例

• 数组索引越界异常：ArrayIndexOutOfBoundsException
• 空指针异常： NullPointerException，直接输出没有问题，但是调用空指针的变量的功能就会报错
• 数学操作异常：ArithmeticException
• 类型转换异常：ClassCastException
• 数字转换异常：NumBerFormatException

*** 运行时异常：一班是程序员业务没有考虑号或者编程逻辑不严谨引起的程序错误***

zero 零

常见编译时异常

编译时异常特点

• 不是RuntimeException或者其子类的异常，
• 编译阶段就报错，必须处理，否则代码不通过

编译时异常的作用

• 是担心程序员的技术不行，在编译阶段就爆出一个错误，目的在于提醒不要出错
• 编译时异常可遇不可求，遇到了就遇到呗

异常的默认处理流程

一般不用

*** 默认的异常处理机制并不号，一旦真的出现异常，程序立即四位***

编译时异常的处理机制

三种处理形式

• 出现的异常直接抛出去给调用者，调用者也继续抛出去
• 出现异常自己捕获处理，不麻烦别人
• 前两者结合，出现异常直接抛出去给调用者，调用者捕获处理

异常处理方式一 ——throws

• throws：用在方法上，可以将方法内部出现的异常抛出去给本方法的调用者处理
• 这种方法并不好，发生异常的方法自己不处理异常，如果异常最终抛出去给虚拟机将引起程序死亡

抛出异常格式

• 方法 throws 异常1，异常2，异常3...{
  
  }
  

规范做法

• 方法 throws Exception{
   }
  

异常处理方式二——try...catch...

• 监听捕获异常，用在方法内部，可以将方法内部出现的异常直接捕获处理
• 这种方式还可以，发生异常的方法自己独立完成异常的处理，程序可以继续往下执行。

格式(不推荐浪费内存空间)

try{
//监听可能出现异常的代码
}catch(异常类型1 变量){
    //处理异常
}catch(异常类型2变量){
	//处理异常
}...

建议格式

try{
    //可能出现异常的代码！
}catch(Exception e){
    e.printStackTrace();
}
Exception可以捕获处理一切异常类型

异常处理方式三——前两者结合

• 方法直接将异常通过throws抛出去给调用者
• 调用者收到异常直接捕获处理

异常处理总结

• 在开发种按照规范来说第三种方式最好的；底层的异常抛出去给最外层，最外层集中捕获处理。
• 实际应用中，只要代码能够编译通过，并且功能完成，那么每一种异常处理方式似乎也都是可以的

运行时异常的处理机制

运行时异常的处理形式

• 运行时异常编译阶段不会出错，是运行时才可能出错的，所以编译阶段不处理也可以。
• 按照规范建议还是处理：建议在最外层调用处集中捕获处理即可

异常处理使代码更稳健的案例

package com.yu.Day0604Demo;

import java.util.Scanner;

public class userprinthowmush {
    public static void main(String[] args) {
        while (true) {
            try {
                Scanner s = new Scanner(System.in);
                System.out.println("请输入当前商品价格：");
                String mush = s.nextLine();//输入的价格不一定为纯数字组合
                double shu = Double.valueOf(mush);//可能会出现的错误 NumberFormatException
                if(shu > 0){
                    System.out.println("当前商品的价格为"+shu);
                }else{
                    System.out.println("输入价格有误，请重新输入");
                }
            } catch (Exception e) {
                System.out.println("输入价格包含英文，请重新输入！！！");
            }
        }
    }
}

自定义异常

自定义异常的分类

1、自定义编译时异常

• 定义一个异常继承Exception
• 重写构造器
• 在出现异常的地方用throw new 自定义对象抛出

作用：在编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理

判断年龄是否正确

package com.yu.Day0604Demo;

public class YUAgeException extends Exception{
    public YUAgeException() {
        super();
    }

    public YUAgeException(String message) {
        super(message);
    }
}

package com.yu.Day0604Demo;

public class userAgeTexr {
    public static void main(String[] args) {
        try {
            AgeTrue(-55);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void AgeTrue(int age) throws YUAgeException {
        if (age < 0 || age > 200 ){
            throw new YUAgeException();

        }else {
            System.out.println("输入年龄正确");
        }
    }
}

2、自定义运行时异常

• 定义一个异常类型继承RuntimeException
• 重写构造器
• 在出现异常的地方用Throw new 自定义对象抛出

*** 作用：提醒不强烈，编译阶段不报错！运行时才可能出现***

package com.yu.Day0604Demo;

public class YUAgeException extends RuntimeException{
    public YUAgeException() {
        super();
    }

    public YUAgeException(String message) {
        super(message);
    }
}

package com.yu.Day0604Demo;

public class userAgeTexr {
    public static void main(String[] args) {

            AgeTrue(55);
    }
    public static void AgeTrue(int age) throws YUAgeException {
        if (age < 0 || age > 200 ){
            throw new YUAgeException();

        }else {
            System.out.println("输入年龄正确");
        }
    }
}

---

throw:方法内部直接创建一个异常对象，并从此点抛出

throws：用在方法申明上的，爬出方法内部的异常