Um, IO fluxo Resumo e Classificação
1 Visão geral: fluxo de IO para processar a transferência de dados entre os dispositivos, as operações de Java sobre o fluxo de dados por meio de, objetos Java para o fluxo de operação do pacote de IO
2, fluxo IO a classificação
de acordo com o fluxo de dados
| fluxo de entrada | fluxo de saída |
|---|---|
| dados Leia | gravar dados |
De acordo com os tipos de dados
| fluxo de bytes | fluxo de caracteres |
|---|---|
| Você pode ler e escrever arquivos de qualquer tipo, tais como arquivo de texto de vídeo e áudio | Você pode ler e escrever arquivos de texto |
| fluxo de bytes classe base Resumo: InputStream, o OutputStream | fluxos caráter de classe base abstrata: leitor, escritor |
| Byte fluxo de entrada InputStream, saída de bytes fluxo OutputStream | Character-entrada fluxo Reader, personagem de saída de fluxo de escritor |
Nota : Este é derivado de quatro classe base abstrata é um nome subclasse como um sufixo ao nome do nome de seu pai subclasse.
Segundo, o fluxo de caracteres
1, os dados FileOutputStream write
①, construtor de
FileOutputStream (arquivo de arquivo) // criar um arquivo para gravar o arquivo de dados representado pelo objeto File especificado no fluxo de saída.
FileOutputStream (String name) // criar uma gravação de dados em um arquivo com o nome especificado do fluxo de arquivo de saída.
②, FileOutputStream três write () método
de gravação public void (int b): uma gravação byte mais do que um byte na frente do corte bytes
de gravação public void (byte [] b ): Adicione uma matriz de bytes
de gravação public void (byte [] b, int fora , int len): escrever uma parte da matriz de bytes
③, os dados de escrita FileOutputStream escrita adicional implementar e de avanço de linha
| janelas | Linux | Mac |
|---|---|---|
| \ R \ n | \ n | \ r |
FileOutputStream (String nome, boolean append) , parâmetro 2 representando se a escrita adicional
exemplo: FileOutputStream out = new FileOutputStream ( " b.txt", true); // true representa escrita adicional
public class MyIODemo {
public static void main(String[] args) throws IOException {
//参2 代表是否追加写入
//FileOutputStream(String name, boolean append)
//创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileOutputStream out = new FileOutputStream("b.txt",true);//true 表示追加写入
out.write(97); //一次写入一个字节
out.write(98);
//写入一个字节数组
out.write("\r\n".getBytes());//换行
out.write("像我这样优秀的人，本该灿烂过一生".getBytes());
out.write("\r\n".getBytes());
//写入字节数组的一部分 从某个索引开始，写多少个字节
out.write("怎么二十多年到头来，还在人海里浮沉".getBytes(),0,27);
out.write("\r\n".getBytes());
//流使用完毕之后，必须释放资源
out.close();
}
}
3, FilelnputStream ler dados
①, o byte de entrada é obtido a partir do sistema de ficheiros, um ficheiro
②, FilelnputStream (String nome)
ligado a um ficheiro real a ser criada pela abertura de um FilelnputStream, o ficheiro através do nome de caminho sistema de arquivo nome especificado.
③, FileInputStream (arquivo Arquivo)
Cria um FileInputStream, abrindo uma conexão com o arquivo real, o arquivo especificado pelo arquivo de objeto de arquivo do sistema de arquivos.
④, fluxo de entrada de ficheiro, não há erro se está associada é relatado
int ler (): lido um byte, ineficiente
byte [] = new bytes new byte [1024];
int len = in.read (bytes) ; // ler uma vez valor de retorno é um array de bytes que você ler o número de bytes de válido
Nota: depois que o fluxo após o uso, os recursos devem ser liberados
4 de entrada e saída de bytes a eficiência do fluxo
BufferedOutputStream (OutputStream out) Criar um novo fluxo de saída tamponada a gravação de dados para o fluxo de saída especificado subjacente.
BufferedInputStream (InputStream in) Cria um BufferedInputStream e salva seu argumento, o fluxo de entrada no, para uso posterior.
Substancialmente a mesma utilização eficiente da entrada e saída de fluxos substancialmente byte corrente
5, Processo
分别使用使用高效字节流和基本字节流复制文件
public class MyDemo3 {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
copy2(); //耗时18542毫秒 耗时13802毫秒
copy1(); //耗时14046毫秒 耗时14331毫秒
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
private static void copy2() throws IOException {
FileInputStream in = new FileInputStream("E:\\我的图片和音乐\\疯狂动物城.mp4");
FileOutputStream out = new FileOutputStream("D:\\疯狂动物城.mp4");
//创建一个数组缓冲区
byte[] bytes = new byte[1024*8];
int len = 0; //记录读取到的有效的字节个数
while ((len = in.read(bytes)) != -1) {
out.write(bytes, 0, len);
out.flush();
}
in.close();
out.close();
}
private static void copy1() throws IOException {
BufferedInputStream in = new BufferedInputStream(new FileInputStream("E:\\我的图片和音乐\\疯狂动物城.mp4"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\疯狂动物城.mp4"));
byte[] bytes = new byte[1024*8];
int len=0;
while ((len=in.read(bytes))!=-1){
out.write(bytes,0,len);
}
out.close();
in.close();
}
}
Terceiro, o fluxo de caracteres
1 por causa do fluxo de caracteres aparece : operações chinesas fluxo devido byte não é particularmente conveniente, portanto, java fornece um fluxo de caracteres.
= + Tabela Byte fluxo de caracteres de código corrente
2, classe de cadeia de codificação e descodificação de problemas na
codificação : a cadeia é convertida em uma matriz de bytes, a leitura pode ler no
- public byte [] getBytes (); usando conjunto padrão de codificação de caracteres da plataforma é byte string esta sequência, armazenando o resultado num novo array de bytes.
- public byte [] getBytes (String charsetName) utilizando o conjunto de caracteres especificado codificação esta corda é uma sequência de bytes, e armazenando o resultado num novo array de bytes.
Decodificação : a conversão de matriz de bytes em uma string, na leitura pode entender
- public String (byte [] bytes): Especifica o conjunto de caracteres padrão usando a matriz de bytes internet decodificado, uma nova cadeia de construção.
- public String (byte [] bytes, String charsetName) matriz de bytes especificado, utilizando o conjunto de caracteres de descodificação especificado, construir uma nova cadeia.
3, a utilização de comutações OutputStreamWriter
①, OutputStreamWriter
é um personagem ponte fluxos de fluxo de bytes: a tabela de código pode ser usado para especificar o código de caracteres gravados para o fluxo em bytes. Ele usa o conjunto de caracteres pode ser especificado pelo nome ou explicitamente dado, caso contrário ele irá aceitar conjunto de caracteres padrão da plataforma.
②, o construtor
a: OutputStreamWriter (OutputStream out) // criar o OutputStreamWriter caracteres padrão de codificação.
b: OutputStreamWriter (fora OutputStream, Charset cs) // Cria um OutputStreamWriter determinado conjunto de caracteres.
Nota: O arquivo associado com o fluxo de saída, e se não, o sistema criará automaticamente
③, 5 Zhong escrever caracteres os fluxos de dados maneira
public void write(int c) 写一个字符
public void write(char[] cbuf) 写一个字符数组
public void write(char[] cbuf,int off,int len) 写一个字符数组的 一部分
public void write(String str) 写一个字符串
public void write(String str,int off,int len) 写一个字符串的一部分
举例：
public class MyDemo {
public static void main(String[] args) throws IOException {
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("a.txt"));
//往文件中写入数据
out.write('尼'); //一次写入一个字符
out.write("\r\n");
out.flush();
out.write("我爱学java");
out.write("\r\n");
out.flush();
out.write("路慢慢慢其修远兮，吾将上下而求索", 0, 8);
out.write("\r\n");
out.flush();
out.write(new char[]{'a', '9', 98, 'e'});
out.write("\r\n");
out.write(new char[]{'我', '爱', '你', '们'}, 2, 2);
out.write("\r\n");
//字符流 需要将数据从缓冲区刷新过去
out.flush();
out.close(); //刷新并关闭
}
}
4, a conversão usando o fluxo InputStreamReader
① construtor
InputStreamReader (InputStream é): lendo a codificação padrão (GBK) dados
InputStreamReader (InputStream é, String charsetName) : ler os dados codificados com o especificado
dois tipos de leitura ②, o fluxo de caracteres forma dos dados
int pública ler () para ler um carácter
int pública de leitura (char [] cbuf ) lê uma matriz de caracteres ou -1, se não ler
public class CopyFile2 {
public static void main(String[] args) throws IOException {
InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
OutputStreamWriter out = new OutputStreamWriter(newFileOutputStream("b.txt"));
//创建一个字符缓冲区
char[] chars = new char[100];
int len = 0; //len 是记录 你每次读取到的有效的字符个数
while ((len=in.read(chars)) != -1) {
out.write(chars, 0, len);//
out.flush(); //字符流记得刷新一下
}
//释放资源
in.close();
out.close();
}
}
5, conveniente classes de fluxo de caracteres
porque o nome é a conversão de fluxo muito tempo, e nós não precisamos de desenvolver o conjunto de caracteres em geral, de modo java nos dar fácil conversão correspondente à classe fluxo. A única desvantagem é que você não pode especificar a codificação.
| fluxo de conversão | classe de conveniência |
|---|---|
| OutputStreamWriter | FileWriter |
| InputStreamReader | FileReade |
FileWriter (Ficheiro); Constrói um objeto FileWriter dado um objeto File.
FileWriter (String nomeArquivo); configurado objeto FileWriter dado um nome de ficheiro.
6, um personagem eficiente fluxo Livro entrada
①, fluxo de saída de caracteres eficiente: BufferedWriter // gravar dados
construtor: BufferedWriter público, (escritor W)
②, eficiente fluxo de entrada de caracteres: BufferedReader // dados lidos
construtor: BufferedReader pública (leitor e)
função especial ③, personagem buffer de fluxo
BufferedWriter: novaLinha public void (): o sistema determina o sistema de alimentação de linha de quebra de linha tendo compatibilidade.
BufferedReader: readLine public String (): uma vez ler uma linha de dados é lido nova linha nova linha é marcado no embrulho podia ler retornos de dados nulo.
举例：//使用高效的字符流，采用读取一行，写入一行的方式来复制文本文件
public class MyDemo8 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("a.txt"));
//BufferedWriter(Writer out)
//创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter out = new BufferedWriter(new FileWriter("b.txt"));
String line=null; //记录每次读取到的一行文本
while ((line=in.readLine())!=null){ //这里注意读取不到返回null
out.write(line);
out.newLine(); //写入一个换行符
out.flush();//刷新
}
//释放资源
out.close();
in.close();
}
}
