NIO编程基础

最新推荐文章于 2023-05-28 22:13:08 发布
最新推荐文章于 2023-05-28 22:13:08 发布
阅读量126 收藏
点赞数
分类专栏： NIO与Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_zero/article/details/104735339
版权

1. NIO概述

1.1 什么是NIO?

Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。

Java NIO: Channels and Buffers（通道和缓冲区）
标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。

Java NIO: Non-blocking IO（非阻塞IO）
Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。

Java NIO: Selectors（选择器）
Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

注意:传统IO是单向传输, NIO中的缓冲区是双向可复用的。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.2 IO和NIO区别

IONIO
面向流面向缓冲区
阻塞IO非阻塞IO
无选择器

2. Buffer的数据存取

一个用于特定基本数据类行的容器。有java.nio包定义的，所有缓冲区都是抽象类Buffer的子类。
Java NIO中的Buffer主要用于与NIO通道进行交互，数据是从通道读入到缓冲区，从缓冲区写入通道中的。
Buffer就像一个数组，可以保存多个相同类型的数据。根据类型不同（boolean除外），有以下Buffer常用子类：

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

2.1 Buffer的概述

  1. 容量（capacity）：表示Buffer最大数据容量，缓冲区容量不能为负，并且建立后不能修改。
  2. 限制（limit）：第一个不应该读取或者写入的数据的索引，即位于limit后的数据不可以读写。缓冲区的限制不能为负，并且不能大于其容量（capacity）。
  3. 位置（position）：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制（limit）。
  4. 标记（mark）与重置（reset）：标记是一个索引，通过Buffer中的mark()方法指定Buffer中一个特定的position，之后可以通过调用reset()方法恢复到这个position。
/**
 * @Auther: 洺润Star
 * @Date: 2020/3/9 11:41
 * @Description:NIO
 * 一：(缓冲区)buffer 用于NIO存储数据 支持多种不同的数据类型
 * 1.byteBuffer
 * 2.charBuffer
 * 3.shortBuffer
 * 4.IntBuffer
 * 5.LongBuffer
 * 6.FloatBuffer
 * 7.DubooBuffer
 *
 * 二、缓冲区核心的方法
 * put 存入数据到缓冲区
 * get 获取缓冲区数据
 * flip 开启读模式
 *
 * 三、缓冲区核心属性
 * capacity:缓冲区最大容量，一旦声明不能改变。
 * limit:界限(缓冲区可以操作的数据大小) limit后面的数据不能读写。
 * position:缓冲区正在操作的位置
 */
public class Test01NIO {
    public static void main(String[] args) {
        System.out.println("-------------指定缓冲区大小---------------");
        //1. 指定缓冲区大小
        ByteBuffer allocate = ByteBuffer.allocate(1024);
        System.out.println(allocate.position());//0
        System.out.println(allocate.limit());//1024
        System.out.println(allocate.capacity());//1024
        //2. 向缓冲区存放五个数据
        allocate.put("abcd1".getBytes());
        System.out.println("-------------向缓冲区存放5个数据---------------");
        System.out.println(allocate.position());//5
        System.out.println(allocate.limit());//1024
        System.out.println(allocate.capacity());//1024
        //3. 开启读模式
        allocate.flip();
        System.out.println("-------------开启读模式---------------");
        System.out.println(allocate.position());//0
        System.out.println(allocate.limit());//5
        System.out.println(allocate.capacity());//1024
        byte[] bytes = new byte[allocate.limit()];
        allocate.get(bytes);
        System.out.println(new String(bytes,0,bytes.length));//abcd1
        //4. 开启重复度模式
        allocate.rewind();
        System.out.println("-------------开启重复度读模式---------------");
        System.out.println(allocate.position());//0
        System.out.println(allocate.limit());//5
        System.out.println(allocate.capacity());//1024
        byte[] bytes2 = new byte[allocate.limit()];
        allocate.get(bytes2);
        System.out.println(new String(bytes2,0,bytes2.length));//abcd1
        // 5.clean 清空缓冲区  数据依然存在,只不过数据被遗忘
        System.out.println("-------------清空缓冲区---------------");
        allocate.clear();
        System.out.println(allocate.position());//0
        System.out.println(allocate.limit());//1024
        System.out.println(allocate.capacity());//1024
        System.out.println((char)allocate.get());//a
    }
}

输出结果：
在这里插入图片描述
注意：

  1. flip()和 rewind()的区别在于前者会直接从位置0开始读取，后者则会从上次读取的位置开始读取;
  2. 可以看到开启读模式前可用大小limit为1024，开启读模式后就变成了5（存放了字节的大小），而如果不开启读模式进行读取就会发生读取错误，如下：
    在这里插入图片描述

2.2 mark与reset用法

标记（mark）与重置（reset）：标记是一个索引，通过Buffer中的mark()方法指定Buffer中一个特定的position，之后可以通过调用reset()方法回到这个position。

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/9 14:51
 * @Description:mark 和reset
 */
public class Test02NIO {
    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        String str = "abcd1";
        byteBuffer.put(str.getBytes());
        //开启读模式
        byteBuffer.flip();
        byte[] bytes = new byte[byteBuffer.limit()];
        byteBuffer.get(bytes,0,2);
        byteBuffer.mark();//标记位置
        System.out.println(new String(bytes, 0, 2));//ab
        System.out.println(byteBuffer.position());//2

        byteBuffer.get(bytes, 2, 2);
        System.out.println(new String(bytes, 2, 2));//cd
        System.out.println(byteBuffer.position());//4

        byteBuffer.reset();
        System.out.println("使用reset重置恢复到mark位置..");
        System.out.println(byteBuffer.position());//2
    }
}

3. 直接缓冲区与非直接缓冲区别

非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中，程序要执行写操作需要将JVM中缓存区拷贝到物理内存中，然后再写到物理磁盘中，反过来就是读操作，由于存在一次拷贝过程所以效率较慢
在这里插入图片描述

直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中，程序和物理磁盘间做读写操作的时候将不会走物理内存和JVM内存，而是直接从物理内存映射文件进行读取，效率更高。直接缓冲区于非直接相比会更加占用内存空间，而且安全性不如后者。

注：IO使用的缓存区为非直接缓冲区。
在这里插入图片描述
字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。

直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。

直接字节缓冲区还可以通过 FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer 。 Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

3.1 通道(Channel)的原理获取

通道表示打开到 IO 设备(例如：文件、套接字)的连接。
若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。
Channel 负责传输， Buffer 负责存储。通道是由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

java.nio.channels.Channel 接口：
  		|--FileChannel
  		|--SocketChannel
  		|--ServerSocketChannel
  		|--DatagramChannel

获取通道

  1. Java 针对支持通道的类提供了 getChannel() 方法
    本地 IO：
    FileInputStream/FileOutputStream
    RandomAccessFile

    网络IO：
    Socket
    ServerSocket
    DatagramSocket

  2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()

  3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()

@Test
// 使用直接缓冲区完成文件的复制(內存映射文件)
public void test2() throws IOException {
	FileChannel inChannel = FileChannel.open(Paths.get("1.png"), StandardOpenOption.READ);
	FileChannel outChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.READ, StandardOpenOption.WRITE,
			StandardOpenOption.CREATE);
	// 映射文件
	MappedByteBuffer inMapperBuff = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
	MappedByteBuffer outMapperBuff = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
	// 直接对缓冲区进行数据读写操作
	byte[] dst = new byte[inMapperBuff.limit()];
	inMapperBuff.get(dst);
	outMapperBuff.put(dst);
	outChannel.close();
	inChannel.close();
}

@Test
// 1.利用通道完成文件复制(非直接缓冲区)
public void test1() throws IOException {
	FileInputStream fis = new FileInputStream("1.png");
	FileOutputStream fos = new FileOutputStream("2.png");
	// ①获取到通道
	FileChannel inChannel = fis.getChannel();
	FileChannel outChannel = fos.getChannel();

	// ②分配指定大小的缓冲区
	ByteBuffer buf = ByteBuffer.allocate(1024);
	while (inChannel.read(buf) != -1) {
		buf.flip();// 切换到读取模式
		outChannel.write(buf);
		buf.clear();// 清空缓冲区
	}
	// 关闭连接
	outChannel.close();
	inChannel.close();
	fos.close();
	fis.close();
}

3.2 直接缓冲区与非直接缓冲耗时计算

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/9 16:01
 * @Description:通道的使用， 并测试直接和非直接缓冲区的速度差别
 */
public class Test03Channel {
    // 1.利用通道完成文件复制(非直接缓冲区)
    @Test
    public void m1() throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fileInputStream  = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test.mp4");
        FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test2.mp4");

        //获取通道
        FileChannel inputStreamChannel = fileInputStream.getChannel();
        FileChannel OutputStreamChannel = fileOutputStream.getChannel();
        //指定缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (inputStreamChannel.read(byteBuffer)!=-1){
            byteBuffer.flip();//切换读取模式
            OutputStreamChannel.write(byteBuffer);
            byteBuffer.clear();//清空缓冲区
        }
        //关闭连接
        OutputStreamChannel.close();
        inputStreamChannel.close();
        fileOutputStream.close();
        fileInputStream.close();
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:"+(endTime-startTime));//3276 3328 3323
    }

    //使用直接缓冲区完成文件的复制（内存映射文件）
    @Test
    public void m2() throws IOException {
        long startTime = System.currentTimeMillis();
        FileChannel inChannel = FileChannel.open(Paths.get("C:\\Users\\Administrator\\Desktop\\test.mp4"), StandardOpenOption.READ);
        FileChannel outChannel = FileChannel.open(Paths.get("C:\\Users\\Administrator\\Desktop\\test.mp4"),
                StandardOpenOption.READ, StandardOpenOption.WRITE,
                      StandardOpenOption.CREATE);

        // 映射文件
        MappedByteBuffer inMapperBuff = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
        MappedByteBuffer outMapperBuff = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

        // 直接对缓冲区进行数据读写操作
        byte[] dst = new byte[inMapperBuff.limit()];
        inMapperBuff.get(dst);
        outMapperBuff.put(dst);
        outChannel.close();
        inChannel.close();
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:"+(endTime-startTime));//602 578 626
    }
}

结果：
选取了大小为两百兆的视频文件，两种方式各测三次，结果为3276 3328 3323毫秒和602 578 626毫秒

3.3 分散读取与聚集写入

分散读取(scattering Reads)：将通道中的数据分散到多个缓冲区中
在这里插入图片描述
聚集写入(gathering Writes)：将多个缓冲区的数据聚集到通道中
在这里插入图片描述

/**
 * @Auther: 洺润Star
* @Description:分散读取&聚集写入
 */
public class Test04ScatteringGathering {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("test.txt", "rw");
        //1. 获取通道
        FileChannel channel = raf1.getChannel();
        // 2.分配指定大小的指定缓冲区
        ByteBuffer buf1 = ByteBuffer.allocate(100);
        ByteBuffer buf2 = ByteBuffer.allocate(1024);
        ByteBuffer[] byteBuffers = {buf1,buf2};
        channel.read(byteBuffers);
        for (ByteBuffer byteBuffer : byteBuffers) {
            // 切换为读取模式
            byteBuffer.flip();
        }
        System.out.println(new String(byteBuffers[0].array(), 0, byteBuffers[0].limit()));
        System.out.println("------------------分散读取--------------------");
        System.out.println(new String(byteBuffers[1].array(), 0, byteBuffers[1].limit()));
        // 聚集写入
        RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
        FileChannel channel2 = raf2.getChannel();
        channel2.write(byteBuffers);
    }
}

4. 字符集 Charset

编码：字符串->字节数组
解码：字节数组 -> 字符串

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/9 17:32
 * @Description:编码&解码
 */
public class Test05Encoder {
    public static void main(String[] args) throws CharacterCodingException {
        Charset cs1 = Charset.forName("GBK");
        // 获取编码器
        CharsetEncoder ce = cs1.newEncoder();
        // 获取解码器
        CharsetDecoder cd = cs1.newDecoder();
        CharBuffer cBuf = CharBuffer.allocate(1024);
        cBuf.put("今天明天后天!");
        cBuf.flip();
        // 编码
        ByteBuffer bBuf = ce.encode(cBuf);
        for (int i = 0; i < 12; i++) {
            System.out.println(bBuf.get());
        }
        // 解码
        bBuf.flip();
        CharBuffer cBuf2 = cd.decode(bBuf);
        System.out.println(cBuf2.toString());
        System.out.println("-----------------尝试使用不同的解码器--------------------");
        Charset cs2 = Charset.forName("GBK");
        bBuf.flip();
        CharBuffer cbeef = cs2.decode(bBuf);
        System.out.println(cbeef.toString());
    }
}
洺润
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NIO编程实现实例
02-21
4. **NIO编程流程**： - 打开通道：根据需求创建FileChannel、SocketChannel或ServerSocketChannel。 - 创建缓冲区：根据需要处理的数据类型创建对应的Buffer实例。 - 读写数据：使用通道与缓冲区交互，将数据从...
java编程基础教程
11-10
Java编程基础教程是初学者踏入Java世界的一把钥匙，它涵盖了所有必要的基础知识，旨在帮助学习者建立起坚实的编程技能。这个教程以清晰、易懂的方式展开，确保初学者能够轻松理解和应用所学知识。 首先，Java编程...
IO 的基本概念
mycsdnhmk的博客
08-13 4865
io 是上面 是以流为基础进行数据的输入输出。通俗点说就是java通过数据流方式和外部进行通讯 I/O中数据的操作是通过流的方式，我们可以把数据流看成水流一样，他可以从一个源头端流入到另一个目的端，且水流不是一次全部到达，而且连续的流入目的端。I是指从外部设备的数据流流入java程序的流。o是指从java程序中把数据流输出到其他设备中的流 IO操作的2个步骤： 1、准备数据 2、把数据从内核中拷贝到程序进程 io的四种模型 首先先了解同步和阻塞的概念 阻塞与非阻塞 主要表现再一个IO操作的过程中，列入读
【IO】概述
yhl_jxy的博客
02-06 648
一输入和输出原理Java的核心库java.io提供了全面的IO接口，但是并不是所有的IO接口。Java的IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读取。术语"输入"和"输出"一般让人很迷惑，输入是什么?输出又是什么?要理解输入和输出需要选择一个参考点，才能确定动的方向，我们可以选择内存作为参考点来理解输入和输出，则输入就可以理解为向内存输入，而输出就可以理解为从内...
关于STM32 __IO 的变量定义
wangzi201368的博客
07-29 3238
这个_IO 是指静态 这个 _IO 是指静态 volatile uint32_t 是指32位的无符号整形变量uint32_t 是指32位的无符号整形变量； 搞stm32这么久了，经常看到stm32里面库文件里面有用“_IO”定义的变量，查过一下当时记住了，过段时间又给忘记了。所以才特意的写一个博文来记住。 volatile volatile 类型是这样的，其数据确实可能在未知的情况下发生变...
JavaNIO编程基础-图解JavaNIO内存模型
javaThinker的专栏
07-15 546
1、网络通信基础 网络通信就是客户端和服务端发送和接收数据的过程 计算机主机通信 一个客户端要发起一次网络通信，必须先知道服务端的IP地址，然后 “网络基础设施” 通过 IP 地址将客户端发送的信息传递到 IP 地址对应的主机上。 通过 IP 可以找到主机，但将消息发送到主机中的具体应用程序需要通过端口号 2、JavaNIO 网络通信 上面提到的概念，在Java中都有其对应的抽象 比如： 1、InetSocketAddress 抽象了IP
一、java基础之nio编程
码农小默
01-14 261
一、什么是nio 1.NIO是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，NIO提供了与标准IO不同的IO工作方式，NIO: Channels and Buffers（通道和缓冲区） 二、nio与io的对比 IO NIO 面向流 面向缓冲区 阻塞IO ...
nio编程基础之 buffer缓冲区的应用
lemonlhy的博客
02-28 202
import java.io.IOException; import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class Test { public static void main(String[] args) throws IOExc...
NIO编程总结
赵睿宇的博客
05-28 759
selecto是NIO的选择器，NIO的同步功能就是靠selector来实现的，多个channel可以注册到同一个selector上，然后用一个线程来管理一个selector选择器，就实现了通过一个线程来管理多个通道实现客户端同步请求的效果。我们可以将Server端的监听连接请求的事件和处理请求的事件放在一个线程中，但是在事件应用中，我们通常会把它们放在两个线程中：一个线程专门负责监听客户端的连接请求（OP_ACCEPT），而且是以阻塞方式执行的；
java nio 编程_JAVA NIO编程入门（一）
weixin_35782250的博客
02-15 134
一、前言笔者之前接触的NIO编程比较少，所以对这一块的基础也比较弱，NIO作为java编程中一个重要的模块，不能很好的掌握它，感觉自己在java方面就掌握的不够，所以，接下来，笔者会学习NIO编程，所以，该系列文章不会涉及到很深源码解析，纯粹的是学习课程，也可以理解为笔者的笔记，记录学习NIO的过程，同时也希望这类文章可以对同样想掌握NIO编程的你有帮助。二、什么是NIO？Java NIO(New...
Java NIO 通信基础
sfklyqh的博客
09-30 636
实现IO多路复用，从具体的开发层面来说，首先把通道注册到选择器中，然后通过选择器内部的机制，可以查询（select）这些注册的通道是否有已经就绪的IO事件（例如可读、可写、网络连接完成等）。通道的写入，就是将数据从缓冲区写入到通道中。OIO是面向字节流或者字符流的，在一般的OIO操作中，我们以流式的方式顺序地从一个流中读取一个或多个字节，因此，我们不能随意地改变读取指针的位置。在NIO中，同一个网络连接用一个通道表示，所有的IO操作都是从通道开始的，既可以从通道读取，也可以向通道写入。
传统BIO编程模型及NIO编程模型源码
01-04
**NIO编程模型** NIO（Non-blocking I/O，非阻塞I/O）是Java 1.4引入的新特性，它提供了一种不同于BIO的I/O操作方式。在NIO中，系统不再直接将数据从内核空间传输到用户空间，而是通过缓冲区（Buffer）进行数据交换...
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
最新发布
07-19
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
【BP回归预测】龙格库塔算法优化BP神经网络RUN-BP光伏数据预测（多输入单输出）【含Matlab源码 5171期】.zip
07-19
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 科研合作 智能优化算法优化BP神经网络分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化BP 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化BP 4.4.3 灰狼算法GWO/狼群算法WPA优化BP 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化BP 4.4.5 萤火虫算法FA/差分算法DE优化BP 4.4.6 其他优化算法优化BP
在UCA上结合DOA估计算法和自适应波束形成matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于海鸥优化算法SOA-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档
07-19
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 采用全新的计算机网络和管理系统，将成为提高KTV管理效率，改善服务水准的重要手段之一。所以城市KTV包房信息管理系统是KTV经营不可缺少的现代工具。系统的主要功能包括：会员管理、类别管理、包房管理、预订管理。 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
Java NIO编程入门与实践：教程与示例
1. **Java NIO基础** - **缓冲区（Buffers）**: Buffer是NIO的核心组件，它们用于临时存储数据，包括ByteBuffer，可以进行读写操作，如示例中的缓冲区创建和使用。 - **通道（Channels）**: Channels代表了I/O连接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值