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("输入年龄正确");

        }

    }

}

巴特西

Javaheima13