blocks|key|334600|text|这个问题的重点似乎被忽略了。如果我正确地理解了您，您需要一个在一个线程中像InputStream那样工作的对象，在另一个线程中创建一个类似于OutputStream的对象来创建两个线程之间的通信方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|334601|也许一个答案是使用组合而不是继承(这是推荐的做法)。创建一个管道，其中包含一个PipedInputStream和一个相互连接的PipedOutputStream，其中包含getInputStream()和getOutputStream()方法。|334602|您不能直接将管道对象传递给需要流的东西，但是可以传递它的get方法的返回值。|334603|这对你有用吗？|334604|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It seems the point of this question is being missed. If I understand you correctly, you want an object that functions like an InputStream in one thread, and an OutputStream in another to create a means of communicating between the two threads.

Perhaps one answer is to use composition instead of inheritance (which is recommended practice anyway). Create a Pipe which contains a PipedInputStream and a PipedOutputStream connected to each other, with getInputStream() and getOutputStream() methods.

You can't directly pass the Pipe object to something needing a stream, but you can pass the return value of it's get methods to do it.

Does that work for you?

blocks|key|665533|text|java.io.PipedOutputStream和java.io.PipedInputStream看起来是用于此场景的类。它们被设计成一起用于在线程之间输送数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|665534|如果您真的想要传递某个对象，那么它需要包含每个对象中的一个并通过getter公开它们。|665535|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

java.io.PipedOutputStream and java.io.PipedInputStream look to be the classes to use for this scenario. They are designed to be used together to pipe data between threads.

If you really want some single object to pass around it would need to contain one of each of these and expose them via getters.

blocks|key|677029|text|我认为这是一件很平常的事。看这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|677030|Easy+way+to+write+contents+of+a+Java+InputStream+to+an+OutputStream|offset|length|677031|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/43157/easy-way-to-write-contents-of-a-java-inputstream-to-an-ouptutstream#43164^0|0|0|1V|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

This is a pretty common thing to do, I think. See this question.

<a href="https://stackoverflow.com/questions/43157/easy-way-to-write-contents-of-a-java-inputstream-to-an-ouptutstream#43164">Easy way to write contents of a Java InputStream to an OutputStream</a>

blocks|key|334585|text|您不能创建一个同时从InputStream和OutputStream派生的类，因为它们不是接口，它们有共同的方法，而且Java不允许多重继承(编译器不知道是调用InputStream.close()还是OutputStream.close()，如果您在新对象上调用close()+)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|334586|另一个问题是缓冲区。Java希望为数据分配一个静态缓冲区(不会改变)。这意味着当您使用‘java.io.PipedXxxStream’时，除非您使用两个不同的线程，否则它的写入数据最终将被阻塞。|334587|因此，Apocalisp的答案是正确的:您必须编写一个复制循环。|334588|我建议您在项目中包括Apache的commons，该项目包含许多仅用于此类任务的助手例程(在流、文件、字符串及其所有组合之间复制数据)。|334589|entityMap^0|A|B|M|C|28|J|2T|K|3O|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|M|$]]

You can't create a class which derives both from <code>InputStream</code> and <code>OutputStream</code> because these aren't interfaces and they have common methods and Java doesn't allow multiple inheritance (the compiler doesn't know whether to call <code>InputStream.close()</code> or <code>OutputStream.close()</code> if you call <code>close()</code> on your new object).

The other problem is the buffer. Java wants to allocate a static buffer for the data (which doesn't change). This means when you use the `java.io.PipedXxxStream', the writing data to it will eventually block unless you use two different threads.

So the answer from Apocalisp is correct: You must write a copy loop.

I suggest that you include Apache's commons-io in your project which contains many helper routines just for tasks like this (copy data between streams, files, strings and all combinations thereof).

blocks|key|677107|text|请参阅http://ostermiller.org/utils/CircularBuffer.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|677108|entityMap|0|LINK|mutability|MUTABLE|url|http://ostermiller.org/utils/CircularBuffer.html^0|3|1C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

See <a href="http://ostermiller.org/utils/CircularBuffer.html" rel="nofollow noreferrer">http://ostermiller.org/utils/CircularBuffer.html</a>

blocks|key|677144|text|我必须为到servlet的缓慢连接实现一个筛选器，所以基本上我将servlet输出流封装到一个QueueOutputStream中，它会将每个字节(在小缓冲区中)添加到一个队列中，然后将这些小缓冲区输出到第二个输出流中，所以在某种程度上这是作为输入/输出流的，IMHO比不会扩展的JDK管道更好，基本上在标准JDK实现(每次读/写)中有太多的上下文切换，阻塞队列对于单个生产者/消费者场景来说就是完美的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|677145|import+java.io.IOException;
import+java.io.OutputStream;
import+java.util.concurrent.*;

public+class+QueueOutputStream+extends+OutputStream
{
++private+static+final+int+DEFAULT_BUFFER_SIZE=1024;
++private+static+final+byte[]+END_SIGNAL=new+byte[]{};

++private+final+BlockingQueue<byte[]>+queue=new+LinkedBlockingDeque<>();
++private+final+byte[]+buffer;

++private+boolean+closed=false;
++private+int+count=0;

++public+QueueOutputStream()
++{
++++this(DEFAULT_BUFFER_SIZE);
++}

++public+QueueOutputStream(final+int+bufferSize)
++{
++++if(bufferSize<=0){
++++++throw+new+IllegalArgumentException("Buffer+size+<=+0");
++++}
++++this.buffer=new+byte[bufferSize];
++}

++private+synchronized+void+flushBuffer()
++{
++++if(count>0){
++++++final+byte[]+copy=new+byte[count];
++++++System.arraycopy(buffer,0,copy,0,count);
++++++queue.offer(copy);
++++++count=0;
++++}
++}

++@Override
++public+synchronized+void+write(final+int+b)+throws+IOException
++{
++++if(closed){
++++++throw+new+IllegalStateException("Stream+is+closed");
++++}
++++if(count>=buffer.length){
++++++flushBuffer();
++++}
++++buffer[count%2B%2B]=(byte)b;
++}

++@Override
++public+synchronized+void+write(final+byte[]+b,+final+int+off,+final+int+len)+throws+IOException
++{
++++super.write(b,off,len);
++}

++@Override
++public+synchronized+void+close()+throws+IOException
++{
++++flushBuffer();
++++queue.offer(END_SIGNAL);
++++closed=true;
++}

++public+Future<Void>+asyncSendToOutputStream(final+ExecutorService+executor,+final+OutputStream+outputStream)
++{
++++return+executor.submit(
++++++++++++new+Callable<Void>()
++++++++++++{
++++++++++++++@Override
++++++++++++++public+Void+call()+throws+Exception
++++++++++++++{
++++++++++++++++try{
++++++++++++++++++byte[]+buffer=queue.take();
++++++++++++++++++while(buffer!=END_SIGNAL){
++++++++++++++++++++outputStream.write(buffer);
++++++++++++++++++++buffer=queue.take();
++++++++++++++++++}
++++++++++++++++++outputStream.flush();
++++++++++++++++}+catch(Exception+e){
++++++++++++++++++close();
++++++++++++++++++throw+e;
++++++++++++++++}+finally{
++++++++++++++++++outputStream.close();
++++++++++++++++}
++++++++++++++++return+null;
++++++++++++++}
++++++++++++}
++++);
++}|code-block|syntax|javascript|677146|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I had to implement a filter for slow connections to Servlets so basically I wrapped the servlet output stream into a QueueOutputStream which will add every byte (in small buffers), into a queue, and then output those small buffers to a 2nd output stream, so in a way this acts as input/output stream, IMHO this is better than JDK pipes which won't scale that well, basically there is too much context switching in the standard JDK implementation (per read/write), a blocking queue is just perfect for a single producer/consumer scenario:

<pre><code>import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.*;

public class QueueOutputStream extends OutputStream
{
 private static final int DEFAULT_BUFFER_SIZE=1024;
 private static final byte[] END_SIGNAL=new byte[]{};

 private final BlockingQueue&lt;byte[]&gt; queue=new LinkedBlockingDeque&lt;&gt;();
 private final byte[] buffer;

 private boolean closed=false;
 private int count=0;

 public QueueOutputStream()
 {
 this(DEFAULT_BUFFER_SIZE);
 }

 public QueueOutputStream(final int bufferSize)
 {
 if(bufferSize&lt;=0){
 throw new IllegalArgumentException("Buffer size &lt;= 0");
 }
 this.buffer=new byte[bufferSize];
 }

 private synchronized void flushBuffer()
 {
 if(count&gt;0){
 final byte[] copy=new byte[count];
 System.arraycopy(buffer,0,copy,0,count);
 queue.offer(copy);
 count=0;
 }
 }

 @Override
 public synchronized void write(final int b) throws IOException
 {
 if(closed){
 throw new IllegalStateException("Stream is closed");
 }
 if(count&gt;=buffer.length){
 flushBuffer();
 }
 buffer[count++]=(byte)b;
 }

 @Override
 public synchronized void write(final byte[] b, final int off, final int len) throws IOException
 {
 super.write(b,off,len);
 }

 @Override
 public synchronized void close() throws IOException
 {
 flushBuffer();
 queue.offer(END_SIGNAL);
 closed=true;
 }

 public Future&lt;Void&gt; asyncSendToOutputStream(final ExecutorService executor, final OutputStream outputStream)
 {
 return executor.submit(
 new Callable&lt;Void&gt;()
 {
 @Override
 public Void call() throws Exception
 {
 try{
 byte[] buffer=queue.take();
 while(buffer!=END_SIGNAL){
 outputStream.write(buffer);
 buffer=queue.take();
 }
 outputStream.flush();
 } catch(Exception e){
 close();
 throw e;
 } finally{
 outputStream.close();
 }
 return null;
 }
 }
 );
 }
</code></pre>

blocks|key|334679|text|最好使用管道或ArrayBlockingQueue，我建议您不要使用PipedInput/OutputStream，因为它们有不好的实践，甚至您可以在下面的链接中看到，它们要求被废弃，因为它会导致许多问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|334680|https://bugs.openjdk.java.net/browse/JDK-8223048|offset|length|334681|对于BlockingQueue和管道，这里有一个简单的例子|334682|管：|style|BOLD|334683|Pipe+pipe+=+Pipe.open();
Pipe.SinkChannel+sinkChannel+=+pipe.sink();
String+newData+=+"New+String+to+write+to+file..."+%2B+System.currentTimeMillis();

ByteBuffer+buf+=+ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());

buf.flip();

while(buf.hasRemaining())+{
++++sinkChannel.write(buf);
}
Pipe.SourceChannel+sourceChannel+=+pipe.source();
ByteBuffer+buf+=+ByteBuffer.allocate(48);

int+bytesRead+=+inChannel.read(buf);|code-block|syntax|javascript|334684|参考资料：http://tutorials.jenkov.com/java-nio/pipe.html|334685|BlockingQueue:|334686|//Shared+class+used+by+threads
public+class+Buffer+{
++++//+ArrayBlockingQueue
++++private+BlockingQueue<Integer>+blockingQueue+=+new+ArrayBlockingQueue<Integer>(1);

++++public+void+get()+{
++++++++//+retrieve+from+ArrayBlockingQueue
++++++++try+{
++++++++++++System.out.println("Consumer+received+-+"+%2B+blockingQueue.take());
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}

++++public+void+put(int+data)+{
++++++++try+{
++++++++++++//+putting+in+ArrayBlockingQueue
++++++++++++blockingQueue.put(data);
++++++++++++System.out.println("Producer+produced+-+"+%2B+data);
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}
}

public+static+void+main(String[]+args)+{
++++++++//+Starting+two+threads
++++++++ExecutorService+executorService+=+null;
++++++++try+{
++++++++++++Buffer+buffer+=+new+Buffer();
++++++++++++executorService+=+Executors.newFixedThreadPool(2);
++++++++++++executorService.execute(new+Producer(buffer));
++++++++++++executorService.execute(new+Consumer(buffer));
++++++++}+catch+(Exception+e)+{
++++++++++++e.printStackTrace();
++++++++}finally+{
++++++++++++if(executorService+!=+null)+{
++++++++++++++++executorService.shutdown();
++++++++++++}
++++++++}
++++}

public+class+Consumer+implements+Runnable+{
++++private+Buffer+buffer;

++++public+Consumer(Buffer+buffer)+{
++++++++this.buffer+=+buffer;
++++}

++++@Override
++++public+void+run()+{
++++++++while+(true)+{
++++++++++++try+{
++++++++++++++++buffer.get();
++++++++++++++++Thread.sleep(1000);
++++++++++++}+catch+(InterruptedException+e)+{
++++++++++++++++e.printStackTrace();
++++++++++++}
++++++++}
++++}
}

public+class+Producer+implements+Runnable+{
++++private+Buffer+buffer;

++++public+Producer(Buffer+buffer)+{
++++++++this.buffer+=+buffer;
++++}

++++@Override
++++public+void+run()+{
++++++++while+(true)+{
++++++++++++Random+random+=+new+Random();
++++++++++++int+data+=+random.nextInt(1000);
++++++++++++buffer.put(data);
++++++++}
++++}
}|334687|参考资料：https://github.com/kishanjavatrainer/ArrayBlockingQueueDemo/tree/master/ArrayBlockingQueueDemo|334688|entityMap|0|LINK|mutability|MUTABLE|url|1|http://tutorials.jenkov.com/java-nio/pipe.html|2|https://github.com/kishanjavatrainer/ArrayBlockingQueueDemo/tree/master/ArrayBlockingQueueDemo^0|0|0|1C|0|0|0|0|2|0|0|5|1A|1|0|0|E|0|0|5|2M|2|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@$D|1B|E|1C|1|1D]]|A|$]]|$1|F|3|G|5|6|7|1E|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1F|8|@$D|1G|E|1H|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1I|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@$D|1K|E|1L|1|1M]]|A|$]]|$1|S|3|T|5|6|7|1N|8|@$D|1O|E|1P|J|K]]|9|@]|A|$]]|$1|U|3|V|5|N|7|1Q|8|@]|9|@]|A|$O|P]]|$1|W|3|X|5|6|7|1R|8|@]|9|@$D|1S|E|1T|1|1U]]|A|$]]|$1|Y|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|C]]|15|$5|11|12|13|A|$14|16]]|17|$5|11|12|13|A|$14|18]]]]

Better to use Pipe or ArrayBlockingQueue, I recommend you not to use PipedInput/OutputStream as they have a bad practice even you can see in the link below that they have asked to be deprecated as it causes many issues.
<a href="https://bugs.openjdk.java.net/browse/JDK-8223048" rel="nofollow noreferrer">https://bugs.openjdk.java.net/browse/JDK-8223048</a>
For the BlockingQueue and Pipe here a simple example of that
Pipe:
<pre><code>Pipe pipe = Pipe.open();
Pipe.SinkChannel sinkChannel = pipe.sink();
String newData = &quot;New String to write to file...&quot; + System.currentTimeMillis();

ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());

buf.flip();

while(buf.hasRemaining()) {
 sinkChannel.write(buf);
}
Pipe.SourceChannel sourceChannel = pipe.source();
ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf);
</code></pre>
Reference: <a href="http://tutorials.jenkov.com/java-nio/pipe.html" rel="nofollow noreferrer">http://tutorials.jenkov.com/java-nio/pipe.html</a>
BlockingQueue:
<pre><code>//Shared class used by threads
public class Buffer {
 // ArrayBlockingQueue
 private BlockingQueue&lt;Integer&gt; blockingQueue = new ArrayBlockingQueue&lt;Integer&gt;(1);

 public void get() {
 // retrieve from ArrayBlockingQueue
 try {
 System.out.println(&quot;Consumer received - &quot; + blockingQueue.take());
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }

 public void put(int data) {
 try {
 // putting in ArrayBlockingQueue
 blockingQueue.put(data);
 System.out.println(&quot;Producer produced - &quot; + data);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
}

public static void main(String[] args) {
 // Starting two threads
 ExecutorService executorService = null;
 try {
 Buffer buffer = new Buffer();
 executorService = Executors.newFixedThreadPool(2);
 executorService.execute(new Producer(buffer));
 executorService.execute(new Consumer(buffer));
 } catch (Exception e) {
 e.printStackTrace();
 }finally {
 if(executorService != null) {
 executorService.shutdown();
 }
 }
 }

public class Consumer implements Runnable {
 private Buffer buffer;

 public Consumer(Buffer buffer) {
 this.buffer = buffer;
 }

 @Override
 public void run() {
 while (true) {
 try {
 buffer.get();
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
}

public class Producer implements Runnable {
 private Buffer buffer;

 public Producer(Buffer buffer) {
 this.buffer = buffer;
 }

 @Override
 public void run() {
 while (true) {
 Random random = new Random();
 int data = random.nextInt(1000);
 buffer.put(data);
 }
 }
}

</code></pre>
Reference:
<a href="https://github.com/kishanjavatrainer/ArrayBlockingQueueDemo/tree/master/ArrayBlockingQueueDemo" rel="nofollow noreferrer">https://github.com/kishanjavatrainer/ArrayBlockingQueueDemo/tree/master/ArrayBlockingQueueDemo</a>

Does anyone have any good suggestions for creating a Pipe object in Java which is both an InputStream and and OutputStream since Java does not have multiple inheritance and both of the streams are abstract classes instead of interfaces?

The underlying need is to have a single object that can be passed to things which need either an InputStream or an OutputStream to pipe output from one thread to input for another.

Input and Output Stream Pipe in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

是否有人对在InputStream和OutputStream中创建管道对象有任何好的建议，因为Java不具有多重继承，而且这两个流都是抽象类而不是接口？底层的需求是，有一个对象可以传递给需要InputStream或OutputStream才能将输出从一个线程输送到另一个线程输入的事物。

问Java中的输入输出流管
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的输入输出流管EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的输入输出流管
EN