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 例题;
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.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));
}
}
