第14章，lambda表达式与流处理例题

最新推荐文章于 2024-07-13 21:16:00 发布

胆小鬼不爱吃香菜

最新推荐文章于 2024-07-13 21:16:00 发布

阅读量721

点赞数

文章标签： windows

本文链接：https://blog.csdn.net/2301_76551149/article/details/134317560

版权

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));
		
	}

}