#outputstream

original source : http://tutorials.jenkov.com/java-io/outputstream.html

The OutputStream class is the base class of all output streams in the Java IO API. Subclasses include the BufferedOutputStream and the FileOutputStream among others. To see a full list of streams, go to the bottom table of the Java IO Overview page.

OutputStream's and Destinations

An OutputStream is typically always connected to some data destination, like a file, network connection, pipe etc. This is also explained in more detail in the Java IO Overview text. The OutputStream's data destination is where all data written to the OutputStream will eventually end.

write(byte)

The write(byte) method is used to write a single byte to the OutputStream. The write() method of an OutputStream takes an int which contains the byte value of the byte to write. Only the first byte of the intvalue is written. The rest is ignored.

Subclasses of OutputStream may have alternative write() methods. For instance, the DataOutputStreamallows you to write Java primitives like int, long, float, double, boolean etc. with its corresponding methods writeBoolean(), writeDouble() etc.

Here is an OutputStream write() example:

OutputStream output = new FileOutputStream("c:\\data\\output-text.txt"); while(hasMoreData()) {  int data = getMoreData();  output.write(data); } output.close();

This OutputStream write() example first creates a FileOutputStream to which the data will be written. Then the example enters a while loop. The condition to exit the while loop is the return value of the method hasMoreData(). The implementation of hasMoreData() is not shown, but imagine that it returns true if there is more data to write, and false if not.

Inside the while loop the example calls the method getMoreData() to get the next data to write to the OutputStream, and then writes that data to the OutputStream. The while loop continues until hasMoreData()returns false.

Note: The proper exception handling has been skipped here for the sake of clarity. To learn more about correct exception handling, go to Java IO Exception Handling.

write(byte[])

The OutputStream class also has a write(byte[] bytes) method and a write(byte[] bytes, int offset, int length) which both can write an array or part of an array of bytes to the OutputStream.

The write(byte[] bytes) method writes all the bytes in the byte array to the OutputStream.

The write(byte[] bytes, int offset, int length) method writes length bytes starting from index offsetfrom the byte array to the OutputStream.

flush()

The OutputStream's flush() method flushes all data written to the OutputStream to the underlying data destination. For instance, if the OutputStream is a FileOutputStream then bytes written to the FileOutputStream may not have been fully written to disk yet. The data might be buffered in memory somewhere, even if your Java code has written it to the FileOutputStream. By calling flush() you can assure that any buffered data will be flushed (written) to disk (or network, or whatever else the destination of your OutputStream has).

close()

Once you are done writing data to the OutputStream you should close it. You close an OutputStream by calling its close() method. Since the OutputStream's various write() methods may throw an IOException, you should close the OutputStream inside a finally block. Here is a simple OutputStream close() example:

OutputStream output = null; try{  output = new FileOutputStream("c:\\data\\output-text.txt");  while(hasMoreData()) {    int data = getMoreData();    output.write(data);  } } finally {    if(output != null) {        output.close();    } }

original source : http://tutorials.jenkov.com/java-io/streams.html

Java IO streams are flows of data you can either read from, or write to. As mentioned earlier in this tutorial, streams are typically connected to a data source, or data destination, like a file, network connection etc.

A stream has no concept of an index of the read or written data, like an array does. Nor can you typically move forth and back in a stream, like you can in an array, or in a file using RandomAccessFile. A stream is just a continuous flow of data.

Some stream implementations like the PushbackInputStream allows you to push data back into the stream, to be re-read again later. But you can only push back a limited amount of data, and you cannot traverse the data at will, like you can with an array. Data can only be accessed sequentially.

Java IO streams are typically either byte based or character based. The streams that are byte based are typically called something with "stream", like InputStream or OutputStream. These streams read and write a raw byte at a time, with the exception of the DataInputStream and DataOutputStream which can also read and write int, long, float and double values.

The streams that are character based are typically called something with "Reader" or "Writer". The character based streams can read / write characters (like Latin1 or UNICODE characters). See the text Java Readers and Writers for more information about character based input and output.

InputStream

The class java.io.InputStream is the base class for all Java IO input streams. If you are writing a component that needs to read input from a stream, try to make our component depend on an InputStream, rather than any of it's subclasses (e.g. FileInputStream). Doing so makes your code able to work with all types of input streams, instead of only the concrete subclass.

Depending on InputStream only isn't always possible, though. If you need to be able to push back data into the stream, you will have to depend on a PushbackInputStream - meaning your stream variable will be of this type. Otherwise your code will not be able to call the unread() method on the PushbackInputStream.

You typically read data from an InputStream by calling the read() method. The read() method returns a int containing the byte value of the byte read. If there is no more data to be read, the read() method typically returns -1;

Here is a simple example:

InputStream input = new FileInputStream("c:\\data\\input-file.txt"); int data = input.read(); while(data != -1){  data = input.read(); }

OutputStream

The class java.io.OutputStream is the base class of all Java IO output streams. If you are writing a component that needs to write output to a stream, try to make sure that component depends on an OutputStream and not one of its subclasses.

Here is a simple example pushing some data out to a file:

OutputStream output = new FileOutputStream("c:\\data\\output-file.txt"); output.write("Hello World".getBytes()); output.close();

Combining Streams

You can combine streams into chains to achieve more advanced input and output operations. For instance, reading every byte one at a time from a file is slow. It is faster to read a larger block of data from the disk and then iterate through that block byte for byte afterwards. To achieve buffering you can wrap your InputStream in an BufferedInputStream. Here is an example:

InputStream input = new BufferedInputStream(                        new FileInputStream("c:\\data\\input-file.txt")); ...

Buffering can also be applied to OutputStream's thereby batching the writes to disk (or the underlying stream) up in larger chunks. That provides faster output too. This is done with a BufferedOutputStream.

Buffering is just one of the effects you can achieve by combining streams. You can also wrap your InputStream in a PushbackStream. That way you can push data back into the stream to be re-read later. This is sometimes handy during parsing. Or, you can combine two InputStreams into one using theSequenceInputStream

original source : http://tutorials.jenkov.com/java-io/networking.html

The details of networking in Java is somewhat out of the scope of this Java IO tutorial. Java Networking is described in more detail in my Java Networking Tutorial. But, since network connections are a common source or destination of data, and because you use the Java IO API to communicate over a network connection, this text will briefly touch upon Java networking.

Once a network connection is established between two processes they communicate via the network connection just like they would with a file: Using an InputStream to read data, and an OutputStream to write data. In other words, while the Java Networking API is being used to establish a network connection between processes, Java IO is being used to exchange data between the processes once the connection is established.

Basically this means that if you have code that is capable of writing something to a file, that same something could easily be written to a network connection. All that is required is that your component doing the writing depends on an OutputStream instead of a FileOutputStream. Since FileOutputStream is a subclass of OutputStream this should be no problem.

The same is true for reading from a file, actually. A component capable of reading some data from a file, can easily read that same data from a network connection. Just make sure you reading component depends on an InputStream for reading it's data, and not a FileInputStream.

Here is an example:

public class MyClass {        public static void main(String[] args) {        InputStream inputStream = new FileInputStream("c:\\myfile.txt");            process(inputStream);        }        public static void process(InputStream input) throws IOException {        //do something with the InputStream    } }

Use FileChannel.force(boolean) or FileDescriptor.sync() to force data to be persistent on disk. Either of them can work. FileChannel.force use FileDispacther.force[1] and it calls fdatasync or fsync in Java 8. 

When you use OutputStream.flush, it does not guarantee the data to be written to disk, just flush it to OS. Better to use FileOutputStream.getChannel().force(true) or FileOutputStream.getFD().sync() to guarantee the persistency, performance might not be good.

Special Thanks to Yongkun. He wrote very good blog post. [2]

[1] http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/solaris/native/sun/nio/ch/FileDispatcherImpl.c#l141

输入流是从一个容器中读内容

How to: What is InputStream & Output Stream? Why do we use them and when do we use each of them?

What is InputStream & Output Stream? Why do we use them and when do we use each of them?

It sounds like a very silly question but can anyone explain me about Input stream and output stream. I remain confused about when do we need input stream and when we need output stream? An explanation with some code snippet will be great. I just need to figure out their difference and usage.

Answer: What is…

iOS 개발을 하면서 메모리 때문에 이렇게 힘들었던 적은 처음이었다. 네트워크를 통해 대용량 파일을 내려받는 과정에서 계속 메모리 에러가 발생했다. 일단 디버깅을 하면서 문제점을 찾고 하나씩 원인과 해결방법을 고민했다.

해결방법 1. AFNetworking 라이브러리에서 outputStream 사용 iOS에서 AFNetworking 라이브러리를 사용했는데 그냥 파일을 내려받을 경우 메모리에 저장되고 작업이 완료된 경우에 NSData를 가지고 파일을 만들기 때문에 계속해서 'Received memory warning' 메시지를 받다가 앱이 죽게 된다. 이때, outputStream을 사용하면 메모리에 저장하는 대신 파일에 직접 스트리밍 되기 때문에 수십-수백MB 크기의 파일을 받을 때 유용하다.

해결방법 2. imageWithContentsOfFile: 메서드 사용 UIImage를 다룰 때, imageWithData 메서드를 자주 사용하고 있었는데 대용량 이미지 파일을 NSData로 변환하고 다시 UIImage로 변환하는 과정에서 메모리가 많이 사용되었다. 이 부분은 imageWithContentsOfFile 메서드를 써서 이미지 사용 후 해제되도록 하였다. imageNamed와 imageWithContentsOfFile의 차이점도 알아두면 도움이 된다.