【JAVA CORE_API】Day18 网络编程、线程、在线聊天室v1.0

于 2024-08-21 20:02:58 发布
阅读量512 收藏 15
点赞数 8
分类专栏： Java Core_API 文章标签： java 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HLJ_Student/article/details/141401468
版权

C/S：客户端/服务器端，所有网络应用都是基于客户端服务器端进行的，Java写的是服务端，客户端是一个软件，服务端也是一个软件，两个软件之间交互；（只能连接对应的服务器）

B/S：浏览器/服务器端，它本质上也是C/S，只不过它的C是一个浏览器而已；（连接任意服务器都可以、百度、淘宝、京东等）

聊天室：两个程序A和B，一个是客户端、一个是服务端：谁发起连接，谁是客户端；谁接收连接，谁是服务端。

想连在一起需要网络，目的是为了传输数据，发送数据的过程中时需要遵守一些协议的：
TCP协议：可靠传输协议，发送数据后需要对方确认，对方确认后才能继续发送数据，再需要对方确认，100%所有数据发送过去，比较像打电话，需要接电话才能听见。虽然说数据完全可靠，但效率低下；
UDP：不可靠传输协议，只管发，不管对方能否接收到，有点像大广播，播了就播了，不管你听没听见。虽然不能保证数据100%都发送成功，但是效率比较高。

但是我们学习的时候学TCP，因为日后面对的客户端都是B（浏览器），而浏览器和客户端之间采用的协议是Http协议，Http协议要求地下客户端服务端传输时必须建立在可靠传输协议TCP上。

网络编程

什么是Socket编程

什么是Socket编程

  • java.net.Socket是Java提供的用于进行网络编程的API；

  • Socket编程可以让软件与软件之间以计算机作为载体，以网络作为信息流动的通道进行远端数据传递，达到交流的目的。

什么是计算机网络

  • 计算机网络是指将具有独立功能的多台计算机通过通信线路连接起来，实现数据共享和交流的计算机系统。

什么是Socket

  • Socket（套接字）：网络通信的标准API、进行可靠的网络通讯。

Socket通讯

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

IP地址（楼）

在这里插入图片描述

端口（门）

在这里插入图片描述

IP+端口

在这里插入图片描述

客户端与服务端（C/S）

在这里插入图片描述

Socket通讯

在这里插入图片描述

在这里插入图片描述

ServerSocket

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

多客户端支持

如何接受多客户端

  • ServerSocket提供方法：

    • Socket accept()：用于监听服务端口，一旦一个客户端连接即返回一个Socket；

    • 多次调用该方法可以感知多个客户端的连接。

在这里插入图片描述

建立连接

建立连接

  • Server.java

     package socket;
 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;
 
 /**
  * 服务端
  */
 public class Server {
     /**
      * java.net.ServerSocket:
      * 运行在服务端，主要作用两个:
      * 1.向系统申请服务端口，客户端通过该端口与服务端建立连接
      * 2.监听服务端口，一旦有客户端连接了，就会立即创建一个Socket对象与客户端进行交互
      *   如果将Socket比喻为"电话"，那ServerSocket就相当于客户中心的"总机"
      */
     private ServerSocket serverSocket;
     public Server(){
         try {
             System.out.println("正在启动服务器");
             /**
              * 创建ServerSocket对象时，会申请一个端口
              * 如果该端口被其它程序占用，会抛出异常:
              *   java.net.BindException: Address already in use:
              * 解决办法:
              * 1.更换端口号
              * 2.杀死占用该端口的进行(通常由于服务端启动两次导致)
              */
             serverSocket = new ServerSocket(8088);
             System.out.println("服务器启动完毕");
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 该方法用于启动程序的执行
      */
     public void start(){
         try {
             System.out.println("等待客户端连接...");
             /*
              accept():
              用于接收客户端连接，并返回一个Scoket对象与所连接的客户端进行交互
              该方法是一个阻塞方法，调用后程序会"卡住"，直接一个客户端连接为止
              */
             Socket socket = serverSocket.accept();
             System.out.println("一个客户端连接了!");
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     public static void main(String[] args) {
         Server server = new Server();
         server.start();
     }
 }

  • Client.java

    package socket;
import java.io.IOException;
import java.net.Socket;
/**
 * 客户端
 */
public class Client {
    /*
      java.net.Socket:套接字
      它封装了TCP协议的通信细节，使用它可以和服务器建立连接并进行交互
     */
    private Socket socket;
    public Client(){
        try {
            System.out.println("正在连接服务端...");
            /*
             实例化Socket对象，就是与远端计算机建立连接的过程
             需要传入两个对数:
             1.服务端的IP地址，用于找到网络上对方的计算机
             2.服务端口，用于找到服务端计算机上的应用程序

             查看IP操作:
              Windows: win+r，输入cmd，回车，输入ipconfig，IPv4就是IP地址
              Mac:触控板上五指向中间抓，选择"终端"程序打开，输入/sbin/ifconfig查看IP地址
             */
            socket = new Socket("localhost",8088);
            System.out.println("服务端连接成功!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 该方法用于启动客户端程序的执行
     */
    public void start(){

    }

    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}

  • 注意在尝试连接本地时要提前打开服务端Server.java，再连接自己，之后就可以通过其他人给出的端口号及IP地址连接其他人。

客户端发送文本数据

  • 利用IO只是中的流连接，使用客户端的Socket获取输出流进行流连接，利用PrintWriter来实现发送一行字符串的操作。

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

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

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

Server.java

package day18;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * 服务端
 */
public class Server {
    /**
     * java.net.ServerSocket：
     * 运行在服务端，主要作用有两个：
     * 1.像系统申请服务端口，客户端通过该端口与服务端建立连接
     * 2.监听服务端口，一旦有客户链接了，就会立即创建一个Socket对象与客户端进行交互
     *      如果将Socket比喻为“电话”，那ServerSocket就相当于客户中心的“总机”。
     * 解决方法：
     * 1.更换端口号；
     * 2.杀死占用该端口的进行（通常由于服务端启动了两次导致）
     */
    private ServerSocket serverSocket;
    public Server(){
        try {
            System.out.println("正在启动服务端......");
            serverSocket = new ServerSocket(8888);
            System.out.println("服务端启动完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 启动服务端方法：
    public void start(){
        try {
            while (true){
                System.out.println("服务端正在等待客户端连接......");
                /**
                 * accept()：
                 * 用于接收客户端连接，并返回一个Socket对象与所连接的客户端进行交互
                 * 该方法是一个阻塞方法，调用后程序会“卡住”，直到一个客户端连接为止
                 */
                Socket socket = serverSocket.accept();
                System.out.println("一个客户端连接了！");
                // 接收客户端发送过来的消息
                InputStream inputStream = socket.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                String message;
                while ((message = bufferedReader.readLine()) != null) {    // 读取客户端发送过来的消息
                    System.out.println("客户端说：" + message);
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }

}

Client.java

package day18;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * 客户端
 */
public class Client {
    /**
     * java.net.Socket：套接字
     * 它封装了TCP协议的通信细节，使用它可以和服务器建立连接并进行交互
     * 可以理解为是电话
     */
    private Socket socket;
    public Client() {
        // 实例化Socket对象，就是与远端计算机建立连接的过程
        // 需要传递两个对数：
        // 1.远端计算机的IP地址，用于找到网络上对方的计算机
        // 2.远端计算机的端口号，用于找到对方计算机中的应用程序
        try {
            System.out.println("正在连接服务端......");
            /**
             * 如何查找本机IP地址：
             * Windows：Win+R，输入cmd，回车，输入ipconfig，回车
             * Mac:触控板上五指向中间抓，选择"终端"程序打开，输入/sbin/ifconfig查看IP地址
             */
            socket = new Socket("172.40.140.102", 8088);
            System.out.println("连接成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 该方法用于启动客户端程序的执行
    public void start() {
        // 通过Socket获取输出流用于向服务端发送消息
        try {
            OutputStream outputStream = socket.getOutputStream();
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
            BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
            PrintWriter printWriter = new PrintWriter(bufferedWriter,true);  // 自动行刷新
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String line = scanner.nextLine();
                if ("exit".equalsIgnoreCase(line)) {
                    break;
                }
                printWriter.println(line);  // 发送消息给服务端
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}

三次握手与四次挥手

客户端断开连接的操作

  • 我们在上方代码中输入“exit”后，服务器会出现一大堆红字；

什么是三次握手四次挥手

  • 异常出现的原因：

    • TCP协议是面向连续的可靠传输协议，双方建立连接及断开连接需要双向确认后才可以进行

    • 当任意一方在没有进行确认断开操作就擅自结束，另一方就会出现该异常。

  • 三次握手与四次挥手：

    • 客户端与服务端建立TCP连接时需要进行三次握手，以确保双方可以建立可靠连接；

    • 任意一方需要断开TCP连接时需要进行四次挥手，以确保双方可靠断开。

三次握手（Three-way Handshake）

  • 第一次握手（SYN）：

    • 客户端发送一个带有SYN（同步）标志的数据包到服务器，并指定客户端的初始化序列号（ISN）；

    • 客户端进入SYN_SENT状态，以等待服务器的确认。

  • 第二次握手（SYN-ACK）：

    • 服务器收到客户端的SYN数据包后，会发送一个带有SYN和ACK（确认）标志的数据包到客户端，确认客户端的请求，并指定服务器的初始化序列号（ISN）。

    • 服务器进入SYN_RCVD状态；

  • 第三次握手（ACK）：

    • 客户端收到服务器的SYN-ACK数据包后，会发送一个带有ACK标志的数据包给服务器，表示确认连线请求；

    • 服务器收到客户端的ACK后，双方都进入ESTABLISHED状态，建立起可靠的连接。

在这里插入图片描述

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

四次挥手（Four-way Wavehake）

  • Socket提供方法：

    • void close()：用于和对方断开TCP连接，底层会进行四次挥手操作。

在这里插入图片描述

  1. 客户端发送FIN报文：客户端首先向服务器发送一个带有FIN标志位的保温，表示客户端不再发送数据，并请求关闭连接。此时客户端进入“FIN_WAIT_1”状态；

  2. 服务器发送ACK报文：服务器收到客户端的FIN报文后，会发送一个确认保温，即ACK报文，告知客户端已经收到关闭请求。此时服务器进入“CLOSE_WAIT”状态，等待确认关闭；

  3. 服务器发送FIN报文：服务器在发送ACK报文后，会继续检查是否还有剩余的数据需要发送。如果有，服务器会继续发送数据；如果没有，服务器会发送一个带有FIN标志位的报文给客户端，表示服务器也不在发送数据了。此时服务及进入“LAST_ACK”状态；

  4. 客户端发送ACK报文：客户端收到服务器的FIN报文后，会发送一个确认报文，即ACK报文，告知服务器已经收到关闭请求，并进入“TIME_WAIT”状态。再“TIME_WAIT”状态下，客户端等待一段时间（通常为2倍的最大报文段生存时间，即MSL），以确保服务器已经收到了ACK报文；

  5. 服务器收到ACK报文：服务器收到客户端的ACK报文后，确认客户端已经收到了服务器的关闭请求，此时服务器进入“CLOSED”状态，完成连接的关闭。

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

 package day18;
 import java.io.*;
 import java.net.Socket;
 import java.nio.charset.StandardCharsets;
 import java.util.Scanner;
 
 /**
  * 客户端
  */
 public class Client {
     /**
      * java.net.Socket：套接字
      * 它封装了TCP协议的通信细节，使用它可以和服务器建立连接并进行交互
      * 可以理解为是电话
      */
     private Socket socket;
     public Client() {
         // 实例化Socket对象，就是与远端计算机建立连接的过程
         // 需要传递两个对数：
         // 1.远端计算机的IP地址，用于找到网络上对方的计算机
         // 2.远端计算机的端口号，用于找到对方计算机中的应用程序
         try {
             System.out.println("正在连接服务端......");
             /**
              * 如何查找本机IP地址：
              * Windows：Win+R，输入cmd，回车，输入ipconfig，回车
              * Mac:触控板上五指向中间抓，选择"终端"程序打开，输入/sbin/ifconfig查看IP地址
              */
             socket = new Socket("localhost", 8888);
             System.out.println("连接成功！");
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     // 该方法用于启动客户端程序的执行
     public void start() {
         // 通过Socket获取输出流用于向服务端发送消息
         try {
             OutputStream outputStream = socket.getOutputStream();
             OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
             BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
             PrintWriter printWriter = new PrintWriter(bufferedWriter,true);  // 自动行刷新
             Scanner scanner = new Scanner(System.in);
             while (true) {
                 String line = scanner.nextLine();
                 if ("exit".equalsIgnoreCase(line)) {
                     break;
                 }
                 printWriter.println(line);  // 发送消息给服务端
             }
 
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 socket.close();  // 进行四次挥手
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 
     public static void main(String[] args) {
         Client client = new Client();
         client.start();
     }
 }

多线程

概念

什么是线程与多线程

  • 线程是一个单一的顺序执行流程；

  • 多线程是多个单一顺序执行流程一起执行。

顺序执行与并发执行

  • 顺序执行：程序从上至下一句一句执行；

  • 并发执行：多个线程一起执行称为“并发执行”。

使用场景

  • 互不干扰：多线程通常用于在一个程序中需要同时处理多个互不干扰的任务；

  • 多线程更快：单线程可以完成，但是多线程更快。

单线程和多线程比喻

  • 可以把单线程看作只有一个灶台，一次只能做一道菜；或看作电路中的串联；

  • 多线程则是有很多灶台，一次能做很多菜；或看作电路中的并联。

CPU与多线程

CPU 的多线程操作通过时间片轮转（Time Slicing）来实现。虽然一个 CPU 在某一时刻只能执行一个线程，但它可以在多个线程之间快速切换，使得每个线程都能获得一定的执行时间。这种快速的切换让用户感觉多个线程是同时运行的。

线程的创建

第一种创建线程形式

  • 继承Thread来定义一个线程：

    • 重写run方法，在其中定义该线程的任务代码。
 package day18;
 
 /**
  * 线程的第一种创建方式：继承Thread类
  * 更方便地使用匿名内部类创建线程、结构简单
  * 缺点：Java是单继承的，所以不能再继承其他类
  *      意味着继承了Thread就无法再继承其他类了，不利于复用
  *      定义线程的同时定义了线程的任务，导致线程和任务绑定在了一起，不利于复用
  */
 public class ThreadDemo01 {
     public static void main(String[] args) {
         Thread thread01 = new MyThread01();
         Thread thread02 = new MyThread02();
         // 启动线程要调用star()，而不是直接调用run()方法
         thread01.start();
         thread02.start();
     }
 }
 
 class MyThread01 extends Thread {
     public void run() {
         for (int i = 0; i < 1000; i++) {
             System.out.println("Hi!" + i);
         }
     }
 }
 
 class MyThread02 extends Thread {
     public void run() {
         for (int i = 0; i < 1000; i++) {
             System.out.println("ByeBye！" + i);
         }
     }
 }

第二种创建线程的方式

  • 启动线程：

    • 实例化线程任务；

    • 实例化线程，同时将任务通过现成的构造器传递给线程；

    • 调用线程的start()方法。

 package day18;
 
 /**
  * 第二种创建线程的方式：实现Runnable接口
  */
 public class ThreadDemo02 {
     public static void main(String[] args) {
         // 创建线程任务
         Runnable runnable01 = new MyRunnable01();
         Runnable runnable02 = new MyRunnable02();
         // 创建线程
         Thread thread01 = new Thread(runnable01);
         Thread thread02 = new Thread(runnable02);
         // 启动线程
         thread01.start();
         thread02.start();
     }
 }
 
 class MyRunnable01 implements Runnable {
     @Override
     public void run() {
         for (int i = 1; i <= 1000; i++) {
             System.out.println("Hello!" + i);
         }
     }
 }
 
 class MyRunnable02 implements Runnable {
     @Override
     public void run() {
         for (int i = 1; i <= 1000; i++) {
             System.out.println("Hi!" + i);
         }
     }
 }

使用匿名内部类实现线程的两种创建方式

 package day18;
 
 /**
  * 使用匿名内部类方式实现线程的两种创建方式
  */
 public class ThreadDemo03 {
     public static void main(String[] args) {
         //第一种创建方式：继承Thread并重写run方法
         Thread thread01 = new Thread() {
             public void run() {
                 for (int i = 0; i < 100; i++) {
                     System.out.println("线程01：" + i);
                 }
             }
         };
         thread01.start();
         //第二种创建方式：实现Runnable接口并重写run方法
         Thread thread02 = new Thread(() -> {
             for (int i = 0; i < 100; i++) {
                 System.out.println("线程02：" + i);
             }
         });
         thread02.start();
     }
 }

并发解决聊天室不能多用户使用问题

 package day18;
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.nio.charset.StandardCharsets;
 
 /**
  * 服务端
  */
 public class Server {
     /**
      * java.net.ServerSocket：
      * 运行在服务端，主要作用有两个：
      * 1.像系统申请服务端口，客户端通过该端口与服务端建立连接
      * 2.监听服务端口，一旦有客户链接了，就会立即创建一个Socket对象与客户端进行交互
      *      如果将Socket比喻为“电话”，那ServerSocket就相当于客户中心的“总机”。
      * 解决方法：
      * 1.更换端口号；
      * 2.杀死占用该端口的进行（通常由于服务端启动了两次导致）
      */
     private ServerSocket serverSocket;
     public Server(){
         try {
             System.out.println("正在启动服务端......");
             serverSocket = new ServerSocket(8888);
             System.out.println("服务端启动完成！");
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     // 启动服务端方法：
     /**
      * accept()：
      * 用于接收客户端连接，并返回一个Socket对象与所连接的客户端进行交互
      * 该方法是一个阻塞方法，调用后程序会“卡住”，直到一个客户端连接为止
      */
     public void start(){
         try {
             while (true){
                 System.out.println("服务端正在等待客户端连接......");
                 Socket socket = serverSocket.accept();
                 System.out.println("一个客户端连接了！");
                 
                 // 启动单独的线程来处理与客户端的通信
                 ClientHandler clientHandler = new ClientHandler(socket);
                 Thread thread = new Thread(clientHandler);
                 thread.start();
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     public static void main(String[] args) {
         Server server = new Server();
         server.start();
     }
 
     /**
      * 该线程任务用于负责与指定的客户端通信
      */
     private class ClientHandler implements Runnable{
         private Socket socket;
         public ClientHandler(Socket socket) {
             this.socket = socket;
         }
 
         @Override
         public void run() {
             try {
                 // 接收客户端发送过来的消息
                 InputStream inputStream = socket.getInputStream();
                 InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
                 BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                 String message;
                 while ((message = bufferedReader.readLine()) != null) {    // 读取客户端发送过来的消息
                     System.out.println("客户端说：" + message);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             } finally {
                 try {
                     serverSocket.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

主线程

  • Java程序的任何代码都是靠线程进行，main方法也是；

  • 程序启动后，JVM创建一条线程执行main方法，这条线程我们叫“主线程main”；

什么是主线程

  • Thread提供的静态方法：

    • static Thread currentThread()；

    • 该方法用于返回执行他的线程；

查看线程的相关信息

  • Thread提供了获取线程信息的相关方法：

    • long getId()：返回该线程的标识符；

    • String getName()：返回该线程的名称；

    • int getPriority()：返回线程的优先级；

    • boolean isAlive()：检测线程是否处于活跃状态；

    • boolean isDeamon()：测试线程是否为守护线程；

    • boolean isInterrupted()：测试线程是否已经中断；

 package day18;
 
 import static java.lang.Thread.currentThread;
 
 /**
  * 线程信息
  */
 public class ThreadInfoDemo {
     public static void main(String[] args) {
         Thread main = currentThread();  // 获取主线程
         System.out.println(main);
         doSome();  // 主线程调用doSome方法
     }
 
     public static void doSome() {
         Thread t = currentThread();  // 获取的是doSome方法的线程
         System.out.println("运行doSome方法的线程：" + t);
         System.out.println("运行doSome方法的线程名称：" + t.getName());
         System.out.println("运行doSome方法的线程优先级：" + t.getPriority());
         System.out.println("运行doSome方法的线程是否是守护线程：" + t.isDaemon());
         System.out.println("运行doSome方法的线程是否是活动线程：" + t.isAlive());
         System.out.println("运行doSome方法的线程是否是中断状态：" + t.isInterrupted());
         System.out.println("运行doSome方法的线程标识符：" + t.getId());
     }
 
 }
张禹垚
关注
  • 8
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSD-2204-API-创建Maven项目-WebServer(项目)-Day10
TheNewSystrm的博客
06-14 355
JSD-2204-API-创建Maven项目-WebServer(项目)-Day10
Core_V4.2_5.0_5.2 Mesh_V1.0.rar
12-24
《蓝牙技术核心规范详解——基于Core_V4.2、Core_V5.0及Core_V5.2和Mesh_V1.0》 蓝牙技术是无线通信领域的重要组成部分，它以其低功耗、短距离、易组网的特点，在物联网、智能家居、智能穿戴设备等领域广泛应用。...
core java--day22（网络编程实例6，udp）
qq_41533897的博客
09-14 154
复习： RandomAccessFile: 文件 seek(); getFilePorinter(); length(); byte[] but = new byte[end-start]; 序列化 : 把对象 写到 文件 ObjectOutputStream writeObject(); 反序列化 : 把文件对象 读取...
Java工作笔记/Java面试题/Java八股文/Java常用API
一位钟爱编程的小伙~
07-22 2268
Java工作笔记/Java面试题/Java八股文/Java常用API
Netty网络编程
yuzheh521的博客
12-04 252
【代码】Netty网络编程。
SitePoint播客＃23：Jeff Veen的网络字体
culi3182的博客
08-08 608
Episode 23 of The SitePoint Podcast is now available! This week, Kevin Yank (@sentience) has a one-on-one chat with Jeff Veen (@veen), one of the bright minds behind Typekit. A complete transcript of ...
Java面试宝典Beta5.0
cillent_boy的专栏
02-15 4309
pdf下载地址：Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 1. 面向对象都有哪些特性以及你对这些特性的理解 21 2. 访问权限修饰符public、private、protected, 以及不写（默认）时的区别(2017-11-12) 22 3. 如何理解clone对象 22 二、JavaSE语法（2017-11-12-wl） ...
linux系统/网络编程
sinat_24820331的博客
12-27 558
经典数据： APUE：unix环境高级编程3版 linux系统编程手册 德 linux系统编程 oreily unix内核源码剖析 日 windows核心编程 linux系统开发模式： ssh远程登录即可；vi； 企业中： 版本控制：把代码写到版本库中（svn/git）由库提交到服务器 重点：shell 进程线程 进程概念： 程序进程线程 写了程序，启动起
基于webSocket的聊天室
weixin_30596735的博客
02-05 133
前言 不知大家在平时的需求中有没有遇到需要实时处理信息的情况，如站内信，订阅，聊天之类的。在这之前我们通常想到的方法一般都是采用轮训的方式每隔一定的时间向服务器发送请求从而获得最新的数据，但这样会浪费掉很多的资源并且也不是实时的，于是随着HTML5的推出带来了websocket可以根本的解决以上问题实现真正的实时传输。 websocket是什么？ 至于websocket是什么、有什么用这样的...
OpenAI新开放了这些好用的API功能(附AI学习指南)
2401_85373898的博客
06-18 907
创建 Assistant 时定义函数：代码语言：javascript复制。
2_corejava18-22.rar_Java编程_Java_
08-12
"2_corejava18-22.rar_Java编程_Java_"这个压缩包文件包含了达内教育机构关于Java编程的第五天至第九天的教学内容，即Java基础的第18到22课。这些课程可能涵盖了Java语言的核心概念和关键特性，旨在帮助学习者深入...
Core Java SE.zip_JavaSE_API_java文档
09-20
它提供了丰富的API，包括集合框架、I/O流、多线程、网络编程、数据库连接（JDBC）、XML处理、GUI组件等，覆盖了软件开发的各个方面。 API（Application Programming Interface）文档是程序员在使用特定库或框架时的...
商业编程-源码-小袁在线留言板 v1.0.zip
06-23
《小袁在线留言板 v1.0》是一款专为商业编程设计的源代码程序，它提供了在网站上实现用户互动和信息交流的功能。这个压缩包包含了整个项目的源代码，允许开发者深入理解其工作原理，并根据实际需求进行定制和扩展。...
corejava-day01-am.zip_Windows编程_Java_
08-11
2 String API 有一个实现原则: 对象内容永远不变 也就是说: String对象永远不变. 3 String 字面量(直接量) 一个String对象的引用 为一个字符串. String s = new String("abc") 4 String 的比较 5 String API (字符...
JAVA进阶补充
2301_80150315的博客
08-15 1024
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 938
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
【Spring框架】
最新发布
m0_71941456的博客
08-18 980
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 487
【代码】springboot网上商品订单转手系统bootpf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值