Java基础（十）——网络编程、Lambda表达式、函数式接口、Stream流

最新推荐文章于 2022-11-24 18:08:08 发布

空城机

最新推荐文章于 2022-11-24 18:08:08 发布

阅读量323

点赞数

分类专栏： Java 文章标签： java intellij idea

本文链接：https://blog.csdn.net/qq_36171287/article/details/105026339

版权

Java 专栏收录该内容

25 篇文章 5 订阅

订阅专栏

网络编程

网络编程概述

计算机网络

是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统

网络编程

在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

具体概述可以去看看

https://blog.csdn.net/qq_36171287/article/details/95670584

https://blog.csdn.net/qq_36171287/article/details/99580141

网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号, 通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识

Java中有InetAddress类

public class InetAddress
extends Object
implements Serializable

此类表示Internet协议（IP）地址。

IP地址是由IP使用的32位或128位无符号数字，构建UDP和TCP协议的低级协议。 IP地址结构由定义RFC 790: Assigned Numbers ， RFC 1918: Address Allocation for Private Internets ， RFC 2365: Administratively Scoped IP Multicast和RFC 2373: IP Version 6 Addressing Architecture 。 InetAddress的一个实例由一个IP地址和可能的相应主机名组成（取决于它是用主机名构造还是已经完成了反向主机名解析）。

例子：

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        //确定主机名称的IP地址
        InetAddress address = InetAddress.getByName("192.168.0.101");
        //获取IP地址主机名
        String name = address.getHostName();
        //返回文本显示中的IP地址字符串
        String ip = address.getHostAddress();

        System.out.println("主机名：" + ip);
        System.out.println("IP地址：" + ip);
    }
}

端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢?如果说IP地址可以唯一标识网络中的设备, 那么端口号就可以唯标识设备中的应用程序了。也就是应用程序的标识

协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则- 样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统-规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

TCP协议

传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据,
- 它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端
- 向服务端发出连接请求，每次连接的创建都需要经过“三次握手"
三次握手: TCP协议中,在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
- 第一次握手,客户端向服务器端发出连接请求，等待服务器确认
- 第二次握手，服务器端向客户端回送-一个响应，通知客户端收到了连接请求
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接

TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一一个Socket对象，从而在通信的两端形成网络虚拟链路，一旦建立了虚拟的网络链路,两端的程序就可以通过虚拟链路进行通信
Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生流来进行网络通信
Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

发送端代码：

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPsend {
    public static void main(String[] args) throws IOException {
        //创建socket对象
//        Socket sc = new Socket(InetAddress.getByName("127.0.0.1"),123456);
        Socket s = new Socket("127.0.0.1",12345);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,TCP".getBytes());

        //释放资源
        s.close();
    }
}

接收端：

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPreceive {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(12345);
        //accept()：侦听要连接到此套接字并接受它
        Socket s = ss.accept();

        //获取输入流，读数据
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println("数据是："+data);

        s.close();
    }
}

运行结果：

UDP协议

UDP协议是一种不可靠的网络协议，它在通信的两端各建立-个Socket对象,但是这两个Socket只是发送，接收数据的对象
因此对于基于UDP协议的通信双方而言,没有所谓的客户端和服务器的概念
Java提供了DatagramSocket类作为基于UDP协议的Socket

发送数据的步骤

①创建发送端的Socket对象(DatagramSocket)
②创建数据，并把数据打包
③调用DatagramSocke对象的方法发送数据
④关闭发送端

import java.io.IOException;
import java.net.*;
public class UDPdemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        //创建数据，把数据打包
        //构造一个数据包，发送程度为len的数据包到指定主机的指定端口号
        byte[] bys = "hello world,我来了".getBytes();
        int len = bys.length;
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bys,len,address,port);

        //调用DatagramSocke对象的方法发送数据
        ds.send(dp);

        //关闭发送端
        ds.close();
    }
}

UDP接收数据

接收数据的步骤

①创建接收端的Socket对象(DatagramSocket)
②创建一个数据包，用于接收数据
③调用DatagramSocket对象的方法接收数据
④解析数据包，并把数据在控制台显示
⑤关闭接收端

代码：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UDPreceive {
    public static void main(String[] args) throws IOException {
        //创建socket接收端对象，参数是制定的端口
        DatagramSocket ds = new DatagramSocket(10086);

        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys,bys.length);

        ds.receive(dp);
        //解析数据包，并把数据在控制台显示
        int len = dp.getLength();
        byte[] data = dp.getData();
        System.out.println("数据是:" + new String(data,0,len));

        ds.close();
    }
}

运行接收端，然后再运行发送端，这样接收端控制台中就能够接收到发送端发送过来的数据了

Lambda表达式

函数式编程思想概述

在数学中，函数就是有输入量输出量的一套计算方案,也就是“拿数据做操作”
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法:“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现

例子：很像JavaScript中的箭头函数

public class LambdaDemo {
    public static void main(String[] args) {
        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

        //匿名内部类的方式改进
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("多线程程序启动了");
//            }
//        }).start();

        //Lambda表达式方式改进
        new Thread( ()->{
            System.out.println("多线程程序启动了");
        } ).start();
    }
}

Lambda表达式标准格式

匿名内部类中重写run()方法的代码分析

方法形式参数为空,说明调用方法时不需要传递参数
方法返回值类型为void, 说明方法执行没有结果返回
方法体中的内容，是我们具体要做的事情

Lambda表达式的代码分析

(): 里面没有内容,可以看成是方法形式参数为空
->:用箭头指向后面要做的事情
{}: 包含一段代码，我们称之为代码块，可以看成是方法体中的内容

JavaScript中箭头函数例子：

var fun = function(a,b){ return a+b; }

var f = (a,b) => a+b

Lambda表达式的格式

格式: (形式参数)-> {代码块}

形式参数:如果有多个参数，参数之间用逗号隔开;如果没有参数，留空即可
->:由英文中画线和大于符号组成，固定写法。代表指向动作
代码块:是我们具体要做的事情，也就是以前我们写的方法体内容

其只能有一个抽象方法，否则就不是函数时接口，就无法用Lambda表达式。

函数式接口

概述

函数式接口:有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

@Functionallnterface
放在接口定义的上方:如果接口是函数式接口，编译通过;如果不是，编译失败

注意

我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是,建议加上该注解

函数式接口作为方法的参数

定义一个类(RunnableDemo),在类中提供两个方法

一个方法是: startThread(Runnable r)方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用start Thread方法

例子：

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

        startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
    }
    private static void startThread(Runnable r){
//        Thread t = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}

Supplier接口

Supplier<T>:包含一个无参的方法

T get():获得结果
该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

例子：

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(()->{
            return "宝可梦";
        });
        System.out.println(s);
    }

    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

Stream流

public interface Stream<T>
extends BaseStream<T,Stream<T>>

使用Stream流的方式完成过滤操作
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:生成流、过滤、逐一打印
Stream流把真正的函数式编程风格引入到ava中

Stream流生成方式

Stream流的使用

生成流
- 通过数据源(集合，数组等)生成流
- list.stream()
中间操作
- 一个流后面可以跟随零个或多个中间操作,其目的主要是打开流，做出某种程度的数据过滤映射，然后返回一个新的流,交给下一个操作使用
- filter()
终结操作
- 一个流只能有一个终结操作，当这个操作执行后，流就被使用“光” 了,无法再被操作。所以这必定是流的最后一个操作
- forEach()

Stream流的常见生成方式

Collection体系的集合可以使用默认方法stream()生成流
1. default Stream<E> stream（）
Map体系的集合间接的生成流
数组可以通过Stream接口的静态方法of(T... values)生成流

例子：

public class CreateStream {
    public static void main(String[] args) {
//        Collection体 系的集合可以使用默认方法stream()生成流
//        default Stream<E> stream（）
        List<String> list = new ArrayList<>();
        Stream<String> liststream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setstream = set.stream();

//        Map体系的集合间接的生成流
        Map<Integer,String> map = new HashMap<>();
        Stream<Integer> keystream = map.keySet().stream();
        Stream<String> valuestream = map.values().stream();
        Stream<Map.Entry<Integer,String>> mapstream = map.entrySet().stream();

//        数组可以通过Stream接口的静态方法of(T... values)生成流
        String[] strarray = {"hello","hi","thank","you"};
        Stream<String> strstream = Stream.of(strarray);
        Stream<String> strstream2 = Stream.of("hello","hi","thank","you");

    }
}

一起学习，一起进步 -.- ，如有错误，可以发评论

空城机

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础（十）——网络编程、Lambda表达式、函数式接口、Stream流

网络编程网络编程概述计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统网络编程在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换具体概述可以去看看https://blog.csdn.net/qq_36171287...
复制链接

扫一扫