Java面向对象程序开发——JDK8新特性

news2025/11/1 4:08:42

文章目录

  • 网络编程入门知识
  • JDK8新特性
    • Lambda表达式
      • 以多线程为例：
      • Lambda结合for循环：
  • Stream流
    • 获取一个流的2种常用的方式：
    • 常用方法
      • 终结方法
      • 延迟方法
    • 案例

网络编程入门知识

软件结构、协议分类、网络通信协议、网络编程三要素、TCP通信协议、文件上传、BIO 、 NIO 与 AIO

JDK8新特性

Lambda表达式

面向对象的思想: 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.

函数式编程思想：只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程，比如你去北京，你可以走着也可以坐车，怎么去不重要，重要的是你能到。

使用前提：
必须有接口，且接口中有且仅有一个抽象方法
必须有上下文环境,否则不知道你表达式干啥用的

主要目的是省去了 新建一个实现类来实现接口，把实现接口的重写方法，放在主方法里面来重写了，用Lambda表达式的写法比匿名内部类的写法，简化了很多。

Lambda由3个部分组成：

(参数类型1 参数名1,参数类型2 参数名2) ‐> { 代码} 
(parameters) ->{ statements; }

以多线程为例：

// 1匿名内部类
Runnable task = new Runnable() {
@Override
public void run() { // 覆盖重写抽象方法
System.out.println("多线程任务执行！");
}
};
new Thread(task).start(); // 启动线程

//2.Lambda
new Thread( () -> System.out.println("多线程任务执行！") ).start()

Lambda结合for循环：

IntStream.range(0,4).forEach(i->System.out.println("循环变量i:"+i));

例如： 请使用Lambda的格式调用 invokeCook 方法，打印输出 "吃饭啦 ! " 字样：

public interface Cook {
		void makeFood();
	}
	
public class Demo {
	public static void main(String[] args) {
		// TODO 请在此使用Lambda【标准格式】调用invokeCook方法
	}
	private static void invokeCook(Cook cook) {
		cook.makeFood();
	}
}

ans

invokeCook(() -> System.out.println("吃饭啦！"));

例子2： 请在此使用Lambda调用invokeCalc方法来计算120+130的结果

public interface Calculator {
	int calc(int a, int b);
}

public class Demo {
	public static void main(String[] args) {
// 使用Lambda调用invokeCalc方法来计算120+130的结果
	}
	private static void invokeCalc(int a, int b, Calculator calculator) {
		int result = calculator.calc(a, b);
		System.out.println("结果是：" + result);
	}
}

invokeCalc(120,130,(int a, int b) -> {return a+b;});

省略写法：
1.小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

invokeCalc(120,130,(a, b)->a+b);  //省略写法：1、3

Stream流

for循环，循环语法关注的是怎么做的问题，循环体里关注的是做什么

代码如下（示例）：

//增强for:数组或者list、set
for(String i:list) {
    System.out.println(i);
}

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        List<String> listA = new ArrayList<>();
        //放入以张开头的元素
        for (String s : list) {
            if (s.startsWith("张")) {
                listA.add(s);
            }
        }
        System.out.println(listA);
        //放入长度为三的元素
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length() == 3) {
                listB.add(s);
            }
        }
        System.out.println(listB);
    }

Stream能给我们带来怎样更加优雅的写法呢？

list.stream()
                .filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3)
                .forEach(s -> System.out.println(s));

在这里插入图片描述

备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何 元素（或其地址值）

获取一个流的2种常用的方式：

获取一个流非常简单，有以下2种常用的方式：
所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

//1.所有的 Collection 集合
 list.stream()
        .filter(s -> s.startsWith("张"))
        .forEach(s -> System.out.println(s));
        Map<String, String> map = new HashMap<>();//map
       Stream<String> valueStream =  map.values().stream();
       Stream<String> keyStream = map.keySet().stream();
       Set<String> set = new HashSet<>();
       Stream<String> setStream = set.stream();
//2.数组的流
      String[] array = {"张三","李四","赵五"};
      Stream<String> arrayStream = Stream.of(array);

常用方法

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调 用。终结方法包括 count 和 forEach 方法 。

终结方法

统计个数：long count();

public static void main(String[] args) {
		String[] array = {"张无忌","周芷若","赵敏"};
	    Stream<String> arrayStream = Stream.of(array);
	    long count = arrayStream.count();
	    System.out.println(count);
    }

逐一处理：forEach，forEach ，将list的每一个元素s交给函数处理，做了一下输出。

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream().forEach(s -> System.out.println(s));
    }

延迟方法

过滤：filter，将一个流转换成子集流

public static void main(String[] args) {
		String[] array = {"张无忌","周芷若","赵敏","张丽热巴", "张战","Jay","王菲","张云雷","张云伟"};
	    Stream<String> arrayStream = Stream.of(array);//流
	    Stream<String> arrayStream1 =arrayStream.filter(s -> s.startsWith("张"));//将一个流转换成子集流
	    arrayStream1.forEach(s -> System.out.println(s));//逐一处理终结方法
	    //arrayStream.forEach(s -> System.out.println(s)); //arrayStream1
	    //stream has already been operated upon or closed
    }

映射：map

public static void main(String[] args) {
		String[] array = {"12","22","23","34", "66","88"};
	    Stream<String> arrayStream = Stream.of(array);//流
	    //map映射：将字符串类型的整数转换成Integer类型的整数
	    //Stream<Integer> arrayStream1 = arrayStream.map(name -> {return Integer.parseInt(name);});
	    Stream<Integer> arrayStream1 = arrayStream.map(name ->Integer.parseInt(name));
	    arrayStream1.forEach(s -> System.out.println(s));//逐一处理终结方法
    }

取用前几个：limit

public static void main(String[] args) {
		String[] array = {"12","22","23","34", "66","88"};
	    Stream<String> arrayStream = Stream.of(array);//流
	    Stream<String> arrayStream1 = arrayStream.limit(20);
	    //取用前几个
	    arrayStream1.forEach(s -> System.out.println(s));//逐一处理终结方法
    }

跳过前几个：skip

public static void main(String[] args) {
		String[] array = {"12","22","23","34", "66","88"};
	    Stream<String> arrayStream = Stream.of(array);//流
	    Stream<String> arrayStream1 = arrayStream.skip(2);//跳过前几个
	    //如果长度大于元素长度则返回一个长度为0的空流
	    arrayStream1.forEach(s -> System.out.println(s));//逐一处理终结方法
    }

组合：concat，将2个流合并成一个流

public static void main(String[] args) {
	    Stream<String> arrayStream1 = Stream.of("张无忌");//流1
	    Stream<String> arrayStream2 = Stream.of("张翠山");//流1
	    Stream<String> arrayStream3 = Stream.concat(arrayStream1, arrayStream2);
	    arrayStream3.forEach(s -> System.out.println(s));
    }

案例

1、第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。

2、第一个队伍筛选之后只要前3个人；存储到一个新集合中。

3、第二个队伍只要姓张的成员姓名；存储到一个新集合中。

4、第二个队伍筛选之后不要前2个人；存储到一个新集合中。

5、将两个队伍合并为一个队伍；存储到一个新集合中。

6、根据姓名创建 Person 对象；存储到一个新集合中。（暂未更新）

7、打印整个队伍的Person对象信息。（暂未更新）

public class TestCalc {
public static void main(String[] args) {
		// 第一支队伍
		ArrayList<String> one = new ArrayList<>();
		Collections.addAll(one, "迪丽热巴", "肖战", "Jay", "王菲", "张云雷", "何云伟");
		List<String> oneA = new ArrayList<>();
		for (String name : one) {
			if (name.length() == 3) {
				oneA.add(name);
			}
		}
		System.out.println("1、第一个队伍只要名字为3个字的成员姓名:");

		for (String name : oneA) {
			System.out.println(name);
		}

		List<String> oneB = new ArrayList<>();
		for (int i = 0; i < 3; i++) {
			oneB.add(one.get(i));
		}
		System.out.println("2、 第一个队伍筛选之后只要前3个人:");
		for (String list : oneB) {
			System.out.println(list);
		}

		// 第二支队伍
		ArrayList<String> two = new ArrayList<>();
		Collections.addAll(two, "张无忌", "张三丰", "赵四", "张二狗");

		List<String> twoA = new ArrayList<>();
		for (String name : two) {
			if (name.startsWith("张")) {
				twoA.add(name);
			}
		}
		System.out.println("3、 第二个队伍只要姓张的成员姓名:");
		for (String name : twoA) {
			System.out.println(name);
		}

		List<String> twoB = new ArrayList<>();
		for (int i = 2; i < two.size(); i++) { // i=x 队伍筛选之后不要前x个人
			twoB.add(two.get(i));
			// twoB.add(two.get(i));
		}

		System.out.println("4、 第二个队伍筛选之后不要前2个人:");
		for (String name : twoB) {
			// System.out.println(twoB);
		}
		System.out.println(twoB);

		// 5、 将两个队伍合并为一个队伍；存储到一个新集合中
		List<String> totalNames = new ArrayList<>();
		totalNames.addAll(one);// Jay 张云雷 何云伟
//			totalNames.addAll(oneB);//迪丽热巴  肖战  Jay
		totalNames.addAll(two); // 张无忌 张三丰 张二狗
//			totalNames.addAll(twoB);  //赵四, 张二狗
		// 根据姓名创建Person对象；
		List<Person> totalPersonList = new ArrayList<>();
		for (String name : totalNames) {
			totalPersonList.add(new Person(name));
		}
		System.out.println("5、将两个队伍合并为一个队伍；存储到一个新集合中:");
		// 打印整个队伍的Person对象信息。
		for (Person person : totalPersonList) {
			// System.out.println(person);

		}
		System.out.println(totalNames);

	}// "迪丽热巴", "肖战", "Jay", "王菲", "张云雷", "何云伟"
		// "张无忌", "张三丰", "赵四", "张二狗"
}

Person

public class Person {
    private String name;
    public Person() {}
    public Person(String name) {
        this.name = name;
    } 
    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

运行截图：
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/726376.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

爬虫的分布式思维与实现思路

爬虫的分布式思维与实现思路

爬虫的分布式思维与实现思路 基本构架 scrapy-redis实现分布式&#xff0c;其实从原理上来说很简单&#xff0c;这里为描述方便&#xff0c;我们把自己的核心服务器称为master&#xff0c;而把用于跑爬虫程序的机器称为slave 我们知道&#xff0c;采用scrapy框架抓取网页&…
阅读更多...
netty学习（4）:通过SpringBoot Web发送消息实现netty实现多个客户端与服务器通信

netty学习（4）:通过SpringBoot Web发送消息实现netty实现多个客户端与服务器通信

1. 基于netty学习&#xff08;3&#xff09;:SpringBoot整合netty实现多个客户端与服务器通信的学习&#xff0c;要想通过http在netty客户端之间发送消息&#xff0c;需要实现spring-boot-starter-web&#xff0c;封装消息格式&#xff0c;自动调用netty客户端 2. 封装一个简单…
阅读更多...
算法笔记——哈希表篇

算法笔记——哈希表篇

一般哈希表都是用来快速判断一个元素是否出现集合里&#xff0c;哈希表并不意味着一定要使用HashMap&#xff0c;有时候使用数组更方便&#xff0c;有时候要使用set&#xff0c;依据具体情况而定&#xff0c;哈希表是典型的空间换时间。 数组作为哈希表 一些应用场景就是为数组…
阅读更多...
工具 | 应用程序无法启动，应为应用程序的并行配置不正确

工具 | 应用程序无法启动，应为应用程序的并行配置不正确

工具 | 应用程序无法启动&#xff0c;应为应用程序的并行配置不正确 “E:\02-Doc\朱老师物联网大讲堂-全部视频\朱有鹏老师嵌入式linux核心课程\开发版光盘资料\X210V3S_A\tools\x210_Fusing_Tool.exe”的激活上下文生成失败。 找不到从属程序集 Microsoft.VC90.MFC,processorA…
阅读更多...
DNS-去中心化域名系统，创建您在DeSoc 社会中的YUAN ID

DNS-去中心化域名系统，创建您在DeSoc 社会中的YUAN ID

传统域名系统 (DNS) 是一个分层的分散信息存储&#xff0c;用于将用户在网络浏览器中输入可读名称&#xff08;例如 www.baidu.com&#xff09;解析为IP地址&#xff0c;来访问互联网上的计算机。传统DNS使用一种分布式数据库&#xff0c;有严格的上下级关系&#xff0c;上级仅…
阅读更多...
[Android JNI] --- JNIEnv和JavaVM

[Android JNI] --- JNIEnv和JavaVM

1 JVMEnv 1.1 JNIEnv 是什么 JNIEnv 即 Java Native Interface Environment&#xff0c;Java 本地编程接口环境。JNIEnv 内部定义了很多函数用于简化我们的 JNI 编程。 JNIEnv是提供JNI Native函数的基础环境&#xff0c;线程相关&#xff0c;不同线程的JNIEnv相互独立&#…
阅读更多...
SpringBoot快速回顾（@value读取配置文件)

SpringBoot快速回顾（@value读取配置文件)

目录 1.定义配置文件2. 定义Controller类3. 测试4. 优化4.1 封装实体类4.3 定义controller类4.2 测试 本文将介绍如何使用value读取配置文件的内容。 在实际项目中&#xff0c;往往会在配置文件中写项目部署需要配置的环境信息&#xff08;数据库驱动&#xff0c;数据库账号密码…
阅读更多...
医疗金融法律大模型：从ChatDoctor到FinBERT/FinGPT/BloombergGPT、ChatLaw/LawGPT_zh

医疗金融法律大模型：从ChatDoctor到FinBERT/FinGPT/BloombergGPT、ChatLaw/LawGPT_zh

第一部分 各种医疗类ChatGPT&#xff1a;或中英文数据微调LLaMA、或中文数据微调ChatGLM 1.1 基于LLaMA微调的中英文版ChatDoctor 1.1.1 ChatDoctor&#xff1a;通过self-instruct技术提示API的数据和医患对话数据集微调LLaMA Github上有一个基于LLaMA模型的医疗微调模型&am…
阅读更多...
zabbix （自定义监控内容-配置邮件报警-自动发现与自动注册）

zabbix （自定义监控内容-配置邮件报警-自动发现与自动注册）

目录 zabbix 客户端主机配置自定义监控内容设置邮件报警zabbix 自动发现与自动注册zabbix 自动发现&#xff08;对于 agent2 是被动模式&#xff09;//zabbix 自动发现&#xff08;对于 agent2 是被动模式&#xff09;zabbix 自动注册&#xff08;对于 agent2 是主动模式&#…
阅读更多...
IDEA+springboot+jpa+Layui+Mysql销售考评系统源码

IDEA+springboot+jpa+Layui+Mysql销售考评系统源码

IDEAspringbootjpaLayuiMysql销售考评系统源码 一、系统介绍1.环境配置 二、系统展示1. 管理员登录2.评分结果3.评分管理4.添加评分5.用户管理6.添加用户7.角色管理8.添加角色8.销售管理9.添加销售 三、部分代码UserDao.javaUserController.javaUser.java 四、其他获取源码 一、…
阅读更多...
计算机组成原理实验二：多位逻辑门构建

计算机组成原理实验二：多位逻辑门构建

目录 一、实验目的 二、实验设备 三、实验原理 四、实验内容 1. 16位非门 2.16位与门 3.16位或门 4. 16位复用器 五、实验习题 1.还可以怎样设计各种芯片的物理结构 2.“block copy”&#xff08;块复制&#xff09;和edit菜单中“copy to clipboard”的区别 六、自…
阅读更多...
在线OJ项目

在线OJ项目

1.在线OJ-背景介绍 在线的网页版的编程平台.&#xff0c;打开一个网站,上面就能看到很多的算法题.&#xff0c;在线做题,在线提交.立即就能看到运行结果,是否通过. leetcode 牛客等 一个在线OJ平台,核心功能: 能够管理题目(保存很多的题目信息:题干&#xff0b;测试用例)题…
阅读更多...
FPGA软核调试方法

FPGA软核调试方法

软核工程创建步骤 创建如下工程目录 bin目录&#xff1a;存放SDK工程生成的elf文件(Release编译模式) hdf目录&#xff1a;存放fpga工程师提供的的hdf文件 prj目录&#xff1a;工程目录(包含SDK工程源码) doc目录&#xff1a;文档目录 基于2018.2版本SDK建立工程 打开Xil…
阅读更多...
Spring Boot中的CSRF攻击及预防

Spring Boot中的CSRF攻击及预防

Spring Boot中的CSRF攻击及预防 什么是CSRF攻击&#xff1f; CSRF&#xff08;Cross-site Request Forgery&#xff09;跨站请求伪造&#xff0c;也称为“one-click attack”或“session riding”&#xff0c;是一种网络攻击方式&#xff0c;攻击者通过在受害者浏览器上欺骗或…
阅读更多...
【redis】生产级部署

【redis】生产级部署

目录 环境部署 redis环境部署 redis多实例配置 构建redis cluster集群 cluster生产集群部署 Cluster集群故障切换 环境部署 1 、关闭防火墙 2 、准备两台虚拟机配置内容如下 redis-master 192.168.108.67 7000 redis-master01 7001 redis-master02 7002 redis-ma…
阅读更多...
Vue2.0-3.0 入门到实战 - 初始及插件安装

Vue2.0-3.0 入门到实战 - 初始及插件安装

1 创建view实例,初始化渲染 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title> </head> <body><div id"app">{{ msg }} </div><script type&…
阅读更多...
第123天：内网安全-域防火墙入站出站规则不出网隧道上线组策略对象同步

第123天：内网安全-域防火墙入站出站规则不出网隧道上线组策略对象同步

#知识点&#xff1a; 0、防火墙组策略对象 1、OSI七层协议模型 2、正反向监听器说明 3、隧道技术分层协议 4、CS&MSF&控制上线-隧道技术&#xff1a;解决不出网协议上线的问题&#xff08;利用出网协议进行封装出网&#xff09; -代理技术&#xff1a;解决网络通讯不通…
阅读更多...
arduino平台控制直流电机PID速度闭环控制编程实现

arduino平台控制直流电机PID速度闭环控制编程实现

PID&#xff08;Proportional-Integral-Derivative&#xff0c;比例-积分-微分&#xff09;控制是一种常用的控制算法&#xff0c;可以用于实现直流有刷电机的速度闭环控制。PID控制器根据当前的误差&#xff08;期望速度与实际速度之差&#xff09;来计算输出&#xff0c;以调…
阅读更多...
RabbitMQ系列（15）--死信队列的简介与死信队列和死信消费者的实现

RabbitMQ系列（15）--死信队列的简介与死信队列和死信消费者的实现

1、死信的概念 死信&#xff0c;顾名思义就是无法被消费的消息&#xff0c;一般来说producer&#xff08;生产者&#xff09;将消息投递到broker或直接放到queue&#xff08;队列&#xff09;中&#xff0c;consumer&#xff08;消费者&#xff09;从queue&#xff08;队列&am…
阅读更多...
Css基础：盒子模型

Css基础：盒子模型

1.盒子模型的构成&#xff1a; 边框 外边距 内边距 实际内容 2.table表格的单元格之间的线太粗需要border-collapse:collapse;合并一下边框宽度 3.内边距 padding 4.外边距 margin 块元素水平居中的做法&#xff0c;margin:0 auto; 行内元素和行内块元素 水平居中做…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023