java中网络编程

于 2021-05-19 14:36:27 发布
阅读量205 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35426012/article/details/117028880
版权
UDP通信

Java提供了DatagramSocket类作为基于UDP协议的Socket

构造方法

方法说明
DatagramSocket()创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名说明
void send(DatagramPacket p)发送数据报包
void close()关闭数据报套接字
void receive(DatagramPacket p)从此套接字接受数据报包

代码示例

发送端

import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class Client {

    public static void main(String[] args) throws IOException {
        //创建socket
        DatagramSocket datagramSocket = new DatagramSocket();
        Scanner scanner = new Scanner(System.in);
        while (true){
            String line = scanner.nextLine();
            if("886".equals(line)){
                break;
            }
            //打包数据包
            DatagramPacket datagramPacket = new DatagramPacket(line.getBytes(), line.length(), InetAddress.getByName("127.0.0.1"), 10000);
            //发送数据
            datagramSocket.send(datagramPacket);
        }
        //关闭发送端
        datagramSocket.close();

    }


}

接收端

import java.io.IOException;
import java.lang.reflect.Array;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Arrays;

public class Server {
    public static void main(String[] args) throws IOException {
        //创建接收端socket
        DatagramSocket datagramSocket = new DatagramSocket(10000);
        //接收缓存
        byte[] bytes=new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
        while (true){
            //清空数组
            Arrays.fill(bytes, (byte) 0);
            //接收数据
            datagramSocket.receive(datagramPacket);
            System.out.println("数据:"+new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
        }

        //关闭
//        datagramSocket.close();
    }
}
TCP

java为客户端提供了Socket类，为服务器端提供了ServerSocket类

  • 构造方法

    方法名说明
    Socket(InetAddress address,int port)创建流套接字并将其连接到指定IP指定端口号
    Socket(String host, int port)创建流套接字并将其连接到指定主机上的指定端口号

  • 相关方法

    方法名说明
    InputStream getInputStream()返回此套接字的输入流
    OutputStream getOutputStream()返回此套接字的输出流

  • 构造方法

    方法名说明
    ServletSocket(int port)创建绑定到指定端口的服务器套接字

  • 相关方法

    方法名说明
    Socket accept()监听要连接到此的套接字并接受它

代码示例
client
注意缓冲流要刷新或关闭对方才能获取到数据

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

public class Client {

    public static void main(String[] args) throws IOException {
        //创建客户端socke
        Socket socket = new Socket("127.0.0.1",10000);
        //获取输出流发送数据
        OutputStream outputStream = socket.getOutputStream();
        //使用转换流解决中文乱码
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream, "utf-8"));
        bufferedWriter.write("hello,在干嘛?");
        bufferedWriter.flush();
        //处理业务时如果没有发送结束标志,服务端会在read时读不到结束标志而一直等待接收数据,可以使用shutdownOutput来写结束标志
        socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
        //获取输入流读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        int b=0;
        while ((b=bufferedReader.read())!=-1){
            System.out.println((char)b);
        }
        System.out.println("client接收数据");
        //关流的的时候会发送一个结束标志
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
    }

}

server

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


public class Server {
    public static void main(String[] args) throws IOException {
        //创建服务器端socket
        ServerSocket serverSocket = new ServerSocket(10000);
        //等待连接并返回连接socket
        Socket accept = serverSocket.accept();
        //获取输入流读取数据
        InputStream inputStream = accept.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        int b=0;
        while ((b=bufferedReader.read())!=-1){
            System.out.println((char)b);
        }
        //获取输出流回写数据
        OutputStream outputStream = accept.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream, "utf-8"));
        bufferedWriter.write("hello,你是哪位?");
        bufferedWriter.newLine();
        bufferedWriter.flush();
        System.out.println("server发送数据");
        //关闭
        bufferedReader.close();
        bufferedWriter.close();
        accept.close();
        serverSocket.close();
    }
}

使用线程池实现文件上传功能
client

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

public class Client {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);
        //是本地的流,用来读取本地文件的
        BufferedInputStream bisFile = new BufferedInputStream(new FileInputStream("test\\ba1.jpg"));
        //网络流,写到服务器
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bosSocket = new BufferedOutputStream(os);
        int b;
        while((b = bisFile.read())!=-1){
            bosSocket.write(b);//通过网络写到服务器中
        }
        bosSocket.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();

        //接收服务器的消息
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(),"utf-8"));
        String line;
        while((line = br.readLine()) !=null){
            System.out.println(line);
        }
        //关闭
        bisFile.close();
        socket.close();
    }


}

thread

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

public class ThreadSocket implements Runnable {
    private Socket acceptSocket;

    public ThreadSocket(Socket accept) {
        this.acceptSocket = accept;
    }

    @Override
    public void run() {
        BufferedOutputStream bos = null;
        try {
            //网络中的流,从客户端读取数据的
            BufferedInputStream bisSocket = new BufferedInputStream(acceptSocket.getInputStream());
            //本地的IO流,把数据写到本地中,实现永久化存储
            bos = new BufferedOutputStream(new FileOutputStream("test\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));

            int b;
            while((b = bisSocket.read()) !=-1){
                bos.write(b);
            }
            //接收文件成功发送消息
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (acceptSocket != null){
                try {
                    acceptSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

server

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);
        //创建线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程数量
                10,   //线程池的总数量
                60,   //临时线程空闲时间
                TimeUnit.SECONDS, //临时线程空闲时间的单位
                new ArrayBlockingQueue<>(5),//阻塞队列
                Executors.defaultThreadFactory(),//创建线程的方式
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
        );

        while (true) {
            Socket accept = ss.accept();
            ThreadSocket ts = new ThreadSocket(accept);
            pool.submit(ts);
        }
    }
}
NIO

非阻塞IO实现
client

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Client {

    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2.指定IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",10000));
        //3.写出数据
        ByteBuffer byteBuffer = ByteBuffer.wrap("死亡如风,常伴吾身".getBytes("utf-8"));
        socketChannel.write(byteBuffer);
        // 手动写入结束标记,防止服务端读取不到结束标志而阻塞,从而不能循环处理新连接
//        socketChannel.shutdownOutput();
        System.out.println("数据已经写给服务器");
        // 4.读取服务器写回的数据
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        int len;
        while((len = socketChannel.read(byteBuffer2)) != -1){
            //因为要循环从buff读数据,所以要切换读写模式,切换为读模式
            byteBuffer2.flip();
            System.out.println(new String(byteBuffer2.array(),0,len,"utf-8"));
            //数据读写完毕,切换为写模式,因为循环要读数据到buff中,所以要切换为写
            byteBuffer2.clear();
        }
        //4.释放资源
        socketChannel.close();
    }


}

server

import java.io.*;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Server {
    public static void main(String[] args) throws IOException {
//        1.打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//        2.绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(10000));
//        3.通道默认是阻塞的，需要设置为非阻塞
        //如果传递true 表示通道设置为阻塞通道...默认值
        //如果传递false 表示通道设置为非阻塞通道
        serverSocketChannel.configureBlocking(false);
        while (true) {
//        5.如果有客户端来连接了，则在服务端通道内部，再创建一个客户端通道，相当于是客户端通道的延伸
            //此时已经设置了通道为非阻塞
            //所以在调用方法的时候,如果有客户端来连接,那么会创建一个SocketChannel对象.
            //如果在调用方法的时候,没有客户端来连接,那么他会返回一个null
            SocketChannel socketChannel = serverSocketChannel.accept();
            if(socketChannel != null){
                System.out.println("此时有客户端来连接了");
                //设置客户端连接通道为非阻塞的,从而read就不会因为没有结束标记而阻塞,设置非阻塞后read读完数据len返回0
                socketChannel.configureBlocking(false);
//        6.客户端将缓冲区通过通道传递给服务端,就到了这个延伸通道socketChannel里面
//        7.服务端创建一个空的缓冲区装数据并输出
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                //获取传递过来的数据,并把他们放到byteBuffer缓冲区中.
                //返回值:
                //正数: 表示本次读到的有效字节个数.
                //0   : 表示本次没有读到有效字节.
                //-1  : 表示读到了末尾
//                int len = socketChannel.read(byteBuffer);
//                System.out.println(new String(byteBuffer.array(),0,len,"utf-8"));
                int len;
                //针对于缓冲区来讲
                //如果 从添加数据 ----> 获取数据 flip
                //如果 从获取数据 ----> 添加数据 clear
                while((len = socketChannel.read(byteBuffer))>0){
                    //切换为读
                    byteBuffer.flip();
                    System.out.println(new String(byteBuffer.array(),0,len,"utf-8"));
                    //切换为写
                    byteBuffer.clear();
                }
                //会写数据到客户端
                System.out.println("接收数据完毕,准备开始往客户端回写数据");
                ByteBuffer byteBuffer2 = ByteBuffer.wrap("我蹭踏足山巅也曾跌落谷底!!!".getBytes("utf-8"));
                socketChannel.write(byteBuffer2);
                //8.释放资源
                socketChannel.close();
            }
        }
    }


}

阻塞IO：相当于你点了外卖后都是一直在门口等外卖，直到外卖送过来
非阻塞IO：相当于你点了外卖后，不在一直傻等，而是干一下别的事情，就跑到门口看看外卖到了没有。一直这样循环，直到我取到外卖，才从这个循环中跳出来

多路IO

多路IO:相当于你点外卖，请了一个门卫看着，外卖没来之前可以自己干自己的事情，如果外卖到了门卫会通知你去拿，

多路IO步骤

  1. 打开一个服务端通道(open)
  2. 绑定对应的端口号
  3. 通道默认是阻塞的，需要设置为非阻塞
  4. 打开一个选择器（门卫大爷）
  5. 将选择器绑定服务端通道，并监视服务端是否准备好
  6. 如果有客户端来连接了，大爷会遍历所有的服务端通道，谁准备好了，就让谁来连接
    连接后，在服务端通道内部，再创建一个客户端延伸通道
  7. 如果客户端把数据传递过来了，大爷会遍历所有的延伸通道，谁准备好了，谁去接收数据

client

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Client {

    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2.指定IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",10000));
        //3.写出数据
        ByteBuffer byteBuffer = ByteBuffer.wrap("死亡如风,常伴吾身".getBytes("utf-8"));
        socketChannel.write(byteBuffer);
        // 手动写入结束标记,防止服务端读取不到结束标志而阻塞,从而不能循环处理新连接
//        socketChannel.shutdownOutput();
        System.out.println("数据已经写给服务器");
        // 4.读取服务器写回的数据
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        int len;
        while((len = socketChannel.read(byteBuffer2)) != -1){
            //因为要循环从buff读数据,所以要切换读写模式,切换为读模式
            byteBuffer2.flip();
            System.out.println(new String(byteBuffer2.array(),0,len,"utf-8"));
            //数据读写完毕,切换为写模式,因为循环要读数据到buff中,所以要切换为写
            byteBuffer2.clear();
        }
        //4.释放资源
        socketChannel.close();
    }


}

server

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Server {
    public static void main(String[] args) throws IOException {
        //1.打开服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2.让这个通道绑定一个端口
        serverSocketChannel.bind(new InetSocketAddress(10000));
        //3.设置通道为非阻塞
        serverSocketChannel.configureBlocking(false);
        //4.打开一个选择器
        //Selector --- 选择器
//        SelectionKey --- 绑定通道后返回那个令牌
        //      SelectableChannel --- 可以使用选择器的通道
        Selector selector = Selector.open();
        //5.绑定选择器和服务端通道
        //将Channel注册到给定的Selector sel上，并指定注册的事件类型(SelectionKey.OP_READ,OP_WRITE,OP_CONNECT,OP_ACCEPT等)
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while(true){
            //选择器会监视客户端通道的状态.
            //6.返回值就表示此时有多少个客户端来连接
            //阻塞直到注册在Selector中的Channel 发送可读写事件(或其他注册事件)
            int count = selector.select();
            if(count != 0){
                System.out.println("有事件发生了");
                //7.会遍历所有的服务端通道.看谁准备好了,谁准备好了,就让谁去连接.
                //获取所有服务端通道的令牌,并将它们都放到一个集合中,将集合返回.
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while(iterator.hasNext()){
                    //selectionKey 依次表示每一个服务端通道的令牌
                    SelectionKey selectionKey = iterator.next();
                    if(selectionKey.isAcceptable()){
                        //可以通过令牌来获取到了一个已经就绪的服务端通道
                        ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                        //客户端的延伸通道
                        SocketChannel socketChannel = ssc.accept();
                        //将客户端延伸通道设置为非阻塞的
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector,SelectionKey.OP_READ);
                        //当客户端来连接的时候,所有的步骤已经全部执行完毕.
                    }else if(selectionKey.isReadable()){
                        //当前通道已经做好了读取的准备(延伸通道)
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer byteBuffer1 = ByteBuffer.allocate(1024);
                        int len;
                        while((len = socketChannel.read(byteBuffer1)) > 0){
                            byteBuffer1.flip();
                            System.out.println(new String(byteBuffer1.array(),0,len));
                            byteBuffer1.clear();
                        }
                        //给客户端的回写数据
                        socketChannel.write(ByteBuffer.wrap("你装啥呢!!!".getBytes("utf-8")));
                        socketChannel.close();
                    }
                    iterator.remove();
                }
            }
        }
    }


}
code_greenhand
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java网络编程
03-03
在本资料中，《Java网络编程》第三版提供了深入浅出的讲解，旨在帮助开发者提升对这一领域的理解。 1. **基础概念**： - **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络...
Android-Socket通信
dream_xang的博客
10-23 301
Android-Socket通信 Socket通信的应用 编写一个Socket连接的工具类SocketConnect，其中handle是用来传递连接状态的。 import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStre...
Socket编程之TCP的简单实现
weixin_41556165的博客
10-29 281
Client import java.io.*; import java.net.Inet4Address; import java.net.InetSocketAddress; import java.net.Socket; public class Client { public static void main(String[] args) throws IOException {...
Socket通信问题
我是你庆歌的博客
04-09 257
客户端 用byte格式传Socket Thread.sleep(3000); //隔一段时间 Socket socket = new Socket();//创建Socket socket.connect(new InetSocketAddress("192.168.40.95",9500));//连接Socket OutputStream outputStream = socket.get...
java点滴之InetAddress类和InetSocketAddress的使用
lingli219的专栏
11-11 965
一简介 InetAddress是Java对IP地址的封装，代表互联网协议（IP）地址； InetAddress对象的获取只能通过静态方法，比如根据主机名获取主机的ip地址封装对象： ? 1 InetAddress add=InetAddress.getByName("BOPZKQZ9SSY5ECY"); 主机名：BOP
Socket编程之 TCP/IP协议实战
qq_30347133的博客
07-11 212
https://www.cnblogs.com/-maji/p/7225640.html
java网络编程http通信
06-14
通过java网络编程深入理解http非阻塞通信和阻塞通信，以及http协议在网络中的应用 源码包每一行都有注释，在代码里面每一个类都有详细的注释来解释这个类的功能这个方法的功能，调用哪一个类的哪一个功能等等。 压缩...
Java网络编程
10-12
Java网络编程是软件开发中的一个重要领域，特别是在分布式系统和互联网应用程序中不可或缺。它涉及通过网络进行数据通信，包括客户端和服务器之间的交互。本主题主要涵盖了Java语言在网络编程方面的核心概念和技术。...
初入网络编程之socket
qq_38009686的博客
12-16 129
Socket服务端 Service import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintStream; import java.net.ServerSocket; import java.net.Socket; /** *...
SOCKET
weixin_42446419的博客
08-28 141
Socket Socket实际上就是IP +协议+port 位于应用层和传输层的一个抽象层 TCP中的socket
Socket
qq_40826814的博客
04-02 440
TCP 核心 API 讲解 socket()：创建一个客户端 Socket。 bind()：绑定一个 Socket 到一个本地地址和端口上。 accept()：服务器端接受一个新的连接。 write()：把数据写入到 Socket 输出流。 read()：从 Socket 输入流中读取数据。 TCP 基础数据传输案例代码 publicclassServer{ privatestaticfinalintPOR...
【socket】 超时连接
myblogzz的博客
08-15 1730
Java socket有两种timeout ：      建立连接timeout，      读取数据timeout， 注意：如果想实现超时连接，需要采用一下方式进行socket连接             Socket socket = null;             socket=new Socket();             socket.connect(new InetS...
qt练习控件label控件-lineEdit控件样例代码
07-30
qt练习控件label控件-lineEdit控件样例代码
【JCR一区级】麻雀搜索算法SSA-CNN-LSTM-Attention故障诊断分类预测【含源码 5689期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Attention分类系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Attention分类 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Attention分类 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Attention分类 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Attention分类 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Attention分类
详解MATLAB Simulink通信系统建模与仿真
07-30
第1 章 MATLAB 基础与通信系统仿真 1.1 MATLAB 简介 1.2 MATLAB 程序设计 1.3 通信系统仿真 第2 章 Simulink 仿真基础 2.1 Simulink 简介 2.2 Simulink 工作环境 2.3 Simulink 仿真的基本方法 2.4 创建自己的模块库 2.5 S-函数的编写 第3 章 通信信号与系统分析 3.1 离散信号和系统 3.2 Fourier 分析 3.3 带通信号的低通等效 3.4 随机信号分析 第4 章 信道 4.1 加性高斯白噪声信道 4.2 多径衰落信道 第5 章 模拟调制 5.1 幅度调制 5.2 角度调制 第6 章 数字基带传输 6.1 概述 6.2 二进制基带信号传输 6.3 基带PAM 信号传输 6.4 带限信道的信号传输 第7 章 数字信号载波传输 7.1 概述 7.2 载波幅度调制（PAM） 7.3 载波相位调制（PSK） 7.4 正交幅度调制（QAM） 7.5 载波频率调制（FSK） 第8 章 信道编码和交织 8.1 概述 8.2 线性分组码
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
2020年首届“洪泽湖杯”中国人工智能掼蛋算法大赛第8名我就是掼蛋.zip
07-30
毕业设计是高等教育阶段学生完成学业的一个重要环节，通常在学士或硕士学业即将结束时进行。这是学生将在整个学业中所学知识和技能应用到实际问题上的机会，旨在检验学生是否能够独立思考、解决问题，并展示其专业能力的一项综合性任务。 毕业设计的主要特点包括： 独立性： 毕业设计要求学生具备独立思考和解决问题的能力。学生需要选择一个合适的课题，研究相关文献，进行实地调查或实验，并提出独立见解。 实践性： 毕业设计是将理论知识应用到实际问题中的一次实践。通过完成毕业设计，学生能够将所学的专业知识转化为实际的解决方案，加深对专业领域的理解。 综合性： 毕业设计往往要求学生运用多个学科的知识，综合各种技能。这有助于培养学生的综合素养，提高他们的综合能力。 导师指导： 学生在毕业设计过程中通常由一名指导老师或导师团队提供指导和支持。导师负责引导学生确定研究方向、制定计划、提供建议，并在整个过程中监督进展。 学术规范： 毕业设计要求学生按照学术规范完成研究，包括文献综述、研究设计、数据采集与分析、结论和讨论等环节。学生需要撰写一篇完整的毕业论文，并进行答辩。
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
最新发布
07-30
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听 效果截图https://www.diyiyuanma.cn/3444.html 多站合一音乐搜索解决方案，数据调用的是各网站的API接口， 有的接口并不是开放的，随时可能失效，本项目相关代码仅供参考。 网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具
07-30
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具。
Java网络高级编程入门指南
"《最新Java网络编程》是殷兆麟、张永平、姜淑娟编著的一本高等学校计算机科学与技术教材，专注于讲解Java在网络编程中的应用，适合初学者。书中涵盖了网络进程通信、RMI、CORBA、Web技术（如JavaBean、Servlet、JSP...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值