package 例题;
import java.util.List;
import java.util.stream.Collectors;
import java.util. stream.Stream;
public class 例题19 {
public static void main(String[] args){
List<例题14> list = 例题14.get例题14List();//获取公共类的测试数据
Stream<例题14> stream = list.stream();//获取集合流对象
stream = stream.filter(people ->"女".equals(people.getSex()));//将所有女员工过滤出来
stream = stream.limit(2);//取出前两位
List<例题14> result = stream.collect(Collectors.toList());//将流对象重新封装成一个List集合
for (例题14 emp : result) {//遍历结果集
System.out.println(emp);//输出员工对象信息
}
}
}
package 例题;
interface SayHi{ //创建打招呼接口
String say(); //打招呼方法
}
public class 例题1 {
public static void main(String[] args) {
//lambda表达式实现打招呼接口，返回抽象方法结果
SayHi hi = ()->"你好啊！这是lambda表达式";
System.out.println(hi.say());
}
}
package 例题;
interface cf{//构造方法接口
例题10 action();//调用无参构造方法
}
public class 例题10 {//测试类
public 例题10() {//无参构造方法
System.out.println("调用无参构造方法");
}
public 例题10(int i) {//有参构造方法
System.out.println("调用有参构造方法");
}
public static void main(String[] args) {
cf a = 例题10::new;//引用测试类的构造方法
例题10 b = a.action();//通过无参方法创建对象
}
}
package 例题;
interface cf2{//构造方法接口
例题11 action(int i);//调用无参构造方法
}
public class 例题11 {//测试类
public 例题11() {//无参构造方法
System.out.println("调用无参构造方法");
}
public 例题11(int i) {//有参构造方法
System.out.println("调用有参构造方法，参数为：" + i);
}
public static void main(String[] args) {
cf2 a = 例题11::new;//引用测试类的构造方法
例题11 b = a.action(123);//通过无参方法创建对象
}
}
package 例题;
interface ac<T>{//构造方法接口
T action(int n);//抽象方法返回对象数组，方法参数决定数组个数
}
public class 例题12 {
public static void main(String[] args) {
ac<例题12[]> a = 例题12[]::new;//引用数组的构造方法
例题12 arr[] = a.action(3);//接口创建数组，并指定数组个数
arr[0] = new 例题12();//给数组元素实例化
arr[1] = new 例题12();
arr[2] = new 例题12();
arr[3] = new 例题12();//如果调用或者给arr[3]赋值，代码则会抛出数组下标越界异常
}
}
package 例题;
import java.util.function.Function;
public class 例题13 {
//创建Function接口对象，参数类型是Integer[]，返回值是String
Function<Integer[], String> f = (n)->{
StringBuilder str = new StringBuilder();//创建字符序列
for(Integer num : n) {//遍历参数数组
str.append(num);//字符序列添加数组元素
str.append('.');//字符序列添加字符'.'
}
str.deleteCharAt(str.length()-1);//删除末尾的'.'
return str.toString();//返回字符串
};
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] ip = {192, 168, 1, 1};//带处理的数组
例题13 d = new 例题13();
System.out.println(d.f.apply(ip));//输出处理结果
}
}
package 例题;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题28{
public static void main(String[] args) {
// TODO Auto-generated method stub
List<例题14> list = 例题14.get例题14List();
Stream<例题14>stream=list.stream();
Map<String,List <例题14>> map = stream.collect(Collectors.groupingBy(例题14::getDept));
Set<String>depts=map.keySet();
for(String dept:depts) {
System.out.println(dept+"员工信息如下:");
List<例题14>temp=map.get(dept);
for(例题14 e:temp) {
System.out.println(e);
}
System.out.println();
}
}
}
package 例题;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题29 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 一级分组规则方法，按照员工部门进行分级
Function<例题14, String> deptFunc = 例题14::getDept;
// 二级分组规则方法，按照员工部门进行分级
Function<例题14, String> sexFunc = 例题14::getSex;
// 将流中的数据进行二级分组，先对员工部分进行分组，在对员工性别进行分组
Map<String, Map<String, List<例题14>>> map = stream
.collect(Collectors.groupingBy(deptFunc, Collectors.groupingBy(sexFunc)));
// 获取Map的中的一级分组键集合，也就是部门名称集合
Set<String> deptSet = map.keySet();
for (String deptName : deptSet) { // 遍历部门名称集合
// 输出部门名称
System.out.println("【" + deptName + "】 部门的员工列表如下：");
// 获取部门对应的二级分组的Map对象
Map<String, List<例题14>> sexMap = map.get(deptName);
// 获得二级分组的键集合，也就是性别集合
Set<String> sexSet = sexMap.keySet();
for (String sexName : sexSet) { // 遍历部门性别集合
// 获取性别对应的员工集合
List<例题14> emplist = sexMap.get(sexName);
System.out.println(" 【" + sexName + "】 员工："); // 输出性别种类
for (例题14 emp : emplist) {// 遍历员工集合
System.out.println(" " + emp); // 输出对应员工信息
}
}
}
}
}
package 例题;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
public class 例题26 {
public static void main(String[] args) {
// 获取公共类的测试数据
List<例题14> list = 例题14.get例题14List();
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 过滤出21岁的员工
stream = stream.filter(people -> people.getAge() == 21);
Optional<例题14> young = stream.findFirst(); // 获取第一个元素
例题14 emp = young.get(); // 获取员工对象
System.out.println(emp); // 输出结果
}
}
package 例题;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题16 {
//输出集合元素
static void ph(String mes, List list) {
System.out.println(mes);//输出文字信息
list.stream().forEach(n->{//使用forEach方法遍历集合并打印元素
System.out.println(n + "");
});
System.out.println();
}
public static void main(String[] args) {
// 创建空数组
List<Integer> list = new ArrayList<>();
for(int i = 1; i <= 10; i++) {//从1循环到10
list.add(i);//从集合赋值
}
ph("集合原有元素：" ,list);//输出集合元素
Stream<Integer> stream = list.stream();//获取集合流对象
//将集合中的所有奇数过滤出来，把过滤结果重新赋值给流对象
stream = stream.filter(n -> n % 2 == 1);
//将流对象重新封装成一个List集合
List<Integer> re = stream.collect(Collectors.toList());
ph("过滤之后的集合元素：" , re);//输出集合元素
}
}
package 例题;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题17 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List();//获取公共类的测试数据
Stream<例题14> stream = list.stream();//获取集合流对象
stream = stream.filter(people->people.getAge()>30);//将年龄大于30岁的员工过滤出来
List<例题14> rt = stream.collect(Collectors.toList());//将流对象重新封装成一个List集合
for(例题14 emp : rt) {//遍历结果集
System.out.println(emp);//输出员工对象信息
}
}
}
package 例题;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题18 {
static void ph(String me, List list) {
System.out.println(me);
list.stream().forEach(n->{
System.out.print(n+"");
});
System.out.println();
}
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
ph("去重前：",list);
Stream<Integer> stream = list.stream();
stream = stream.distinct();
List<Integer> rt = stream.collect(Collectors.toList());
ph("去重后：" ,rt);
}
}
package 例题;
interface Addition{//加法接口
int add(int a,int b);//加法抽象方法
}
public class 例题2 {
public static void main(String[] args) {
//lambda表达式实现加法接口，返回参数相加结果
Addition ad = (x,y)->x+y;
int result = ad.add(15, 16);
System.out.println("相加结果; " + result);
}
}
package 例题;
import java.util.List;
import java.util.stream.Collectors;
import java.util. stream.Stream;
public class 例题20 {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<例题14> list = 例题14.get例题14List();//获取公共类的测试数据
Stream<例题14> stream = list.stream();//获取集合流对象
stream = stream.filter(people ->"男".equals(people.getSex()));//将所有男员工过滤出来
stream = stream.skip(2);//跳过前两位
List<例题14> result = stream.collect(Collectors.toList());//将流对象重新封装成一个List集合
for (例题14 emp : result) {//遍历结果集
System.out.println(emp);//输出员工对象信息
}
}
}
package 例题;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class 例题21 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 将所有开发部的员工过滤出来
stream = stream.filter(people -> "开发部".equals(people.getDept()));
// 将所有员工的名字映射成一个新的流对象
Stream<String> names = stream.map(例题14::getName);
// 将流对象重新封装成一个List集合
List<String> result = names.collect(Collectors.toList());
for (String emp : result) { // 遍历结果集
System.out.println(emp); // 输出所有姓名
}
}
}
package 例题;
import java.util.List;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;
public class 例题22 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 将所有开发部的员工过滤出来
stream = stream.filter(people -> "销售部".equals(people.getDept()));
// 将所有员工的名字映射成一个新的流对象
DoubleStream salarys = stream.mapToDouble(例题14::getSalary);
// 统计流中元素的数学总和
double sum = salarys.sum();
System.out.println("销售部一个月的薪资总额："+sum);
}
}
package 例题;
import java.util.List;
import java.util.stream.Stream;
public class 例题23 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 判断所有员工的年龄是否都大于25
boolean result = stream.allMatch(people -> people.getAge() > 25);
System.out.println("所有员工是否都大于25岁：" + result); // 输出结果
}
}
package 例题;
import java.util.List;
import java.util.stream.Stream;
public class 例题24 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 判断员工是否有的年龄大于等于40
boolean result = stream.anyMatch(people -> people.getAge() >= 40);
System.out.println("员工中有年龄在40或以上的吗？：" + result); // 输出结果
}
}
package 例题;
import java.util.List;
import java.util.stream.Stream;
public class 例题25 {
public static void main(String[] args) {
List<例题14> list = 例题14.get例题14List(); // 获取公共类的测试数据
Stream<例题14> stream = list.stream(); // 获取集合流对象
// 判断公司中是否不存在薪资小于2000的员工？
boolean result = stream.noneMatch(people -> people.getSalary() <2000 );
System.out.println("公司中是否不存在薪资小于2000元的员工？：" + result);// 输出结果
}
}
package 例题;
interface CG3{
String ck(int a);
}
public class 例题3 {
public static void main(String[] args) {
// lambda表达式
//a为参数
CG3 c = (a) -> {
//判断语句
if(a >= 90 && a <= 100) {
return "成绩为优";
}
if(a >= 80 && a <= 90) {
return "成绩为良";
}
if(a >= 60 && a <= 80) {
return "成绩为中";
}
if(a >= 0 && a <= 60) {
return "成绩为差";
}
return "成绩无效";
};
//调用ck方法传入参数进行判断，输出结果
System.out.println(c.ck(50));
}
}
package 例题;
interface CG4{//测试接口
void ck();//测试方法
}
public class 例题4 {
public static void main(String[] args) {
// 创建局部变量
int v = 100;
//实现测试接口
CG4 c = () -> {
//使用局部变量赋值
int num = v - 90;
//更改局部变量，此处报错，无法编译
v = 12;
};
}
}
package 例题;
//接口
interface CG5{
String ck();
}
public class 例题5 {
//成员变量
int v = 100;
//成员方法
public void acto() {
//lambda补全方法体
CG5 c = () ->{
//局部变量
v = 10;
return null;
};
System.out.println("运行方法前v=" + v);
c.ck();
System.out.println("运行方法后v=" + v);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
例题5 l = new 例题5();
l.acto();
}
}
package 例题;
import java.util.Scanner;
interface An{ //防沉迷接口
boolean ck(int age)throws UnderAgeException;//抽象检查方法，抛出用户未成年异常
}
class UnderAgeException extends Exception{ //自定义异常
public UnderAgeException(String message) {//有参构造方法
super(message);//调用原有父类构造方法
}
}
public class 例题6 {
public static void main(String[] args) {
//lambda 表达式创建An对象，默认抛出原有异常
An a = (b)->{
if(b<18) {//如果年龄小于18
throw new UnderAgeException("未满18周岁，开启防沉迷模式！");//抛出异常
}
else {
return true;//返回通过
}
};
//控制台扫描器
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄：");//提示
int age = sc.nextInt();//获取用户输入的年龄
try { //前面抛出过异常，此处捕捉
if(a.ck(age)) {//验证年龄
System.out.println("欢迎━(*｀∀´*)ノ亻!进入XX世界");
}
}
catch(UnderAgeException e) {
System.out.println(e);//打印异常
}
sc.close();//关闭扫描器
}
}
package 例题;
//接口
interface Add{
int add(int a, int b);
}
public class 例题7 {
//静态方法
static int add1(int x, int w){
return x + w;
}
public static void main(String[] args) {
//引用静态方法
Add a1 = 例题7 :: add1;
System.out.println("静态方法的引用：" + a1.add(8, 5));
}
}
package 例题;
import java.text.SimpleDateFormat;
import java.util.Date;
//创建接口
interface Dat{
String method(Date date);
}
public class 例题8 {
//创建方法
public String format(Date date) {
//创建日期格式化对象并设置格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//返回格式化结果
return sdf.format(date);
}
public static void main(String[] args) {
// 创建对象
例题8 l1 = new 例题8();
//利用对象引用方法
Dat d1 = l1 :: format;
//创建时间对象
Date date = new Date();
System.out.println("默认格式：" + date);
System.out.println("接口输出的格式：" + d1.method(date));
}
}
package 例题;
import java.util.HashSet;
interface Pa<T>{//测试接口
int md(T[] t);//抽象方法
}
class PaDemo{//测试类
//静态方法，使用泛型参数，在方法名之前定义泛型。此方法用于查找数组中的重复元素个数
static public <T> int rt(T[] t) {
int ah = t.length;//记录数组长度
java.util.HashSet<T> set = new HashSet<>();//创建哈希集合
for(T tmp : t) {//遍历数组
set.add(tmp);
}
return ah - set.size();//返回数组长度与集合长度的差
}
}
public class 例题9 {
public static void main(String[] args) {
Integer a[] = {1, 1, 2, 3, 1, 5, 6, 1, 8, 8};
String s[] = {"王", "李", "赵", "陈", "李", "孙", "张"};
//创建接口对象，integer作为泛型，引人PaDemo类的静态方法，方法名要定义泛型
Pa<Integer> p1 = PaDemo::<Integer>rt;
System.out.println("整数数组重复元素个数：" + p1.md(a));//调用接口方法
创建接口对象，String作为泛型，引人PaDemo类的静态方法
//方法名不定义泛型，则默认使用接口已定义好的泛型
Pa<String> p2 = PaDemo::rt;
System.out.println("字符串数组重复元素个数：" + p2.md(s));
}
}
