网络编程_TCP通信综合练习：

news2024/10/5 4:30:55

1

image.png

//client：：
public class Client {
    public static void main(String[] args) throws IOException {
        //多次发送数据

        //创建socket对象,填写服务器的ip以及端口
        Socket s=new Socket("127.0.0.1",10000);

        //获取输出流
        OutputStream op = s.getOutputStream();

        //因为要不断发送数据，所以可以使用Sacnner录入数据，结合循环将数据发出去
        Scanner sc=new Scanner(System.in);
        while (true) {
            //键盘录入
            System.out.println("请输入一个数据");
            String str = sc.next();
            //如果输入886就退出发送
            if ("886".equals(str)){
                break;
            }
            op.write(str.getBytes());
        }
        //关流
        s.close();
    }
}
//Server：
public class Server {
    public static void main(String[] args) throws IOException {
        //不断接收
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        //等待客户端来连接
        Socket socket = ss.accept();
        //创建一个输入流对象
        InputStream is = socket.getInputStream();
        //转换流：字节转字符
        InputStreamReader isr = new InputStreamReader(is);

        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
        }
        //关流
        socket.close();//关闭通道
        ss.close();//关闭服务器

    }
}

先启动服务器，再启动客户端
控制台：
image.pngimage.png

2

image.png

//client
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端：发送一条数据，接收服务端反馈的消息并打印
        //服务器：接收数据并打印，再给客户端反馈消息



        //1.创建Socket对象并连接服务端
        Socket socket = new Socket("127.0.0.1",10000);


        //2.写出数据
        String str = "见到你很高兴！";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        //写出一个结束标记，（结束输出流）
        socket.shutdownOutput();


        //3.接收服务端回写的数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        while ((b = isr.read()) != -1){
            System.out.print((char)b);
        }


        //释放资源
        socket.close();


    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //客户端：发送一条数据，接收服务端反馈的消息并打印
        //服务器：接收数据并打印，再给客户端反馈消息


        //1.创建对象并绑定10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2.等待客户端连接
        Socket socket = ss.accept();

        //3.socket中获取输入流读取数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        //细节：
        //read方法会从连接通道中读取数据
        //但是，需要有一个结束标记，此处的循环才会停止
        //否则，程序就会一直停在read方法这里，等待读取下面的数据
        while ((b = isr.read()) != -1){
            System.out.println((char)b);
        }

        //4.回写数据
        String str = "到底有多开心？";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

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


    }
}

image.pngimage.png

3

image.png
下面的例子是传输图片，所以使用字节流

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

        //创建Socket对象连接服务器
        Socket s = new Socket("127.0.0.1", 10000);

        //读取图片文件：使用字节流
        //图片较大：使用缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\netcode\\clientdir\\a.jpg"));

        //在通道中获取字节流,输入数据到服务端
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        //边读边写
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //结束标识
        s.shutdownOutput();

        //接受服务端回馈：字节流-->字符流---->缓冲流
        BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

        int b;
        while((b=br.read())!=-1){
            System.out.print((char) b);
        }
        //关流
        s.close();
    }
}

//server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);
        //等待客户端连接
        Socket socket = ss.accept();

        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //输出到本地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\a.jpg"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //返回信息：字节流-->字符流---->缓冲流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        //关流
        socket.close();
        ss.close();
    }

}

image.pngimage.png

4.

image.png

//client
public class Client {
    public static void main(String[] args) throws IOException {

        //创建Socket对象连接服务器
        Socket s = new Socket("127.0.0.1", 10000);

        //读取图片文件：使用字节流
        //图片较大：使用缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\netcode\\clientdir\\a.jpg"));

        //在通道中获取字节流,输入数据到服务端
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        //边读边写
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //结束标识
        s.shutdownOutput();

        //接受服务端回馈：字节流-->字符流---->缓冲流
        BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

        int b;
        while((b=br.read())!=-1){
            System.out.print((char) b);
        }
        //关流
        s.close();
    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);
        //等待客户端连接
        Socket socket = ss.accept();

        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());

        //随机uuid、
        String str = UUID.randomUUID().toString().replace("-", "");
        //输出到本地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //返回信息：字节流-->字符流---->缓冲流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        //关流
        socket.close();
        ss.close();
    }

}

image.png

5.

image.png、
服务端不停止，用户端一直传
思路：可以在服务端使用循环嵌套：
如下：

public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);



        while (true) {
            //等待客户端连接
            Socket socket = ss.accept();

            //获取通道中传来的数据
            //字节流读取字节
            //缓冲流提升效率
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());

            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);//当第一个用户还在传输时，服务端代码还会在这不断循环
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();
            //关流
            socket.close();//断开当前通道
            //ss.close();//关闭服务器    ----这里不可以让服务器关闭
        }



    }
}

但是循环有弊端，它是一种单线程，如果说此时要传输的文件很大，当第一个用户还在传输时，服务端代码还会停止在第25行，此时就无法和第二个用户产生连接（只有完成一次循环后，才能和下一个用户进行数据连接），所以我们可以用多线程来改进。使多个用户可以同时传输数据，服务端也可以同时读取多个用户的数据

//多线程
public class MyThread  extends Thread{

    Socket socket;
     public MyThread (Socket socket){
         this.socket=socket;
     }


    @Override
    public void run() {
        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        try {
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            bw.write("上传成功");
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //5.释放资源
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //等待客户端连接
            Socket socket = ss.accept();
            new MyThread(socket).start();
            //ss.close();
        }

    }
}

//client....

6.

image.png
使用自定义线程池

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


        //1创建线程池对象
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程数量
                16,//线程池总大小
                60,//空闲时间
                TimeUnit.SECONDS,//单位
                new ArrayBlockingQueue<>(2),//队列
                Executors.defaultThreadFactory(),//线程工厂，让线程池如何创建线程对象
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略
        );

        //2创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //3等待客户端连接
            Socket socket = ss.accept();
            //开启一条线程
            //一个用户就对应服务端的一条线程

            //调用submit方法传入myRunnable对象
            pool.submit((new MyRunnable(socket)));
            //ss.close();
        }

    }
}
//MyRunnable
public class MyRunnable implements Runnable {

    Socket socket;
     public MyRunnable(Socket socket){
         this.socket=socket;
     }


    @Override
    public void run() {
        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        try {
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            bw.write("上传成功");
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //5.释放资源
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//client.....

7.

image.png

public class Server {
    public static void main(String[] args) throws IOException {
        //客户端：多次发送数据
        //服务器：接收多次接收数据，并打印

        //1.创建对象绑定10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2.等待客户端来连接
        Socket socket = ss.accept();

        //3.读取数据
        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        int b;
        while ((b = isr.read()) != -1){
            System.out.print((char)b);
        }

        //4.释放资源
        socket.close();
        ss.close();

    }
}

首先启动服务端：
再在浏览器输入：
image.png
获得到数据：
image.png

8.

image.png
client

package A;

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

public class Client1 {
    public static void main(String[] args) throws IOException {
        /**
         * 每一个客户端都是一个线程
         */


        while (true) {
            //1.与服务端建立连接
            Socket socket = new Socket("127.0.0.1", 10000);
            System.out.println("服务器已连接");
            //2生成聊天界面
            System.out.println("==============欢迎来到黑马聊天室================");
            System.out.println("1登录");
            System.out.println("2注册");
            System.out.println("请输入您的选择：");
            //3键盘录入
            Scanner sc = new Scanner(System.in);
            String choose = sc.nextLine();
            //判断：
            switch (choose) {
                case "1":
                    //登录逻辑
                    login(socket);
                    break;
                case "2":
                    //注册逻辑

                    break;
                default:
                    System.out.println("没有该选项");

            }
        }
    }

    /**
     * //登录
     *
     * @param socket
     * @throws IOException
     */
    private static void login(Socket socket) throws IOException {
        //1输入账户和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.nextLine();
        System.out.println("请输入密码");
        String password = sc.nextLine();

        //***登录要求使用username=zhangsan&password=123这种格式发给服务端
        //2拼接
        StringBuilder sb = new StringBuilder();
        sb.append("username=").append(username).append("&password=").append(password);

        //3提交给服务器验证
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //第一次是告诉服务器是此时登陆操作是什么
        bw.write("login");
        bw.newLine();//这两个要配套使用
        bw.flush();
        //第二次告诉服务器用户端输入的账号密码
        bw.write(sb.toString());
        bw.newLine();
        bw.flush();

        //接收服务端的回馈消息
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String message = br.readLine();

        if ("1".equals(message)) {
            System.out.println("登陆成功，可以开始聊天");

            //开一条单独的线程，专门用来接收服务端转发过来的聊天记录
            new Thread(new ClientMyRunnable(socket)).start();


            //将要说的话传给服务器，交给服务器转发给其他客户端
            talk2All(bw);
        } else if ("2".equals(message)) {
            System.out.println("密码不正确");
        } else {
            System.out.println("用户名不存在，请先注册");
        }
    }

    private static void talk2All(BufferedWriter bw) throws IOException {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你要说的话");
            String message = sc.nextLine();
            bw.write(message);
            bw.newLine();
            bw.flush();
        }


    }
}

class ClientMyRunnable implements Runnable {
    Socket socket;

    //构造
    public ClientMyRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        //循环包裹，不断读取服务端发过来的信息（接受群发消息）
        while (true) {
            try {
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String message = br.readLine();
                System.out.println(message);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

server

package A;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.Buffer;
import java.nio.file.attribute.UserPrincipal;
import java.util.ArrayList;
import java.util.Properties;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Server {
    //成员位置方便调用
  static  ArrayList<Socket>list=new ArrayList<>();

    public static void main(String[] args) throws IOException {
        //1创建ServerSocket对象，并连接10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2把本地文件中的正确用户名和密码都获取到
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("..\\Chat\\account.txt");
        prop.load(fis);
        fis.close();
        //只要来了一个客户端，就开一个条线程
        while (true) {
            //等待服务端连接
            Socket socket = ss.accept();
            System.out.println("有客户端来连接");
            //开始处理线程任务
            new Thread(new MyRunnable(socket, prop)).start();
        }
    }
}

//-----------------------------------------------------------------------
class MyRunnable implements Runnable {
    Socket socket;
    Properties prop;

    //构造
    public MyRunnable(Socket socket, Properties prop) {
        this.socket = socket;
        this.prop = prop;
    }

    @Override
    public void run() {
        /**
         * 每一个线程要做的事情
         */
        try {
            //1读取客户端传来的信息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //第一次读取的是用户的操作
            String choose = br.readLine();
            while (true) {
                switch (choose) {
                    case "login" -> login(br);
                    case "register" -> register();
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    /**
     * 1.获取用户端输入的帐号、密码
     * 2.与正确的账号密码比较
     * 3.写出不同情况的返回信息
     */
    public void login(BufferedReader br) throws IOException {
        System.out.println("用户执行了登陆操作");
        //第二次读取的是用户端传递过来的拼接信息：username=zhangsan&password=123
        String userInfo = br.readLine();
        //获取真正的账号密码：切割
        String s1 = userInfo.split("&")[0];
        String s2 = userInfo.split("&")[1];
        String usernameInput = s1.split("=")[1];
        String passwordInput = s2.split("=")[1];
        System.out.println("账号是：" + usernameInput);
        System.out.println("密码是：" + passwordInput);

        //比较
        if (prop.containsKey(usernameInput)) {
            //用户名一致，就比较密码
            //先获取当前正确密码
            String rellyPassword = (String) prop.get(usernameInput);
            if (passwordInput.equals(rellyPassword)) {
                //登陆成功，给用户端返回信息
                messageToClient("1");//登陆成功，可以开始聊天
                //登陆成功后需要将当前socket对象存储起来
                Server.list.add(socket);
                //接收客户端发送的信息并打印在控制台
                talk2All(br,usernameInput);
            } else {
                //密码不正确，给用户端返回信息
                messageToClient("2");//密码不正确

            }
        } else {
            //用户名不存在，给用户端返回信息：
            messageToClient("3");//用户名不存在，请先注册

        }
    }

    private void talk2All(BufferedReader br, String usernameInput) throws IOException {
        //聊天死循环
        while(true){
            //接收客户端发送的信息
            String message = br.readLine();
            System.out.println(usernameInput+"发送过来了消息："+message);

            //群发
            for (Socket s : Server.list) {
                //s以此表示每一个socket对象
                messageToClient(s,usernameInput+"发送过来了消息："+message);
            }
        }
    }


    /**
     *因为三种情况：登陆成功、密码不正确、用户名不存在都要返回信息给客户端，所以干脆抽取成方法
     * @param message
     */
    public void messageToClient(String message) throws IOException {
        //获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(message);
        bw.newLine();
        bw.flush();
    }

    /**
     * 重载的messageToClient
     * @param socket
     * @param message
     */
    public void messageToClient(Socket socket,String message) throws IOException {
        //获取输出流,将数据写给当前的socket通道对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(message);
        bw.newLine();
        bw.flush();
    }















    /**
     * 注册逻辑
     */
    private static void register() {
        System.out.println("用户执行了注册操作");
    }

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1457073.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python统计分析——一元线性回归分析

python统计分析——一元线性回归分析

参考资料&#xff1a;用python动手学统计学 1、导入库 # 导入库 # 用于数值计算的库 import numpy as np import pandas as pd import scipy as sp from scipy import stats # 用于绘图的库 import matplotlib.pyplot as plt import seaborn as sns sns.set() # 用于估计统计…
阅读更多...
【高效开发工具系列】PyCharm使用

【高效开发工具系列】PyCharm使用

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
vue3项目配置按需自动导入API组件unplugin-auto-import

vue3项目配置按需自动导入API组件unplugin-auto-import

场景应用&#xff1a;避免写一大堆的import&#xff0c;比如关于Vue和Vue Router的 1、安装unplugin-auto-import npm i -D unplugin-auto-import 2、配置vite.config import AutoImport from unplugin-auto-import/vite//按需自动加载API插件 AutoImport({ imports: ["…
阅读更多...
Unity中的Lerp插值的使用

Unity中的Lerp插值的使用

Unity中的Lerp插值使用 前言Lerp是什么如何使用Lerp 前言 平时在做项目中插值的使用避免不了&#xff0c;之前一直在插值中使用存在误区&#xff0c;在这里浅浅记录一下。之前看的博客或者教程还多都存在一个“永远到达不了&#xff0c;只能无限接近”的一个概念。可能是之前脑…
阅读更多...
ThreadLocal “你”真的了解吗？

ThreadLocal “你”真的了解吗？

今天想梳理一个常见的面试题。在开始之前&#xff0c;让我们一起来回顾一下昨天的那篇文章——《Spring 事务原理总结七》。这篇文章比较啰嗦&#xff0c;层次也不太清晰&#xff0c;所以以后有机会我一定要重新整理一番。这篇文章主要想表达这样一个观点&#xff1a;Spring的嵌…
阅读更多...
对于软件测试的理解

对于软件测试的理解

前言 “尽早的介入测试&#xff0c;遇到问题的解决成本就越低” 随着软件测试技术的发展&#xff0c;测试工作由原来单一的寻找缺陷逐渐发展成为预防缺陷&#xff0c;探索测试&#xff0c;破坏程序的过程&#xff0c;测试活动贯穿于整个软件生命周期中&#xff0c;故称为全程…
阅读更多...
【SpringBoot】项目启动增加自定义Banner

【SpringBoot】项目启动增加自定义Banner

SpringBoot项目启动增加自定义Banner 前言 最近有个老哥推荐我给博客启动的时候加上自定义Banner&#xff0c;开始我还不太明白他说的是那部分&#xff0c;后面给我发了这样一个&#xff0c;瞬间就懂了~ // _ooOoo_ …
阅读更多...
Python（九十三）函数的参数总结

Python（九十三）函数的参数总结

❤️ 专栏简介&#xff1a;本专栏记录了我个人从零开始学习Python编程的过程。在这个专栏中&#xff0c;我将分享我在学习Python的过程中的学习笔记、学习路线以及各个知识点。 ☀️ 专栏适用人群 &#xff1a;本专栏适用于希望学习Python编程的初学者和有一定编程基础的人。无…
阅读更多...
不要0！我们需要1！

不要0！我们需要1！

解法一&#xff1a; 十进制转二进制同时数1的个数 #include<iostream> #define endl \n using namespace std; void solve(int x) {int cnt 0;while (x) {if (x % 2 1) cnt;x / 2;}cout << cnt << endl; } int main() {int n;cin >> n;solve(n);re…
阅读更多...
2024-2-19 LC200. 岛屿数量

2024-2-19 LC200. 岛屿数量

其实还是用并查集将 独立的岛屿视为独立的子集。 count其实是集合的个数&#xff0c;同一个块岛屿被压缩成了一个集合&#xff0c;而每个表示海洋的格子依然被看作独立的集合&#xff0c;在所有的格子都走完一遍后&#xff0c;count 被压缩的岛屿 所有表示海洋的独立格子的数…
阅读更多...
2024.2.19

2024.2.19

使用fread和fwrite完成两个文件的拷贝 #include<stdio.h> #include<stdlib.h> #include<string.h> int main(int argc, const char *argv[]) {FILE *fpNULL;if((fpfopen("./tset.txt","w"))NULL){perror("open error");retur…
阅读更多...
免费白嫖一个互联网创业者交流论坛，真香！

免费白嫖一个互联网创业者交流论坛，真香！

先说最重要的 当前小报童39.9&#xff0c;2.23之后会涨价到99.9 现在扫码购买&#xff0c;然后凭借截图找我全款报销&#xff0c;全款报销&#xff01; 扫码报销&#xff0c;备注“烽狂创客” 下面来看下这个专栏的内容 专栏作者是谁 挽歌&#xff0c;20岁&#xff0c;985大…
阅读更多...
1. 处理日期和时间的 chrono 库

1. 处理日期和时间的 chrono 库

1. 处理日期和时间的 chrono 库 C11 中提供了日期和时间相关的库 chrono&#xff0c;通过 chrono 库可以很方便地处理日期和时间&#xff0c;为程序的开发提供了便利。chrono 库主要包含三种类型的类&#xff1a;时间间隔duration、时钟clocks、时间点time point。 1.1 基本常…
阅读更多...
[计算机网络]---Https协议

[计算机网络]---Https协议

前言 作者&#xff1a;小蜗牛向前冲 名言&#xff1a;我可以接受失败&#xff0c;但我不能接受放弃 如果觉的博主的文章还不错的话&#xff0c;还请点赞&#xff0c;收藏&#xff0c;关注&#x1f440;支持博主。如果发现有问题的地方欢迎❀大家在评论区指正 目录 一、https协…
阅读更多...
课上题目代码

课上题目代码

dijkstra和spfa区别 &#xff1a; dikstra是基于贪心的思想&#xff0c;每次选择最近的点去更新其它点&#xff0c;过后就不再访问。而在spfa算法中&#xff0c;只要有某个点的距离被更新了&#xff0c;就把它加到队列中&#xff0c;去更新其它点&#xff0c;所有每个点有被重…
阅读更多...
Java中的线程（创建多线程的三种方法）

Java中的线程（创建多线程的三种方法）

Java中的线程——创建 创建多线程方式一&#xff1a;继承Thread类方式二&#xff1a;实现Runnable接口方式三&#xff1a;实现Callable接口 线程的常用API 创建多线程 方式一&#xff1a;继承Thread类 定义一个子类MyThread继承线程类java.lang.Thread&#xff0c;重写run方法…
阅读更多...
vue3+ts项目搭建

vue3+ts项目搭建

⛰️个人主页: 蒾酒 &#x1f525;系列专栏&#xff1a;《vue3实战》 &#x1f30a;山高路远&#xff0c;行路漫漫&#xff0c;终有归途。 目录 前置条件 基础工程模板搭建 测试环境变量是否配置成功 初始化vue项目 安装常用依赖 基础项目目录介绍 前置条件 请确…
阅读更多...
自动化测试框架搭建全过程

自动化测试框架搭建全过程

前段时间写了一系列自动化测试相关的文章&#xff0c;当然更多的是方法和解决问题的思路角度去阐述我的一些观点。这篇文章来聊聊新手如何从零到一落地实践接口自动化测试。 为什么要做接口测试 测试理念的演变 早些时候&#xff0c;软件研发交付流程大多遵循V型或W型的瀑布…
阅读更多...
9、内网安全-横向移动Exchange服务有账户CVE漏洞无账户口令爆破

9、内网安全-横向移动Exchange服务有账户CVE漏洞无账户口令爆破

用途&#xff1a;个人学习笔记&#xff0c;有所借鉴&#xff0c;欢迎指正&#xff01; 背景&#xff1a; 在内网环境的主机中&#xff0c;大部分部署有Exchange邮件服务&#xff0c;对于Exchange服务的漏洞也是频出&#xff0c;在这种情况下&#xff0c;如果拿到内网中一台主机…
阅读更多...
2024 年 2 月 TIOBE 指数：最流行的 10 种编程语言

2024 年 2 月 TIOBE 指数：最流行的 10 种编程语言

Go 进入了 TIOBE 指数的前 10 名&#xff0c;这是谷歌编程语言有史以来的最高位置。 在 2024 年 2 月的 TIOBE 软件最受欢迎的编程语言列表中&#xff0c;Python、C 和 C 保持了它们的领先地位&#xff08;图 A&#xff09;。TIOBE 的专有积分系统考虑了根据多种大型搜索引擎&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023