【NIO】

最新推荐文章于 2024-10-30 10:20:22 发布
最新推荐文章于 2024-10-30 10:20:22 发布
阅读量652 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmcxmc___/article/details/123772387
版权

什么是NIO

IO回顾

  • IO：Input OutPut（输入 输出）
  • IO技术的作用：解决设备和设备之间的数据传输问题
  • IO的应用场景：图片上传、下载、打印机打印信息表、解析XML…

概念

  • 即 Java New IO
  • 是1个全新的、 JDK 1.4后提供的 IO API
  • Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO

作用

  • NIO和IO有相同的作用和目的，但实现方式不同
  • 可替代 标准Java IO 的IO API
  • IO是以流的方式处理数据，而NIO是以块的方式处理数据。

流与块的比较

  • NIO和IO最大的区别是数据打包和传输方式。
  • IO是以流的方式处理数据，而NIO是以块的方式处理数据。
  • 面向流的IO一次一个字节的处理数据，一个输入流产生一个字节，一个输出流就消费一个字节。
  • 面向块的IO系统以块的形式处理数据。每一个操作都在一步中产生或消费一个数据块。按块要比按流快的多

新特性

对比于 Java IO，NIO具备的新特性如下：

IONIO
面向流(Stream Oriented)面向缓冲区(Buffer Oriented)
阻塞IO(Blocking IO)非阻塞(Non Blocking IO)
/选择器(Selectors)
  • 可简单认为：IO是面向流的处理，NIO是面向块(缓冲区)的处理
  • 面向流的I/O 系统一次一个字节地处理数据
  • 一个面向块(缓冲区)的I/O系统以块的形式处理数据

核心组件

Java NIO的核心组件 包括：

  • 通道（Channel）
  • 缓冲区（Buffer）
  • 选择器（Selector）

在NIO中并不是以流的方式来处理数据的，而是以buffer缓冲区和Channel管道配合使用来处理数据。

Selector是因为NIO可以使用异步的非阻塞模式才加入的东西

简单理解一下：

  • Channel管道比作成铁路，buffer缓冲区比作成火车(运载着货物)
    而我们的NIO就是通过Channel管道运输着存储数据的Buffer缓冲区的来实现数据的处理！
  • Channel不与数据打交道，它只负责运输数据。与数据打交道的是Buffer缓冲区
  • 相对于传统IO而言，流是单向的。对于NIO而言，有了Channel管道这个概念，我们的读写都是双向的

Buffer缓冲区

Buffer缓冲区概述

作用：缓冲区，用来存放具体要被传输的数据，比如文件、scoket 等。这里将数据装入 Buffer 再通过通道进行传输。

Buffer 就是一个数组，用来保存不同数据类型的数据

在 NIO 中，所有的缓冲区类型都继承于抽象类 Buffer，最常用的就是 ByteBuffer，对于 Java 中的基本类型，基本都有一个具体 Buffer 类型与之相对应，它们之间的继承关系如下图所示
在这里插入图片描述

  • ByteBuffer：存储字节数据到缓冲区
  • ShortBuffer：存储字符串数据到缓冲区
  • CharBuffer： 存储字符数据到缓冲区
  • IntBuffer：存储整数数据到缓冲区
  • LongBuffer：存储长整型数据到缓冲区
  • DoubleBuffer：存储小数到缓冲区
  • FloatBuffer：存储小数到缓冲区

对于 Java 中的基本数据类型，都有一个 Buffer 类型与之相对应，最常用的自然是ByteBuffer 类（二进制数据）

ByteBuffer的创建方式

  • 在堆中创建缓冲区：allocate(int capacity) （最常用）

  • 在系统内存创建缓冲区：allocateDirect(int capacity)

  • 通过普通数组创建缓冲区：wrap(byte[] arr)

import java.nio.ByteBuffer;

public class Demo01Buffer {
    public static void main(String[] args) {
        //在堆中创建缓冲区：allocate(int capacity) (最常用)
        ByteBuffer buffer1 = ByteBuffer.allocate(10);

        //在系统内存创建缓冲区：allocateDirect(int capacity)
        ByteBuffer buffer2 = ByteBuffer.allocateDirect(10);

        //通过普通数组创建缓冲区：wrap(byte[] arr)
        byte[] arr = {97,98,99};
        ByteBuffer buffer3 = ByteBuffer.wrap(arr);
    }

常用方法

拿到一个缓冲区我们往往会做什么？很简单，就是读取缓冲区的数据/写数据到缓冲区中。

所以，缓冲区的核心方法就是:

  • put(byte b) : 给数组添加元素
  • get() :获取一个元素
import java.nio.ByteBuffer;
import java.util.Arrays;

public class Demo02Buffer的方法 {
    
    public static void main(String[] args) {
	
    //创建对象
    ByteBuffer buffer = ByteBuffer.allocate(10);

    //put(byte b) : 给数组添加元素
    buffer.put((byte)10);
    buffer.put((byte)20);
    buffer.put((byte)30);

    //把缓冲数组变成普通数组
    byte[] arr = buffer.array();

    //打印
    System.out.println(Arrays.toString(arr));

    //get() :获取一个元素
    byte b = buffer.get(1);
    System.out.println(b);   //20

	}
}

核心变量

Buffer类维护了4个核心变量属性来提供关于其所包含的数组的信息

  • 容量Capacity
    缓冲区能够容纳的数据元素的最大数量。容量在缓冲区创建时被设定，并且永远不能被改变。(不能被改变的原因也很简单，底层是数组)

  • 界限Limit
    缓冲区中可以操作数据的大小，代表了当前缓冲区中一共有多少数据（从limit开始后面的位置不能操作）。

  • 位置Position
    下一个要被读或写的元素的位置。Position会自动由相应的 get( )和 put( )函数更新。

  • 标记Mark
    一个备忘位置。用于记录上一次读写的位置。就是读写操作之前的position

byteBuffer.put("baidu".getBytes());
System.out.println("第一次put后---->position--->" + byteBuffer.position());

// 做一个标记：记录上一次读写位置 position的值 5
byteBuffer.mark();

byteBuffer.put("zimu".getBytes());
System.out.println("第二次put后---->position--->" + byteBuffer.position());

// 还原到标记位置
byteBuffer.reset();
System.out.println("reset后---->position--->" + byteBuffer.position());

public static void main(String[] args) {

        // 创建一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 看一下初始时4个核心变量的值
        System.out.println("初始时-->limit--->"+byteBuffer.limit());
        System.out.println("初始时-->position--->"+byteBuffer.position());
        System.out.println("初始时-->capacity--->"+byteBuffer.capacity());
        System.out.println("初始时-->mark--->" + byteBuffer.mark());

        System.out.println("--------------------------------------");

        // 添加一些数据到缓冲区中
        String s = "JavaEE";
        byteBuffer.put(s.getBytes());

        // 看一下初始时4个核心变量的值
        System.out.println("put完之后-->limit--->"+byteBuffer.limit());
        System.out.println("put完之后-->position--->"+byteBuffer.position());
        System.out.println("put完之后-->capacity--->"+byteBuffer.capacity());
        System.out.println("put完之后-->mark--->" + byteBuffer.mark());
    }

运行结果：
在这里插入图片描述
现在我想要从缓存区拿数据，怎么拿呀？？NIO给了我们一个flip()方法。这个方法可以改动position和limit的位置！
还是上面的代码，flip()一下后，再看看4个核心属性的值会发生什么变化：

byteBuffer.flip();
System.out.println("flip完之后-->limit--->"+byteBuffer.limit());
System.out.println("flip完之后-->position--->"+byteBuffer.position());
System.out.println("flip完之后-->capacity--->"+byteBuffer.capacity());
System.out.println("flip完之后-->mark--->" + byteBuffer.mark());

运行结果：
在这里插入图片描述

  • limit变成了position的位置了
  • 而position变成了0
  • 每当要从缓存区的时候读取数据时，就调用filp()“切换成读模式”。

读取缓冲区的数据

// 创建一个limit()大小的字节数组(因为就只有limit这么多个数据可读)
byte[] bytes = new byte[byteBuffer.limit()];

// 将读取的数据装进我们的字节数组中
byteBuffer.get(bytes);

// 输出数据
System.out.println(new String(bytes, 0, bytes.length));

运行结果：在这里插入图片描述
随后输出一下核心变量的值：
在这里插入图片描述
读完我们还想写数据到缓冲区，那就使用clear()函数，这个函数会“清空”缓冲区

数据没有真正被清空，只是被遗忘掉了，此时继续执行byteBuffer.get(bytes);还是可以获取到javaEE
在这里插入图片描述

Channel通道

Channel通道概述

通道（Channel）：由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。

标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中（白话: 就是数据传输用的通道，作用是打开到IO设备的连接，文件、套接字都行）

Channel API

在这里插入图片描述

  • FileChannel：用于读取、写入、映射和操作文件的通道。
  • DatagramChannel：通过 UDP 读写网络中的数据通道。
  • SocketChannel：通过 TCP 读写网络中的数据。
  • ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来 的连接都会创建一个 SocketChannel。

FileChannel基本使用

  • 使用FileChannel完成文件的复制
public class CopyTest {
    public static void main(String[] args) throws Exception {
        // 通道依赖于IO流
        FileInputStream fileInputStream = new FileInputStream("D:\\初音未来.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\复制.jpg");
        // 使用流获取通道
        FileChannel channel = fileInputStream.getChannel();
        FileChannel channel1 = fileOutputStream.getChannel();
        // 创建缓冲数组
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (channel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            channel1.write(byteBuffer);
            byteBuffer.clear();
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

网络编程收发信息

客户端

public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 创建客户端通道，使用SocketChannel.open()方法
        SocketChannel socketChannel = SocketChannel.open();
        // 指定要连接的服务器地址和端口，使用connect(SocketAddress remote)方法
        // 参数SocketAddress是抽象类，使用其实现类InetSocketAddress构造
        socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), 1080));
        // 缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 编写数据
        buffer.put("你好，NIO！".getBytes());
        // 调整position和limit，否则写数据的时候有问题
        buffer.flip();
        // 输出数据
        socketChannel.write(buffer);
        // 释放资源
        socketChannel.close();
    }
}

服务器端

public class NIOServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建服务器通道，使用ServerSocketChannel.open()方法
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定端口，使用bind(SocketAddress local)
        // 参数SocketAddress是抽象类，使用其实现类InetSocketAddress构造
        serverSocketChannel.bind(new InetSocketAddress(1080));
        // 设置非阻塞，ttue为阻塞
        serverSocketChannel.configureBlocking(false);
        while (true) {
            // 等待客户端连接
            SocketChannel accept = serverSocketChannel.accept();
            if (accept != null) {
                // 缓冲区
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                // 读取数据，读的是缓冲区中有数据的长度
                int len = accept.read(byteBuffer);
                // 打印，将缓冲区转为数组并转成字符串
                System.out.println(new String(byteBuffer.array(), 0, len));
                break;
            } else {
                System.out.println("做一些别的事");
                Thread.sleep(5000);
            }
        }
    }
}

Selector选择器

多路复用的概念

一个选择器可以同时监听多个服务器端口, 帮多个服务器端口同时等待客户端的访问

Selector的和Channel的关系

选择器（Selector） 是 Channel（通道）的多路复用器，Selector 可以同时监控多个 通道的 IO（输入输出） 状况。

选择器提供选择执行已经就绪的任务的能力。从底层来看，Selector提供了询问通道是否已经准备好执行每个I/O操作的能力。Selector 允许单线程处理多个Channel。仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道，这样会大量的减少线程之间上下文切换的开销。

可选择通道(SelectableChannel)

注意：并不是所有的Channel，都是可以被Selector 复用的。比方说，FileChannel就不能被选择器复用。

判断一个Channel 能被Selector 复用，有一个前提：判断他是否继承了一个抽象类SelectableChannel。如果继承了SelectableChannel，则可以被复用，否则不能。

SelectableChannle 的结构如下图：
在这里插入图片描述
SelectableChannel类提供了实现通道的可选择性所需要的公共方法

通道和选择器注册之后，他们是绑定的关系吗？
答:不是。不是一对一的关系。一个通道可以被注册到多个选择器上，但对每个选择器而言只能被注册一次。
通道和选择器之间的关系，使用注册的方式完成。SelectableChannel可以被注册到Selector对象上，在注册的时候，需要指定通道的哪些操作，是Selector感兴趣的。
在这里插入图片描述

Channel注册到Selector

使用Channel.register（Selector sel，int ops）方法，将一个通道注册到一个选择器时。
第一个参数：指定通道要注册的选择器是谁
第二个参数：指定选择器需要查询的通道操作

可以供选择器查询的通道操作，从类型来分，包括以下四种：

（1）可读 : SelectionKey.OP_READ

（2）可写 : SelectionKey.OP_WRITE

（3）连接 : SelectionKey.OP_CONNECT

（4）接收 : SelectionKey.OP_ACCEPT

如果Selector对通道的多操作类型感兴趣，可以用“位或”操作符来实现：
int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

Selector的使用流程

// 1、获取Selector选择器
Selector selector = Selector.open();

// 2、获取通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

// 3.设置为非阻塞
serverSocketChannel.configureBlocking(false);

// 4、绑定连接
serverSocketChannel.bind(new InetSocketAddress(SystemConfig.SOCKET_SERVER_PORT));

// 5、将通道注册到选择器上,并制定监听事件为：“接收”事件
serverSocketChannel.register(selector，SelectionKey.OP_ACCEPT);

上面通过调用通道的register()方法会将它注册到一个选择器上。

需要注意的是：
与Selector一起使用时，Channel必须处于非阻塞模式下，否则将抛出异常IllegalBlockingModeException

选择键(SelectionKey)

Channel和Selector的关系确定好后，并且一旦通道处于某种就绪的状态，就可以被选择器查询到。这个工作，使用选择器Selector的select()方法完成。select方法的作用，对感兴趣的通道操作，进行就绪状态的查询。

Selector可以不断的查询Channel中发生的操作的就绪状态。并且挑选感兴趣的操作就绪状态。一旦通道有操作的就绪状态达成，并且是Selector感兴趣的操作，就会被Selector选中，放入选择键集合中。

select() :选择器等待客户端连接的方法
阻塞问题:
1.在开始没有客户访问的时候是阻塞的
2.在有客户来访问的时候方法会变成非阻塞的
3.如果客户的访问被处理结束之后,又会恢复成阻塞的
selectedKeys() :选择器会把被连接的服务端对象放在Set集合中,这个方法就是返回一个Set集合

轮询查询就绪操作

通过Selector的 select() 方法，可以查询出已经就绪的通道操作，这些就绪的状态集合，包存在一个元素是SelectionKey对象的Set集合中。

select()方法返回的int值，表示有多少通道已经就绪

而一旦调用select()方法，并且返回值不为0时，下一步工干啥？

通过调用Selector的selectedKeys()方法来访问已选择键集合，然后迭代集合的每一个选择键元素，根据就绪操作的类型，完成对应的操作

NIO 编程实例:
客户端

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

        //创建客户端
        SocketChannel sc = SocketChannel.open();
        //指定要连接的服务器ip和端口
        sc.connect(new InetSocketAddress("127.0.0.1",9000));

        //创建缓冲输出
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        //给数组添加数据
        buffer.put("百度".getBytes());

        //切换
        buffer.flip();

        //输出数据
        sc.write(buffer);

        //关闭资源
        sc.close();
    }

服务端

public class Selector服务端 {

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

        // 1、获取Selector选择器
        Selector selector = Selector.open();

        // 2、获取通道
        ServerSocketChannel ssc1 = ServerSocketChannel.open();
        ServerSocketChannel ssc2 = ServerSocketChannel.open();
        ServerSocketChannel ssc3 = ServerSocketChannel.open();

        // 3.设置为非阻塞
        ssc1.configureBlocking(false);
        ssc2.configureBlocking(false);
        ssc3.configureBlocking(false);

        // 4、绑定连接
        ssc1.bind(new InetSocketAddress(8000));
        ssc2.bind(new InetSocketAddress(9000));
        ssc3.bind(new InetSocketAddress(10000));


        // 5、将通道注册到选择器上,并注册的操作为："接收"操作
        ssc1.register(selector, SelectionKey.OP_ACCEPT);
        ssc2.register(selector, SelectionKey.OP_ACCEPT);
        ssc3.register(selector, SelectionKey.OP_ACCEPT);


        // 6、采用轮询的方式，查询获取"准备就绪"的注册过的操作
        while (selector.select() > 0) {
            // 7、获取当前选择器中所有注册的选择键（“已经准备就绪的操作”）
            Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
            while (selectedKeys.hasNext()) {

                // 8、获取"准备就绪"的事件
                SelectionKey selectedKey = selectedKeys.next();

                    // 9、获取ServerSocketChannel
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectedKey.channel();
                // 10、接受客户端发来的数据
                SocketChannel socketChannel = serverSocketChannel.accept();

                // 11、读取数据
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int length = 0;
                    while ((length = socketChannel.read(byteBuffer)) != -1) {
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(), 0, length));
                        byteBuffer.clear();
                    }
                    socketChannel.close();
                }
                // 12、移除选择键
                selectedKeys.remove();
            }
        // 13、关闭连接
       	 ssc1.close();
       	 ssc2.close();
      	 ssc3.close();
        }

}
远道学java
关注
NIO概述
12-22
2.2 NIO概述 NIO NIO ==> New IO(新IO), Non-Block IO(非阻塞IO) NIO非阻塞IO，运行当前程序在处理IO事务时，不会影响其他程序的运行，可以在不使用多线程的情况下，满足IO操作要求。 三大核心部分: 通道 ...
NIO原理详解
热门推荐
左耳听风的博客
08-18 7万+
1.阻塞与同步 2.BIO与NIO对比 3.NIO简介 4.缓冲区Buffer 5.通道Channel 6.反应堆 7.选择器 8.NIO源码分析 9.AIO 1.阻塞与同步 1）阻塞(Block)和非租塞(NonBlock): 阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候阻塞：往往需要等待缞冲区...
Java NIO 详解（一）
weixin_33795743的博客
09-14 1440
NIO即新的输入输出，这个库是在JDK1.4中才引入的。它在标准java代码中提供了高速的面向块的IO操作。 一、基本概念描述 1.1 I/O简介 I/O即输入输出，是计算机与外界世界的一个借口。IO操作的实际主题是操作系统。在java编程中，一般使用流的方式来处理IO，所有的IO都被视作是单个字节的移动，通过stre...
Java中的NIO和IO的比较
个人视角下的技术领域探索
05-13 541
        java标准的I/O中，提供了基于流的I/O实现，即InputStream和OutputStream。这种基于流的实现以字节为单位处理数据。        NIO在java 1.4中被纳入到了JDK中，与旧式的的基于流的I/O相比，NIO是基于块的，以块为单位处理数据。NIO有两个重要的组件缓冲（Buffer）和通道（Channel）。        Buffer：缓冲是一块连续的...
NIO与IO的区别
Mr孔先森
06-24 2万+
JAVA NIO vs IO 当我们学习了Java NIO和IO后，我们很快就会思考一个问题： 什么时候应该使用IO，什么时候我应该使用NIO 在下文中我会尝试用例子阐述java NIO 和IO的区别，以及它们对你的设计会有什么影响 Java NIO和IO的主要区别 IO NIO 面向Stream 面向Buffer 阻塞IO 非阻塞IO
java中的IO和NIO的区别原理
jubaoquan的博客
01-16 1821
Java NIO和IO的主要区别 IO NIO 面向Stream 面向Buffer 阻塞IO 非阻塞IO   Selectors 面向Stream和面向Buffer Java NIO和IO之间最大的区别是IO是面向流（Stream）的，NIO是面向块（buffer）的，所以，这意味着什么？ 面向流
Java流NIO
12-22
Java NIO，全称为New Input/Output，是Java平台中用于处理输入输出操作的重要部分，自Java 1.4版本引入。NIO的核心目标是提供一种更高效、更灵活的I/O模型，以应对高性能应用的需求。传统的Java IO API基于流(Stream...
Java NIO 中文 Java NIO 中文 Java NIO 中文文档
07-15
Java NIO 深入探讨了 1.4 版的 I/O 新特性，并告诉您如何使用这些特性来极大地提升您所写的 Java 代码的执行效率。这本小册子就程序员所面临的有代表性的 I/O 问题作了详尽阐述，并讲解了 如何才能充分利用新的 I/O ...
nio的excel导出
06-07
nio的excel导出
niodemo.zip
05-26
Java NIO，全称为Non-Blocking Input/Output（非阻塞输入/输出），是Java标准库提供的一种替代传统I/O（BIO）模型的新技术。NIO在Java 1.4版本中引入，旨在提高I/O操作的效率，特别是在处理大量并发连接时。与传统的...
第5节浅谈NIO
pjh88的博客
07-25 226
浅谈NIO 概述 1.Java NIO 全称 Java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。 2.NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。【基本案例】 NIO 有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器） 。 3.NIO 是面向缓冲区，或者面向块编程的
NIO学习笔记一
麒麟木木
07-20 2904
I/O简介发     在Java编程中，原先一直使用的是基于流的I/O。所有I/O都被视为单个的字节的移动，通过一个称为 Stream 的对象一次移动一个字节。而JDK1.4开始出现的NIO，与原来的I/O有着同样的作用和目的，但是它使用不同的方式。NIO是基于块的I/O方式来进行的，所以块I/O的效率可以比流I/O高得多。 流与块的比较     原来的 I/O 库与 NIO 最重要的区别是
使用NIO处理对象数据
liu199123的博客
02-27 300
JavaSE中基于Socket的网络通信是阻塞式的，当程序执行输入输出操作后，在这些操作返回之前会一直阻塞该线程，使得服务器要为每一个客户端提供线程进行数据处理，这种处理不适合处理数量多的客户端，jdk1.4后Java引入了nio. 在进行网络编程时，使用SocketChannel大大减轻了服务器的负担，在此贴上如何讲一个对象装入ByteBuffer的： [code="java"]im...
面试官：什么是NIO？NIO的原理是什么机制？
weixin_45727359的博客
03-14 358
作者：依本多情https://blog.csdn.net/qq_36520235/NIO和IO到底有什么区别？有什么关系？首先说一下核心区别：NIO是以...
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1268
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1047
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 512
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1235
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
最新发布
2301_79272475的博客
10-30 396
Java复习24（PTA)：多种排序的book类*
Java NIO 入门教程
"java_NIO_入门" Java NIO（New Input/Output）是自JDK 1.4版本引入的一个新特性，它为Java应用程序提供了更高效的数据传输方式，特别是对于大块数据处理和并发操作。传统的Java I/O基于流（Stream）模型，而NIO则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值