其中：
file.seek(file.length()/3);
String s = "--插入--";
// s = new String(s.getBytes("ISO-8859-1"),"utf-8");
byte[] bytes = s.getBytes();
file.write(bytes);
这段如果不写，也就是不用randomAccessFile的write来写入，获得的txt文件打开时，没有乱码，但是如果使用了write，控制台输出没有问题，但是，txt文件中就会变成乱码，即便使用注释部分的代码也没能解决。
复制代码
Do not use the write randomAccessFile
Use the write randomAccessFile
3.7. Pipeline media
In java, the role of the pipeline is to achieve the same virtual machine communication between two different threads. And pipeline related classes are: PipedInputStream and PipedOutputStream.
package cn.wh3t;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.RandomAccessFile;
import java.io.Reader;
public class AboutIO {
public static void pipedStream() throws IOException {
// TODO 自动生成的方法存根
final PipedOutputStream pipedOutputStream = new PipedOutputStream();
final PipedInputStream pipedInputStream = new PipedInputStream(pipedOutputStream);
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO 自动生成的方法存根
try {
pipedOutputStream.write("piped".getBytes());
} catch (IOException e) {
// TODO: handle exception
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO 自动生成的方法存根
try {
int data = pipedInputStream.read();
while (data!=-1) {
System.out.println((char)data);
data = pipedInputStream.read();
}
} catch (IOException e) {
// TODO: handle exception
}finally {
try {
pipedInputStream.close();
} catch (IOException e2) {
// TODO: handle exception
}
}
}
});
thread1.start();
thread2.start();
}
public static void main(String[] args) throws IOException {
//writeByte2File();
//readFile2Bytes();
//writeChar2File();
//readFile2Char();
//byte2Char();
//fileOption();
//randomReadFile();
pipedStream();
}
}
复制代码
p
i
p
e
d
复制代码
Like the two pipelines, one responsible for input, a charge of output.
3.8. Network Media
JavaIO network that is oriented Java network programming , core socket, the same as disk operations, corresponding to the two sets of Java network programming api: IO and NIO.
JavaAPI provided two NIO, a set of standard input and output NIO, a network programming NIO.
NIO difference between the maximum and IO: IO data (simple and convenient, but the process is slow), NIO processing data in blocks (faster than the flow, but not as a simple stream) in a stream.
About Buffer
Buffer and Channel standard is a core subject in the NIO, almost every IO operations are used to get. Any source and target data must pass through a Channel object, Buffer namely container object, all objects, whether the reader to go through the Channel Buffer.
Buffer is essentially an array, usually a byte array, but may be other type of array. However, a buffer is not just an array importantly, it provides a structured access to data, but also can read and write process tracking system.
Buffer read and write data using the following four general steps:
Data is written to Buffer
Call flip () method (the Buffer switching from write mode to read mode)
Reading data from the Buffer
Call clear () or compact () method (Clear emptied the entire buffer, the read data is cleared Compact any unread data is moved to the beginning of the buffer, the new data is written back into the unread data)
Java NIO in specific Buffer types are as follows: (Data Buffer can be these basic types, Mapped some special - in simple terms MappedByteBuffer )
ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer
About Channel
Different flows and Channel
Channel is bi-directional, both reading and writing, and the flow is unidirectional
Channel support asynchronous read and write
Channel must read and write through the Buffer objects
Java NIO in Channel types are as follows:
FileChannel (for reading and writing file data)
DatagramChannel (UDP for reading and writing data)
The SocketChannel (TCP for reading and writing data)
ServerSocketChannel (allow us to listen to the TCP link requests, each will create a SocketChannel)
Read and write operations NIO
Reads data from a file, it requires three steps, write, too
Get the Channel from FileInputStream
Creating Buffer
To read data from the Channel Buffer
package cn.wh3t;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class AboutIO {
public static void NIOReadAndWriteByCopyFile(String src,String dst) throws IOException {
// TODO 自动生成的方法存根
FileInputStream is = new FileInputStream(src);
FileOutputStream os = new FileOutputStream(dst);
FileChannel Ichannel = is.getChannel();
FileChannel Ochannel = os.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
int num = Ichannel.read(buffer);
if (num == -1) {
break;
}
buffer.flip();//Flips this buffer. The limit is set to the current position and thenthe position is set to zero.
Ochannel.write(buffer);
buffer.clear();
}
Ichannel.close();
Ochannel.close();
is.close();
os.close();
}
public static void main(String[] args) throws IOException {
//writeByte2File();
//readFile2Bytes();
//writeChar2File();
//readFile2Char();
//byte2Char();
//fileOption();
//randomReadFile();
//pipedStream();
//bufferStream();
//bufferChar();
NIOReadAndWriteByCopyFile("G:/Java/hello3.text", "G:/Java/hello4.text");
}
}
复制代码
flip, clear that the method is used to set these two values.
public final Buffer flip() {
//一般从Buffer读取数据前调用
limit = position;
position = 0;
mark = -1; //取消标记
return this;
public final Buffer clear() {
//一般把数据写入Buffer前调用
position = 0;
limit = capacity;
mark = -1;
return this;
复制代码
Network Programming NIO (asynchronous IO)
Brief asynchronous IO
Asynchronous IO read and write data is not blocked, the general IO, when read will block until there is data to be read will block until there is data to be written during write. Not only does not block asynchronous IO, IO can also register events such as read data, new connections, when an event occurs, the system will notify.
Another big advantage of asynchronous IO is: it allows a large number of inputs and outputs simultaneously execute IO. Since polling is usually synchronous IO, or create a large number of threads to handle. Using asynchronous IO, events on any number of channels can listen without polling, do not have a lot of threads.
Selector (NIO third core object)
Selector is an object that can be registered to a lot Channel, listen for events that occur on each Channel, and be able to read or write Channel decided based on the event. Such a thread through managing multiple Channel, it can handle a large number of connections.
With the benefits of the Selector: you can use a thread to handle all the channels, switching between threads for the operating system is costly, and each thread will consume resources. So, the better thread systems. (But now with the operating system and CPU performance in terms of getting better and better multi-tasking, k overhead is also reduced, in fact, a multi-core CPU, without the use of multi-tasking is a waste of CPU power)
Selector Channel have interested in the event are four:
Connect --SelectionKey.OP_CONNECT
Accept --SelectionKey.OP_ACCEPT
Read --SelectionKey.OP_READ
Write --SelectionKey.OP_WRITE
Channel trigger an event, the event has already explained Ready. Therefore, when the channel connection is successful to the server, that connect ready; accept ready is when the server accepts a request for connection channel; channel when the read data is read ready; channel has a writable data in write ready. (If you are interested in multiple events, use or ( "|") operator to connect)
SelectionKey
Call to register () returned a SelectionKey. SelectionKey registered on behalf of the channel in the Selector on this. When a Selector notify you when an incoming event, it is done by providing the event SelectionKey, SelectionKey user can also cancel the registration channel. Its properties are as follows:
Interest the SET at The (is a collection of events of interest to be selected)
READY the SET at The (channel ready collection)
Channel at The (get registered Channel)
Selector at The (get registered Selector)
Object attached AN (optional) (more information about an object or attach to the SelectionKey, to facilitate identification of a particular channel)
By selecting channels Selector
Once Selector registered with one or more channels, you can call several overloaded select () methods, which return to ready the channel.
int select (): obstruction to have at least one channel-ready on your event registration
int select (long timeout): and select the same, but the longest block the timeout milliseconds
int selectNow (): does not block, no matter what the channel is ready to return immediately
Once called select () method, which returns a value representing one or more channels ready. You can () will return SelectionKey in virtual channenl by selector.selectedKey
After calling select a thread is blocked, there are ways to return from select, as long as the other thread calls selector.wakeup on that object first thread calls the select method, blocked threads will be immediately returned.
If there are other thread calls wakeup, but there are no threads blocked on select methods, then the next call to select the thread immediately wakeup.
Call the close method after using the Selector, it will close all SelectionKey Selector and registered under the Selector invalid, the channel itself is not closed.
3.9. BufferedInputStream和BufferedOutputStream
I.e., to increase efficiency using the IO buffer, Common IO is read byte by byte, but with a buffer, a chunk of data can be read once
package cn.wh3t;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.RandomAccessFile;
import java.io.Reader;
public class AboutIO {
public static void bufferStream() throws IOException {
// TODO 自动生成的方法存根
File file = new File("G:/Java/hello3.text");
byte[] bytes = new byte[(int)file.length()];
InputStream is = new BufferedInputStream(new FileInputStream(file),2*1024);
//the total number of bytes read into the buffer, or -1 if there is no more data because the end ofthe stream has been reached.
int size = is.read(bytes);
System.out.println("大小："+size+"内容："+new String(bytes));
is.close();
}
public static void main(String[] args) throws IOException {
//writeByte2File();
//readFile2Bytes();
//writeChar2File();
//readFile2Char();
//byte2Char();
//fileOption();
//randomReadFile();
//pipedStream();
bufferStream();
}
}
复制代码