I/O流与网络编程

最新推荐文章于 2024-08-12 14:02:31 发布
最新推荐文章于 2024-08-12 14:02:31 发布
阅读量141 收藏
点赞数
文章标签： 网络 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55737591/article/details/127999105
版权

I/O流与网络编程

将文件通过流方式输出到控制台上

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class FileTest {
    //单元测试的文件路径定位到模块下，main方法则定位到工程下
    @Test
    public void test(){
        FileReader fileReader= null;
        try {
            File file = new File("hello.txt");
            fileReader = new FileReader(file);
            int data;
            while ((data=fileReader.read())!=-1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileReader!=null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

使用read(char[] cbuf)读数据

 @Test
    public void test1(){
        FileReader fr = null;
        try {
            File file = new File("hello.txt");
            fr = new FileReader(file);
            int len;
            char[] cbuf=new char[5];
            while ((len=fr.read(cbuf))!=-1){
                //方式一
//                for (int i = 0; i < len; i++) {
//                    System.out.print(cbuf[i]);
//                }
                //方式二
                String s = new String(cbuf, 0, len);
                System.out.print(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                fr.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

写出数据到硬盘上

/**
 * FileWriter(File file) 默认是覆盖
 * FileWriter(File file,boolean append) append=true是追加
 */
@Test
public void test2(){
    FileWriter fileWriter = null;
    try {
        File file = new File("hello1.txt");
        fileWriter = new FileWriter(file,true);
        fileWriter.write("I have a dream\n");
        fileWriter.write("You need to have a dream");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (fileWriter!=null){
            try {
                fileWriter.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

}

文件的读入和写出

 @Test
    public void test3(){
        FileReader fr= null;
        FileWriter fw= null;
        try {
            File file = new File("hello1.txt");
            fr = new FileReader(file);
            fw = new FileWriter("hello2.txt");
            char[] cbuf=new char[5];
            int len;
            while ((len=fr.read(cbuf))!=-1){
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fr!=null){

                try {
                    fr.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fw!=null){

                try {
                    fw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

图片的复制

 /**
     * 测试FileInputStream和FileOutputStream读写图片文件
     * 字节流数组
     */
    @Test
    public void test4(){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream= null;
        try {
            fileInputStream = new FileInputStream(new File("MP130S.png"));
            fileOutputStream = new FileOutputStream(new File("MP130S1.png"));
            byte[] buff=new byte[1024];
            int len;
            while ((len=fileInputStream.read(buff))!=-1){
                fileOutputStream.write(buff,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fileInputStream!=null){

                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fileOutputStream!=null){

                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }




	//封装为一个方法
   public void testFile(String srcPath,String desPath) {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(new File(srcPath));
            fileOutputStream = new FileOutputStream(new File(desPath));
            byte[] buff = new byte[1024];
            int len;
            while ((len = fileInputStream.read(buff)) != -1) {
                fileOutputStream.write(buff, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fileInputStream != null) {

                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fileOutputStream != null) {

                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

使用缓冲流对非文本文件的复制

 @Test
    public void test6(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(new File("C:\\Users\\CZ\\Desktop\\968cad867de68c74ce135336a947c3f2.mp4"));
            fos = new FileOutputStream(new File("968cad867de68c74ce135336a947c3f21.mp4"));
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            byte[] bytes=new byte[1024];
            int len;
            while ((len=bis.read(bytes))!=-1){
                bos.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (bis!=null){

                try {
                    bis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bos!=null){

                try {
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fis!=null){

                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fos!=null){

                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }

使用缓冲流对文本文件的复制

 @Test
    public void test7(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(new File("hello1.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));
            char[] cbuf=new char[5];
            int len;
            while ((len=br.read(cbuf))!=-1){
                bw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br!=null){

                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bw!=null){

                try {
                    bw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

对图片进行加密和解密

 /**
     * 将读到的值进行异或，如果再异或一遍就是解密
     */
    @Test
    public void test8(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(new File("MP130S.png"));
            fos = new FileOutputStream(new File("MP130S3.png"));
            byte[] bytes=new byte[1024];
            int len;
            while ((len=fis.read(bytes))!=-1){
                for (int i = 0; i < len; i++) {
                    bytes[i]= (byte) (bytes[i] ^ 5);
                }
                fos.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fis!=null){

                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fos!=null){

                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

对每个字符出现的次数进行计数

 @Test
    public void test1(){
        FileReader fr = null;
        FileWriter fw= null;
        try {
            fr = new FileReader(new File("zj.txt"));
            Map<Character,Integer> map=new HashMap<>();
            int len;
            while ((len=fr.read())!=-1) {
                char c = (char) len;
                if (map.get(c) == null) {
                    map.put(c, 1);
                } else {
                    map.put(c, map.get(c) + 1);
                }
            }
            fw = new FileWriter(new File("zj1.txt"));
                Set<Map.Entry<Character, Integer>> entries = map.entrySet();
                for (Map.Entry<Character,Integer> entry1:entries){
                    switch (entry1.getKey()){
                        case ' ':
                            fw.write("空格="+entry1.getValue());
                            break;
                        case '\t':
                            fw.write("tab键="+entry1.getValue());
                            break;
                        case '\r':
                            fw.write("回车="+entry1.getValue());
                            break;
                        case '\n'
                                :fw.write("换行="+entry1.getValue());
                            break;
                        default:
                            fw.write(entry1.getKey()+"="+entry1.getValue());
                            break;
                    }
                    fw.write("\n");
                }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fr!=null){

                try {
                    fr.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fw!=null){

                try {
                    fw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

标准输入输出流的练习

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class FileTest3 {

    public static void main(String[] args) {
        InputStreamReader isr = null;
        BufferedReader br= null;
        try {
            isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while (true){
                System.out.println("请输入字符串");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                    System.out.println("程序结束");
                    break;
                }
                String s = data.toUpperCase();
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br!=null){

                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (isr!=null){

                try {
                    isr.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}

网络编程

客户端发送信息给客户端，服务端显示信息在控制台

import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPTest {



    @Test
    public void client(){
        Socket socket= null;
        OutputStream os = null;
        try {
            //客户端的ip地址
            InetAddress ip=InetAddress.getByName("127.0.0.1");
            //创建Socket类参数为ip和端口的对象
            socket = new Socket(ip,8899);
            //输出流
            os = socket.getOutputStream();
            //返送信息
            os.write("你好，我是客户端，我正在给你发信息".getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (os!=null){

                try {
                    os.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null){

                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }


    @Test
    public void server(){
        ServerSocket ss= null;
        InputStream is = null;
        Socket socket=null;
        ByteArrayOutputStream baos= null;
        try {
            //通过构造器创建端口号
             ss = new ServerSocket(8899);
             //通过调用accept()创建Socket对象
             socket = ss.accept();
             //获取输入流
            is = socket.getInputStream();
//            将数据写出
            baos = new ByteArrayOutputStream();
            byte[] bytes=new byte[5];
            int len;
            while ((len=is.read(bytes))!=-1){
                baos.write(bytes,0,len);
            }
            System.out.println(baos.toString());
            //获取接收到的ip地址
            System.out.println("接收信息的ip地址为:"+socket.getInetAddress().getHostAddress());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (baos!=null){

                try {
                    baos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (is!=null) {

                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null){

                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

        }

    }
}

客户端发送文件给服务器端，服务器端存在本地

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPTest1 {

    @Test
    public void client(){

        Socket socket= null;
        OutputStream os = null;
        FileInputStream fis= null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
            os = socket.getOutputStream();
            fis = new FileInputStream("MP130S.png");
            byte[] bytes=new byte[1024];
            int len;
            while ((len=fis.read(bytes))!=-1){
                os.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fis!=null){

                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (os!=null){

                try {
                    os.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null){

                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }


    @Test
    public void server(){

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos= null;
        try {
            ss = new ServerSocket(9090);
            socket = ss.accept();
            is = socket.getInputStream();
            fos = new FileOutputStream("MP130S1.png");
            byte[] bytes=new byte[1024];
            int len;
            while ((len=is.read(bytes))!=-1){
                fos.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (is!=null) {
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (ss!=null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}

客户端发送文件给服务器端，服务器端存在本地，客户端再发送数据给服务器端，服务器端接收并输出

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPTest2 {

    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis= null;
        InputStream is=null;
        ByteArrayOutputStream baos=null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8999);
            os = socket.getOutputStream();
            fis = new FileInputStream("MP130S.png");
            byte[] bytes=new byte[10];
            int len;
            while ((len=fis.read(bytes))!=-1){
                os.write(bytes,0,len);
            }
            //read()会堵塞，此时进行关闭
            socket.shutdownOutput();

            //接受服务端传来的数据
            is = socket.getInputStream();
            baos=new ByteArrayOutputStream();
            byte[] bytes1=new byte[10];
            int len1;
            while ((len1=is.read(bytes1))!=-1){
                baos.write(bytes1,0,len1);
            }

            System.out.println(baos.toString());

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fis!=null){

                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (os!=null){

                try {
                    os.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }
    @Test
    public void server(){
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos= null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(8999);
            socket = ss.accept();
            is = socket.getInputStream();
            fos = new FileOutputStream("MP130S2.png");
            byte[] bytes=new byte[50];
            int len;
            while ((len=is.read(bytes))!=-1){
                fos.write(bytes,0,len);
            }

            //像客户端发送数据表示已经收到
            os = socket.getOutputStream();
            os.write("客户端，我这边已经收到你传输的数据".getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (os!=null){

                try {
                    os.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (is!=null){

                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket!=null){

                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (ss!=null){

                try {
                    ss.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
叶上不取名
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
OS 文件的IO流
echo.T的博客
08-20 259
学知识要成体系，不仅要知道怎么用，还要知道为什么这么用。魔鬼总是存在于细节之中。今天我们来总结一下文件的IO流。 1、基本的文件IO流 public class OSFileIO_v1 { public static void main(String[] args) { standIO(); } static void standIO() { FileOutputStream out = null; try {...
java IO流与网络编程
weixin_43972609的博客
07-05 649
Java的IO是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在Java中把对于输入/输入操作是以流的方式进行操作的。java.io 包下提供了大量的供我们使用的操作【流】的方法和接口，用于进行各类数据的处理和传输。计算机的输入和输出都是通过二进制来完成的。在网络中我们要传递数据就要将数据【流化】，换句话说就是将文件、复杂的对象转化成能够在网络上传输的一个个的0和1，我在这里先画几幅图帮助大家理解一下。文件在磁盘的输入输出：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(i
Python-os 文件流的一系列操作手册
lb812383331的专栏
06-27 154
import os os.getcwd() # 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname") # 改变当前脚本工作目录；相当于shell下cd os.curdir() # 返回当前目录: ('.') os.pardir() # 获取当前目录的父目录字符串名：('..') os.makedirs('dir1/dir2') # 可生成多层...
文件流和OS
moonlight616的博客
05-26 189
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 r+ 打开一个文件用于读写。文件指针将会放在文件的开头。 rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，...
IO流和网络编程
chenzhao1223的博客
02-09 210
IO流和网络编程UDP
java基础之I/O流
10-12
Java中的I/O流是程序与外部数据交互的重要机制，它允许数据在程序、文件、网络等之间流动。I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流...
Java课程设计报告书-学生版-1_I/O流与文件课程设计_
09-30
在Java编程语言中，I/O流（Input/Output Stream）是处理数据输入和输出的核心机制。本课程设计报告书——“Java课程设计报告书-学生版-1_I/O流与文件课程设计_”旨在帮助学生深入理解并掌握如何在Java中进行文件操作...
探索Java I/O 模型的演进
08-25
1. **传统Java I/O（基于流的I/O）**：Java早期的I/O库基于InputStream和OutputStream，这些类采用阻塞I/O模型，如FileInputStream和FileOutputStream。 2. **NIO（Non-blocking I/O）**：Java 1.4引入了NIO（New I/...
Java I/O流通讯录
11-26
Java I/O流通讯录是一个基于Java编程语言设计的实用程序，它主要用于演示和学习Java的I/O流操作。在这个项目中，开发者通过I/O流实现了对文件的读写功能，从而构建了一个简单的通讯录系统。这个系统允许用户进行添加...
怎么使用I/O编程???
07-01
在Java编程中，I/O（Input/Output）处理是与外部世界交互的关键技术，涉及文件读写、网络通信等场景。I/O的核心思想是通过流(Stream)来传输数据，使得程序能从数据源读取数据或将数据写入目标。 **1.1 I/O简介** I...
IO流与网络编程
weixin_42687074的博客
04-08 739
前文： BIO流（传统IO流）：同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。 网络编程：本质是两个设备之间的数据交换，使用IP地址、域名、端口连接到另一台计算机上对应的程序，按照规定的协议(数据格式)来交换数据。 NIO流：NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.n...
IO与网络编程
D956683658的博客
09-01 162
io流 输入流：InputStream，FileInputStream，ByteArrayInputStream，BufferedInputStream，Reader，FileReader，BufferedReader 输出流：OutputStream，FileOutputStream，ByteArrayOutputStream，BufferedOutputStream，Writer，FileWriter，BufferedWriter BIO,NIO和AIO BIO:blocking-io,同步
SSH 和 Telnet 之间的区别
ITmoster的博客
08-08 389
SSH 和 Telnet是帮助用户与远程系统建立连接的两种通信协议，这些通信协议决定了数据如何在网络上的不同设备之间传输，这些设备通常需要通过各种物理和数字环境进行传输，网络协议的主要目标是通信、网络管理和安全。
HAProxy基本配置及参数实操
Webston的博客
08-12 866
静态#动态#以下静态和动态取决于hash_type 是否consistentfirst #使用较少static-rr #做了session 共享的web集群leastconn #数据库source#基于客户端公网IP 的会话保持Uri--------------->http #缓存服务器，CDN服务商，蓝汛、百度、阿里云、腾讯url_param--------->http #可以实现session 保持hdr #基于客户端请求报文头部做下一步处理高。
mpls vpn基础实验
wudongfang666的专栏
08-10 480
场景：异地两个站点通过mpls vpn骨干网络实现安全通讯虚拟路由转发 VRF ，相当于在设备内建立一条虚拟通道，一个vpn的实例（vrf）可以简单的理解为一台虚拟设备。拓扑图。
48天笔试训练错题——day44
ミカミミミ博客
08-08 832
48天笔试训练错题——day44.
Netty原理及实战应用（下篇）
最新发布
program哲学
08-12 50
本文详细介绍了netty关于websocket集成、消息推送应用、网络连接编解码等方面的内容
运用Npcap库实现SYN半开放扫描
CSDN
08-10 1083
Npcap 是一款高性能的网络捕获和数据包分析库，作为 Nmap 项目的一部分，Npcap 可用于捕获、发送和分析网络数据包。本章将介绍如何使用 Npcap 库来实现半开放扫描功能。TCP SYN 半开放扫描是一种常见且广泛使用的端口扫描技术，用于探测目标主机端口的开放状态。由于这种方法并不完成完整的 TCP 三次握手过程，因此具有更高的隐蔽性和扫描效率。
思路超清晰的 LVS-NAT 模式实验部署
star103301的博客
08-09 1028
一、实验原理1、实验基础配置图。
Java I/O流与文件操作详解
在Java编程中，I/O（Input/Output）流是处理数据传输的核心概念，它允许程序与外部世界交互，如读取键盘输入、操作文件和目录，以及在网络间发送和接收数据。Java I/O系统主要由java.io和java.nio包提供支持，其中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值