网络编程（UDP、TCP）

原创 已于 2022-01-18 21:15:52 修改 · 291 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #java

于 2021-01-31 22:59:44 首次发布
本文详细介绍了Java网络编程的基础，包括使用InetAddress获取主机信息，以及实现UDP和TCP通信的完整步骤。通过实例展示了UDP发送和接收数据的过程，以及在不同场景下的应用，如键盘录入、文件传输等。同时，还涵盖了TCP通信的客户端和服务器端交互，包括发送数据、接收反馈、文件上传等。最后，提到了多线程在文件上传中的应用，实现了更高效的服务器处理能力。

网络编程

1.网络编程入门

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import java.net.InetAddress;
import java.net.UnknownHostException;

/*
    InetAddress
        此类表示Internet协议（IP）地址

    public static InetAddress getByName​(String host)：确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
    public String getHostName​()：获取此IP地址的主机名
    public String getHostAddress​()：返回文本显示中的IP地址字符串
 */
public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        //public static InetAddress getByName​(String host)：确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
        //InetAddress address = InetAddress.getByName("DESKTOP-DTO32CR");
        InetAddress address = InetAddress.getByName("192.168.1.16");
        //public String getHostName​()：获取此IP地址的主机名
        
        String name = address.getHostName();
        //public String getHostAddress​()：返回文本显示中的IP地址字符串
        String ip = address.getHostAddress();

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.UDP通信程序

在这里插入图片描述
在这里插入图片描述

import java.io.IOException;
import java.net.*;

/*
    UDP发送数据的步骤
        1:创建发送端的Socket对象(DatagramSocket)
        2:创建数据，并把数据打包
        3:调用DatagramSocket对象的方法发送数据
        4:关闭发送端
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket​() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        DatagramSocket ds = new DatagramSocket();

        //创建数据，并把数据打包
        //DatagramPacket​(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();
        
//        int length = bys.length;
//        InetAddress address = InetAddress.getByName("192.168.1.66");
//        int port = 10086;
//        DatagramPacket dp = new DatagramPacket(bys,length,address,port);
        
        //简写
        DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);

        //调用DatagramSocket对象的方法发送数据
        //void send​(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);

        //关闭发送端
        //void close​() 关闭此数据报套接字
        ds.close();
    }
}

在这里插入图片描述

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/*
    UDP接收数据的步骤
        1:创建接收端的Socket对象(DatagramSocket)
        2:创建一个数据包，用于接收数据
        3:调用DatagramSocket对象的方法接收数据
        4:解析数据包，并把数据在控制台显示
        5:关闭接收端
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        //DatagramSocket​(int port) 构造数据报套接字并将其绑定到本地主机上的指定端口
        DatagramSocket ds = new DatagramSocket(10086);

        //创建一个数据包，用于接收数据
        //DatagramPacket​(byte[] buf, int length) 构造一个 DatagramPacket用于接收长度为 length数据包
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys,bys.length);

        //调用DatagramSocket对象的方法接收数据
        ds.receive(dp);

        //解析数据包，并把数据在控制台显示
        //byte[] getData() 返回数据缓冲区
//        byte[] datas = dp.getData();
        //int getLength​() 返回要发送的数据的长度或接收到的数据的长度
//        int len = dp.getLength();
//        String dataString = new String(datas,0,len);
//        System.out.println("数据是：" + dataString);
        
        //简写
        System.out.println("数据是：" + new String(dp.getData(),0,dp.getLength()));

        //关闭接收端
        ds.close();
    }
}

在这里插入图片描述

2.1 UDP通信程序练习

在这里插入图片描述
SendDemo

/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();

        //自己封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null) {
            //输入的数据是886，发送数据结束
            if ("886".equals(line)) {
                break;
            }

            //创建数据，并把数据打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);

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

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

ReceiveDemo

/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }

        //关闭接收端
//        ds.close();
    }
}

在这里插入图片描述
在这里插入图片描述
还可以创建多个发送端，形成类似聊天室窗口

3.TCP通信程序

在这里插入图片描述
在这里插入图片描述

/*
    TCP发送数据的步骤
        1:创建客户端的Socket对象(Socket)
        2:获取输出流，写数据
        3:释放资源
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket​(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号
//        Socket s = new Socket(InetAddress.getByName("192.168.1.66"),10000);
        //Socket​(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("192.168.1.66",10000);

        //获取输出流，写数据
        //OutputStream getOutputStream​() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

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

在这里插入图片描述

/*
    TCP接收数据的步骤
        1:创建服务器端的Socket对象(ServerSocket)
        2:获取输入流，读数据，并把数据显示在控制台
        3:释放资源
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket​(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);

        //Socket 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();
        ss.close();
    }
}

3.1 TCP通信程序练习

3.1.1 服务器给出反馈

在这里插入图片描述

/*
    客户端：发送数据，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        Socket s = new Socket("192.168.1.66", 10000);

        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //接收服务器反馈
        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);

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


/*
    服务器：接收数据，给出反馈
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        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);

        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已经收到".getBytes());

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

在这里插入图片描述
在这里插入图片描述

3.1.2 客户端数据来自于键盘录入

在这里插入图片描述

/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }

            //获取输出流对象
//            OutputStream os = s.getOutputStream();
//            os.write(line.getBytes());
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

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

/*
    服务器：接收到的数据在控制台输出
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端的连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //获取输入流
//        InputStream is = s.getInputStream();
//        InputStreamReader isr = new InputStreamReader(is);
//        BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

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

3.1.3 服务器数据写入文本文件

在这里插入图片描述客户端和上面一样

/*
    服务器：接收到的数据写入文本文件
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        ss.close();
    }
}

3.1.4 服务器数据来自于文本文件

在这里插入图片描述

/*
    客户端：数据来自于文本文件
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

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

服务器端和上面一样

3.1.5 上传文件服务器给出反馈

在这里插入图片描述
ClientDemo

/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(22222);

        //自定义结束标记,如果要复制的文本中有和自定义标记自定义标记一样的字符串，
        //则自定义标记之后的文本停止传输
//        bw.write("886");
//        bw.newLine();
//        bw.flush();

        //public void shutdownOutput​()
        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

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

ServerDemo

/*
    服务器：接收到的数据写入文本文件，给出反馈
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));

        String line;
        while ((line=br.readLine())!=null) { //等待读取数据
//            if("886".equals(line)) {
//                break;
//            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(11111);

        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

        //释放资源
        bw.close();
        ss.close();
    }
}

3.1.6 多线程实现文件上传

在这里插入图片描述
ClientDemo

/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

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

ServerThread

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

public class ServerThread implements Runnable {
    private Socket s;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try {
            //接收数据写到文本文件
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//            BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
            //解决名称冲突问题
            int count = 0;
            File file = new File("myNet\\Copy["+count+"].java");
            while (file.exists()) {
                count++;
                file = new File("myNet\\Copy["+count+"].java");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));

            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();

            //释放资源
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ServerDemo

/*
    服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }

//        ss.close();
    }
}
网络编程（TCP/UDP通信）
qq_59342972的博客
03-15 682
简单讲述TCP与UDP的通讯过程
网络编程 udp tcp
08-22
在众多网络编程技术中，TCP和UDP这两种传输协议因其广泛应用而显得尤为重要。TCP（Transmission Control Protocol，传输控制协议）与UDP（User Datagram Protocol，用户数据报协议）在实现机制、应用场景及性能表现...
TCP_UDP网络编程
wanggong_1991的博客
11-23 580
一.TCP 1.TCP流程-服务器端 》》socket类型: 流式套接字SOCK_STREAM 数据报套接字SOCK_DGRAM 原始套接字SOCK_RAW 》》IP地址的转换: in_addr_t inet_addr(const char *strptr); 功能: 将strptr所指向的字符串转换成32位的网络字节序二进制值 如 inet_addr(“192.168.7.135”); char * inet_ntoa(struct in_addr inaddr); //struct in_add
第十五章 、网络编程
爱码者的博客
07-28 1100
网络编程 目录 文章目录网络编程目录主要内容学习目标第15章 网络编程15.1 软件结构15.2 网络通信协议15.2.1 TCP/IP协议参考模型15.2.2 TCP与UDP协议15.3 网络编程三要素1、协议2、IP地址3、端口号15.4 InetAddress类15.5 Socket15.6 TCP网络编程15.6.1 通信模型15.6.2 开发步骤1、服务器端2、客户端15.6.3 相关A...
网络编程（TCP/UDP）
qq_63250428的博客
12-16 1350
TCP/UDP
网络编程—TCP、UDP编程
萌新
04-14 1208
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
简单的聊天程序 网络编程 UDP TCP
01-11
在IT领域，网络编程是构建分布式系统和互联网应用程序的基础，其中UDP（用户数据报协议）和TCP（传输控制协议）是两种最常用的网络通信协议。本文将深入探讨这两种协议及其在简单聊天程序中的应用。 首先，TCP是一...
《深入Java网络编程：TCP与UDP实战攻略》
08-31
内容概要：本文系统讲解了Java网络编程中TCP与UDP协议的核心概念与实战开发，涵盖TCP/IP协议族、端口与IP地址分类、客户端-服务器模型等基础理论，并深入介绍Java中Socket、ServerSocket、DatagramSocket等关键类的...
《深入C语言网络编程：UDP与TCP的实战对决》
最新发布
10-09
内容概要：本文深入讲解了C语言中UDP与TCP网络编程的核心原理与实战应用。首先介绍了UDP协议的无连接、不可靠、面向数据报和低开销等特性，并详细说明了socket、sendto、recvfrom等核心函数的使用方法。随后通过实现...
网络编程UDP、TCP详解
ForFuture
07-16 400
网络编程   网络编程主要用于解决计算机与计算机（手机、平板…）之间的数据传输问题。 1.InetAddress(IP类)   方法： 方法 描述 getLocalHost() 获取本机的IP地址对象 getByName(“IP或者主机名”) 根据一个IP地址的字符串形式或者是一个主机名生成一个IP地址对象。 (用于获取别人的IP地址对象) getHostAddress()...
JavaSE-数组集合和链表集合 数组和链表.docx
04-18
JavaSE-数组集合和链表集合 数组和链表.docx
计算机网络——基于UDP与TCP网络编程
LYJbao的博客
10-20 2836
保姆级TCP、UDP网络编程，适合小白进来学习~~~
网络编程-TCP与UDP
m0_67391870的博客
04-29 514
1.定义区别 TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送； UDP则不为IP提供可靠性、流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济
数据结构（2）：集合、链表、数组
tianping25的博客
11-19 666
I：概念      集合：用于存储无需元素，值不能重复      链表：是一种线性表，但是并不会在物理存储上分配一块连续空间来存储它，而是在每一个节点里维护一个指针（pointer）指向下一个节点。因此这n个节点是离散分配的，彼此通过指针相连，链表的插入和删除操作复杂度为O（1），查询复杂度为O（n），链表中主要介绍3类，单向链表、双向链表、循环链表。                 单向链...
数据结构之集合和链表
jupiter_888的博客
04-28 1025
底层数据结构 线性结构 线性表是一种线性结构，它是由零个或多个数据元素构成的有限序列。线性表的特征是在一个序列中，除了头尾元素，每个元素都有且只有一个直接前驱，有且只有一个直接后继，而序列头元素没有直接前驱，序列尾元素没有直接后继。 数据结构中常见的线性结构有数组、单链表、双链表、循环链表等。线性表中的元素为某种相同的抽象数据类型。可以是C语言的内置类型或结构体，也可以是C++自定...
数组、集合、链表、哈希表、跳跃链表
不求上进的码农的博客
10-31 626
这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半（上图中是7, 19, 26）。在这样一个链表中，如果我们要查找某个数据，那么需要从头开始逐个进行比较，直到找到包含数据的那个节点，或者找到第一个比给定数据大的节点为止（没找到）。也就是说，时间复杂度为O(n)。数组必须是在内存中有一段连续的内存,所以它必须预先知道长度,数组的访问方式是O(1),而链表是O(N),但是!它可以做到平均复杂度为O(LogN)的插入,删除和查找操作.同样的,Redis的作者在实现SkipList的时候.
集合、List、链表
m0_58421245的博客
07-15 479
一、集合 1.1 概述 java集合是使能够储存和操纵元素不固定的一组数据，所以java集合类都位于java。util包中 注意 :如果集合中存放基本类型，一定要将其“装箱”成对应的“基本类型包装类” 1、2 继承体系 由以上两图我们可以看出Java集合类有清晰的继承关系，有很多子接口和实现类。但是，并不是所有子接口或实现类都是最常用的。 下面我们列举出最常用的几个子接口和实现类： Collection ——> List ——> ArrayList类 Col...
集合-链表
fire57的博客
06-03 586
文章目录1. 什么是链表2. 链表的种类3. 链表与数组的区别4. 链表的使用 1. 什么是链表 链表： 链表是由一组不必相连（可相连可不相连）的内存结构（节点）按特定的顺序链接在一起的抽象数据类型。 链表是离散存储线性结构 离散： 链表的每个节点可能存于不相连的内存块中，即两个或多个节点所处的内存块的内存地址不相连，所以说链表是离散的。 线性： 通过链表的头结点可以找到下一个节点，直至找到尾结点，就像多个有顺序的点可以连成一条线，所以说链表是线性的。 链表由节点组成，链表的节点离散分配，节点彼此通过指针相
Java笔记—集合
maohe的博客
08-17 721
集合的框架集合框架的概述集合，数组都是对多个数据进行存储的结构，简称Java容器。说明：此时的内存，主要是内存层面的存储，不涉及到持久化的储存（.txt,jpg,avi等等）
网络编程核心TCP/UDP源代码解析
在网络编程中，TCP（传输控制协议）和UDP（用户数据报协议）是最常用的两种协议，它们分别在可靠性和速度上有着不同的特点和应用场景。 ### TCP（传输控制协议） TCP是一种面向连接的、可靠的、基于字节流的传输层...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值