1.O que é IO
As operações de E/S em Java referem-se principalmente ao uso de Java para operações de entrada e saída. Todos os mecanismos de E/S Java são baseados em fluxos de dados para entrada e saída. Esses fluxos de dados representam a sequência fluida de caracteres ou dados de bytes. Os fluxos de E/S do Java fornecem métodos padrão para leitura e gravação de dados. Qualquer objeto em Java que represente uma fonte de dados fornecerá métodos para ler e escrever seus dados em um fluxo de dados.
Java.io é o pacote principal para a maioria das classes de entrada/saída orientadas a fluxo de dados. Além disso, Java também fornece suporte para transmissão de bloco, e bloco IO é usado na biblioteca principal java.nio.
A vantagem do stream IO é que ele é simples e fácil de usar, mas a desvantagem é que é menos eficiente. O Block IO é muito eficiente, mas a programação é mais complicada.
Modelo Java IO:
O design do modelo IO do Java é excelente. Ele usa o padrão Decorator para dividir Streams por função. Você pode montar esses Streams dinamicamente para obter as funções necessárias. Por exemplo, se você precisar de um fluxo de entrada de arquivo em buffer, deverá usar uma combinação de FileInputStream e BufferedInputStream.
2. Conceitos básicos de fluxo de dados
O fluxo de dados é uma coleção de dados contínuos, assim como o fluxo de água em um cano de água. A água é fornecida pouco a pouco em uma extremidade do cano de água, e o que é visto na outra extremidade do cano de água é um fluxo contínuo. de água. O programa de gravação de dados pode gravar dados no pipeline de fluxo de dados, segmento por segmento. Esses segmentos de dados formarão um longo fluxo de dados em sequência. Para programas de leitura de dados, a segmentação do fluxo de dados durante a gravação não pode ser vista. Dados de qualquer comprimento podem ser lidos a cada vez, mas apenas os dados anteriores podem ser lidos primeiro e, em seguida, os dados subsequentes. Independentemente de os dados serem gravados em vários lotes ou como um todo de uma só vez, o efeito da leitura é exatamente o mesmo.
"Um fluxo é a origem ou destino dos dados armazenados em um disco ou outro dispositivo periférico."
Existem três maneiras de armazenar dados em um computador: uma é armazenamento externo, uma é memória e a outra é cache. Por exemplo, o disco rígido, o disco magnético, a unidade flash USB, etc. no computador são todos de armazenamento externo. Há um cartão de memória no computador e o cache está na CPU. O armazenamento externo tem a maior capacidade de armazenamento, seguido pela memória e, finalmente, pelo cache. Porém, a leitura dos dados do armazenamento externo é a mais lenta, seguida pela memória, e o cache é o mais rápido. Aqui está um resumo da leitura de dados da memória externa para a memória e da gravação de dados da memória para a memória externa. Para a compreensão da memória e do armazenamento externo, podemos simplesmente entendê-la como um contêiner, ou seja, o armazenamento externo é um contêiner e a memória é outro contêiner. Então, como ler os dados do contêiner de armazenamento externo no contêiner de memória e como salvar os dados do contêiner de memória no armazenamento externo?
Na biblioteca de classes Java, a parte IO é muito grande porque cobre uma ampla gama de campos:
Entrada e saída padrão, operações de arquivo, fluxos de dados na rede, fluxos de strings, fluxos de objetos, fluxos de arquivos zip, etc. Em Java, a abstração de entrada e saída é chamada de fluxo, que é como um cano de água conectando dois contêineres. A leitura de dados da memória externa para a memória é chamada de fluxo de entrada, e a gravação de dados da memória para a memória externa é chamada de fluxo de saída.
Fluxo é um conceito muito vívido Quando o programa precisa ler dados, ele abrirá um fluxo para a fonte de dados. Essa fonte de dados pode ser um arquivo, memória ou conexão de rede. Da mesma forma, quando o programa precisar gravar dados, ele abrirá um fluxo para o destino.
Os conceitos básicos resumidos são os seguintes:
Uma sequência ordenada de bytes com um ponto inicial e um ponto final. Incluindo fluxo de entrada e fluxo de saída.
2) Fluxo de entrada:O programa lê a fonte de dados do fluxo de entrada. As fontes de dados incluem o mundo externo (teclado, arquivos, rede...), que é o canal de comunicação que lê a fonte de dados no programa
O objetivo do uso de fluxos de dados é tornar a saída e a entrada independentes do dispositivo.
O Input Stream não se importa de qual dispositivo vem a fonte de dados (teclado, arquivo, rede)
O fluxo de saída não se importa para qual dispositivo os dados são destinados (teclado, arquivo, rede)
3. E/S padrão
Os programas Java podem trocar informações breves com o mundo exterior por meio de parâmetros de linha de comando. Ao mesmo tempo, também estipulam como trocar informações com dispositivos de entrada e saída padrão, como teclados e monitores. Por meio de arquivos, informações em qualquer formato de dados podem ser trocadas com o mundo exterior.
1. Parâmetros de linha de comandoResultados em execução:
args[0] é <Java>
args[1] é <C>
args[2] é <VB>
O fluxo de dados padrão que acompanha o sistema java: java.lang.System:
Perceber:
(1) A classe System não pode criar objetos e só pode usar seus três membros estáticos diretamente.
(2) Sempre que o método principal é executado, os três objetos acima são gerados automaticamente.
1) Fluxo de saída padrão System.out
System.out envia dados para o dispositivo de saída padrão e seu tipo de dados é PrintStream. método:
2) Fluxo de entrada padrão System.in
System.in lê dados do dispositivo de entrada padrão (obtém dados da entrada padrão, geralmente o teclado) e seu tipo de dados é InputStream. método:
3) Fluxo de erros padrão
System.err gera erro padrão e seu tipo de dados é PrintStream. Consulte a API para obter instruções detalhadas.
A saída padrão chama o método println por meio de System.out para gerar parâmetros e quebrar novas linhas, enquanto o método print gera parâmetros, mas não quebra novas linhas. O método println ou print implementa vários métodos de saída de tipos de dados básicos por meio de sobrecarga, incluindo tipos de parâmetros de saída boolean, char, int, long, float e double. Ao mesmo tempo, métodos cujos tipos de parâmetros de saída são char[], String e Object também ficam sobrecarregados. Entre eles, os métodos print(Object) e println(Object) chamarão o método toString do parâmetro Object em tempo de execução.
classe pública StandardInputOutput {
public static void main(String args[]) {
Sequências;
//Cria um leitor de buffer para ler dados linha por linha do teclado
InputStreamReader ir = novo InputStreamReader(System.in);
BufferedReader in = novo BufferedReader(ir);
System.out.println("Sistema Unix: ctrl-d ou ctrl-c para sair"
+ "/nSistema Windows: ctrl-z sair");
tentar {
//Lê uma linha de dados e envia-a para o monitor como padrão
s = in.readLine();
// Se ocorrer um erro de E/S quando o método readLine() estiver em execução, uma IOException será lançada.
enquanto (s! = nulo) {
System.out.println("Ler: " + s);
s = in.readLine();
}
//Fecha o leitor em buffer
in.close();
} catch (IOException e) { // Captura quaisquer exceções de IO.
e.printStackTrace();
}
}
}
4.arquitetura hierárquica java.IO
As coisas mais importantes em todo o pacote Java.io são 5 classes e uma interface. As cinco classes referem-se a File, OutputStream, InputStream, Writer e Reader; uma interface refere-se a Serializable. Depois de dominar essas operações principais de IO, você terá uma compreensão preliminar do sistema IO em Java.
Java I/O inclui principalmente os seguintes níveis, incluindo três partes:
1. A parte principal da parte de streaming IO;
2. A parte não-streaming inclui principalmente algumas classes que auxiliam a parte de streaming, tais como: classe File, classe RandomAccessFile e classe FileDescriptor;
3. Outras classes - classes relacionadas à segurança na parte de leitura de arquivos, como a classe SerializablePermission, e classes de sistema de arquivos relacionadas ao sistema operacional local, como a classe FileSystem, a classe Win32FileSystem e a classe WinNTFileSystem.
As principais classes são as seguintes:
1. Arquivo (características e gerenciamento de arquivos): usado para informações de descrição de arquivos ou diretórios, como geração de novos diretórios, modificação de nomes de arquivos, exclusão de arquivos, determinação do caminho do arquivo, etc.
2. InputStream (operação em formato binário): classe abstrata, operação de entrada baseada em bytes e é a classe pai de todos os fluxos de entrada. Define características comuns que todos os fluxos de entrada possuem.
3. OutputStream (operação em formato binário): classe abstrata. Operações de saída baseadas em bytes. É a classe pai de todos os fluxos de saída. Define características comuns que todos os fluxos de saída possuem.
Os caracteres em Java adotam o padrão Unicode. Um caractere tem 16 bits, ou seja, um caractere é representado por dois bytes. Para tanto, foram introduzidos fluxos para processamento de caracteres em JAVA.
4. Leitor (operação de formato de arquivo): classe abstrata, operação de entrada baseada em caracteres.
5. Gravador (operação de formato de arquivo): classe abstrata, operação de saída baseada em caracteres.
6. RandomAccessFile (operação de arquivo aleatório): possui funções ricas e pode realizar operações de acesso (entrada e saída) de qualquer local no arquivo .
A arquitetura do fluxo IO em Java é a seguinte:
5. Classe de arquivo sem streaming - Classe de arquivo
}
Descrição: Métodos da classe Arquivo:
(1) existe() testa se o arquivo ou diretório especificado existe no disco
(2) mkdir() cria o diretório especificado pelo objeto de arquivo (diretório de camada única)
(3) createNewFile() cria o arquivo especificado pelo objeto de arquivo
(4) list() retorna todas as strings de nomes de arquivos no diretório
6. Biblioteca de classes de fluxo Java.IO
O pacote java.io contém todas as classes necessárias para streaming de E/S. Existem quatro classes básicas no pacote java.io: classes InputStream, OutputStream, Reader e Writer, que lidam com fluxos de bytes e fluxos de caracteres, respectivamente:
E/S de fluxo de dados básico
entrada/saída
fluxo de bytes
fluxo de caracteres
fluxo de entrada
Fluxo de entrada
Leitor
fluxo de saída
Fluxo de saída
Escritor
Várias outras variações de fluxos em Java são derivadas deles:
A versão JDK1.4 começou a introduzir uma nova biblioteca de classes de E/S, que está localizada no pacote java.nio. A nova biblioteca de classes de E/S usa canais e buffers para melhorar a eficiência das operações de E/S.
No pacote java.io, java.io.InputStream representa o fluxo de entrada de bytes e java.io.OutputStream representa o fluxo de saída de bytes, que está no nível superior do pacote java.io. Ambas as classes são classes abstratas, o que significa que não podem ser instanciadas e devem ser subclassificadas para atingir determinadas funções.
1. Classificação específica dos fluxos IO1. Classificação geral por tipo de E/S:
1. Memória 1) Ler e gravar dados de/para a matriz de memória: CharArrayReader, CharArrayWriter, ByteArrayInputStream, ByteArrayOutputStream
2) Ler e gravar dados de/para strings de memória StringReader, StringWriter, StringBufferInputStream
2. Pipe pipeline implementa entrada e saída de pipeline (comunicação entre processos): PipedReader, PipedWriter, PipedInputStream, PipedOutputStream
3. Fluxo de arquivo de arquivo . Ler e gravar arquivos: FileReader, FileWriter, FileInputStream, FileOutputStream
4. Entrada e saída do objeto ObjectSerialization : ObjectInputStream, ObjectOutputStream
5. O fluxo de dados DataConversion lê e grava de acordo com os tipos de dados básicos (os dados processados são os tipos básicos de Java (como booleanos, bytes, inteiros e números de ponto flutuante)): DataInputStream, DataOutputStream
6. A impressão inclui métodos de impressão convenientes: PrintWriter, PrintStream
7. O buffer armazena dados em cache ao ler ou gravar para reduzir o número de E/S: BufferedReader, BufferedWriter, BufferedInputStream, BufferedOutputStream
8. Filtragem de fluxo de filtragem , filtragem quando os dados são lidos ou gravados: FilterReader, FilterWriter, FilterInputStream, FilterOutputStream pass
9.Concatenação mescla entrada e conecta vários fluxos de entrada em um fluxo de entrada: SequenceInputStream
10. A contagem conta linhas ao ler dados: LineNumberReader, LineNumberInputStream
11.Peeking Ahead realiza a pré-leitura por meio do mecanismo de cache: PushbackReader, PushbackInputStream
12. A conversão entre bytes e caracteres converte o fluxo de bytes em um fluxo de caracteres de acordo com certos padrões de codificação/decodificação ou realiza a conversão reversa (Stream to Reader, classe de conversão Writer): InputStreamReader, OutputStreamWriter
2. Classificação por fonte de dados (destino):
1. Arquivo: FileInputStream, FileOutputStream, FileReader, FileWriter
2. byte[]: ByteArrayInputStream, ByteArrayOutputStream
3. Char[]: CharArrayReader, CharArrayWriter
4. String: StringBufferInputStream, StringReader, StringWriter
5. Fluxo de dados de rede: InputStream, OutputStream, Reader, Writer
7. Fluxo de bytes InputStream/OutputStream
InputStream é um fluxo de entrada de bytes. Ele próprio é uma classe abstrata e deve contar com suas subclasses para implementar várias funções. Essa classe abstrata é a superclasse de todas as classes que representam fluxos de entrada de bytes. Fluxos herdados de InputStream inserem dados no programa e a unidade de dados é bytes (8 bits);
InputStream é uma classe usada para inserir dados de bytes, portanto, a classe InputStream fornece três métodos de leitura sobrecarregados na classe Inputstream:
(1) public abstract int read(): lê um byte de dados e o valor de retorno é um valor do tipo int com os bits altos preenchidos com 0. Se o valor de retorno = -1, significa que nenhum byte foi lido e o trabalho de leitura foi encerrado.
(2) public int read(byte b[ ]): Leia b.length bytes de dados e coloque-os no array b. O valor de retorno é o número de bytes lidos. Este método é realmente implementado chamando o próximo método (3) public int read(byte b[ ], int off, int len): Leia até len bytes de dados do fluxo de entrada e armazene-os em um deslocamento de off no matriz b.
(4) public int available(): Retorna o número de bytes que podem ser lidos no fluxo de entrada. Nota: Se a entrada for bloqueada, o thread atual será suspenso. Se o objeto InputStream chamar este método, ele retornará apenas 0. Este método deve ser chamado por um objeto de subclasse que herda a classe InputStream para ser útil.
(5) public long skip (long n): Ignore n bytes no fluxo de entrada, o valor de retorno é o número de bytes realmente ignorados, pule alguns bytes para ler (6) public int close(): estamos após o uso, o stream que abrimos deve ser fechado.
Principais subcategorias:
1) FileInputStream usa um arquivo como um InputStream para realizar a operação de leitura do arquivo 2) ByteArrayInputStream: usa um buffer na memória como um InputStream 3) StringBufferInputStream: usa um objeto String como um InputStream
4) PipedInputStream: implementa o conceito de pipe, usado principalmente em threads 5) SequenceInputStream: mescla vários InputStreams em um InputStream
Principais subcategorias:
1) ByteArrayOutputStream: Armazena informações em um buffer na memória
2) FileOutputStream: Armazene informações em um arquivo
3) PipedOutputStream: implementa o conceito de pipe, usado principalmente em threads
4) SequenceOutputStream: mescla vários OutStreams em um OutStream
Determinação do fim do fluxo: quando o valor de retorno do método read() for -1; quando o valor de retorno de readLine() for nulo;
3. Fluxo de entrada de arquivo: classe FileInputStreamFileInputStream pode usar o método read() para ler um byte por vez e retorná-lo como um tipo int, ou usar o método read() para ler em uma matriz de bytes quantos bytes são lidos de acordo com o número de elementos na matriz de bytes. matriz de bytes. No processo de leitura ou gravação de um arquivo inteiro, essa matriz de bytes geralmente é usada como buffer, porque essa matriz de bytes geralmente desempenha um papel intermediário no recebimento de dados.
Como usar(2)
FileInputStream in=newFileInputStream(“d: /abc.txt”);
Exemplo de programa:
Exibir o conteúdo do programa InputFromFile.java no monitor
classe pública ArquivoTeste {
public static void main(String args[]) lança IOException {
tentar{
FileInputStream rf=new FileInputStream("InputFromFile.java");
int n=512; buffer de bytes[]=novo byte[n];
enquanto((rf.read(buffer,0,n)!=-1)&&(n>0)){
System.out.println(nova String(buffer));
}
System.out.println();
rf.close();
} catch(IOException IOe){
System.out.println(IOe.toString());
}
}
}
A classe FileOutputStream é usada para processar fluxos de dados que usam arquivos como destinos de saída de dados;
Existem duas maneiras de criar um objeto de fluxo de arquivos:
Caminho 1:
Arquivo f = novo arquivo ("d:/myjava/write.txt");
FileOutputStream out= novo FileOutputStream (f);
Caminho 2:
FileOutputStream out=new FileOutputStream("d:/myjava/write.txt ");
Método 3: O construtor usa o objeto FileDescriptor() como parâmetro.
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=novo FileOutputStream(fd);
Método 4: O construtor usa o nome do arquivo como primeiro parâmetro e um valor booleano como segundo parâmetro.
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
Nota: (1) Ao gravar dados em um arquivo, se o arquivo já existir, o arquivo existente será sobrescrito; (2) Quando a operação de leitura/gravação terminar, o método close deve ser chamado para fechar o fluxo;
}
classe pública ArquivoTeste {
public static void main(String args[]) lança IOException {
tentar {
Arquivo inFile = new Arquivo("copy.java");
Arquivo outFile = new Arquivo("copy2.java");
FileInputStream finS = new FileInputStream(inFile);
FileOutputStream foutS = new FileOutputStream(outFile);
interno c;
enquanto ((c = finS.read()) != -1) {
foutS.write(c);
}
finS.close();
foutS.close();
} catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
}
}
}
O acesso do computador a dispositivos externos é demorado. Quanto maior a frequência de acesso à memória externa, maior a probabilidade de a CPU ficar ociosa. Para reduzir o número de acessos à memória externa, mais dados devem ser lidos e gravados em um acesso ao periférico. Para tanto, além dos mecanismos de leitura e escrita necessários à troca de dados entre programas e nós de fluxo, também deverá ser adicionado um mecanismo de buffer. Fluxo em buffer significa que cada fluxo de dados recebe um buffer, e um buffer é uma memória que armazena dados temporariamente. Isto pode reduzir o número de acessos ao disco rígido e melhorar a eficiência da transmissão.
BufferedInputStream: Ao gravar dados no fluxo em buffer, os dados são primeiro gravados no buffer. Depois que o buffer estiver cheio, o sistema envia os dados para o dispositivo de saída de uma só vez.
BufferedOutputStream: Ao ler dados do fluxo em buffer, o sistema primeiro lê os dados do buffer. Quando o buffer está vazio, o sistema lê os dados do dispositivo de entrada para o buffer.
Conecte BufferedInputStream a FileInputStream
FileInputStreamin=newFileInputStream("arquivo1.txt");
BufferedInputStreambin=newBufferedInputStream(in);
2) Grave a memória no arquivo:
Conecte BufferedOutputStream a FileOutputStream
FileOutputStreamout=newFileOutputStream(“arquivo1.txt”);
BufferedOutputStreambin=newBufferedInputStream(fora);
classe pública ReadWriteToFile {
public static void main(String args[]) lança IOException {
InputStreamReader sin = novo InputStreamReader(System.in);
BufferedReader bin = novo BufferedReader(sin);
FileWriter out = new FileWriter("meuarquivo.txt");
BufferedWriter luta = new BufferedWriter(out);
Sequências;
enquanto ((s = bin.readLine()).length() > 0) {
bout.write(s, 0, s.length());
}
}
}
8. Escritor/Leitor de fluxo de caracteres
Os caracteres em Java adotam o padrão Unicode. Um caractere tem 16 bits, ou seja, um caractere é representado por dois bytes. Para tanto, foram introduzidos fluxos para processamento de caracteres em JAVA.
Classe abstrata para leitura de fluxos de caracteres. Os únicos métodos que as subclasses devem implementar são read(char[], int, int) e close(). No entanto, a maioria das subclasses substituirá alguns dos métodos definidos aqui para fornecer maior eficiência e/ou funcionalidade adicional.
1) FileReader: Correspondente a FileInputStream, é usado principalmente para ler arquivos de caracteres, usando a codificação de caracteres padrão e possui três construtores:
(1) Use o nome do arquivo como uma string: FileReader f=new FileReader(“c:/temp.txt”);
(2) O construtor toma o objeto File como parâmetro.
Arquivo f=novo arquivo(“c:/temp.txt”);
Leitor de arquivos f1=novo Leitor de arquivos(f);
(3) O construtor toma o objeto FileDescriptor como parâmetro
FileDescriptor() fd = novo FileDescriptor()
Leitor de arquivos f2=novo Leitor de arquivos(fd);
(1) Use a matriz de caracteres especificada como parâmetro: CharArrayReader(char[])
(2) Use a matriz de caracteres como fluxo de entrada: CharArrayReader(char[], int, int)
Para ler uma string, o construtor é o seguinte: public StringReader(String s);
2) CharArrayReader: corresponde a ByteArrayInputStream
3) StringReader: corresponde a StringBufferInputStream
4) Leitor de entradaStream
Leia bytes do fluxo de entrada e converta-os em caracteres: Public inputstreamReader(inputstream is);
5) FilterReader: permite filtrar fluxos de caracteres
filterReader protegido (Leitor r);
6) BufferReader: Aceita um objeto Reader como parâmetro e adiciona um buffer de caracteres a ele. Use o método readline() para ler uma linha.
BufferReader público(Leitor r);
Métodos principais:
(1) publicintread()throwsIOException;//Lê um caractere, o valor de retorno é o caractere lido
(2) publicintread(charcbuf[])throwsIOException;/*Lê uma série de caracteres no array cbuf[], e o valor de retorno é o número de caracteres realmente lidos*/
(3) publicabstractintread(charcbuf[],intoff,intlen)throwsIOException;
/*Lê os caracteres len e armazena-os a partir do subscrito do array cbuf[]. O valor de retorno é o número real de caracteres lidos. Este método deve ser implementado por uma subclasse*/.
Classe abstrata para escrever em fluxos de caracteres. Os únicos métodos que as subclasses devem implementar são write(char[], int, int), flush() e close(). No entanto, a maioria das subclasses substituirá alguns dos métodos definidos aqui para fornecer maior eficiência e/ou funcionalidade adicional. Suas subcategorias são as seguintes:
1) FileWrite: corresponde a FileOutputStream e grava dados do tipo de caractere em um arquivo, usando a codificação de caracteres padrão e o tamanho do buffer.
FileWrite público (arquivo f);
2) chararrayWrite: Corresponde a ByteArrayOutputStream, usando o buffer de caracteres como saída.
CharArrayWrite() público;
3) PrintWrite: Gera saída formatada public PrintWriter (outputstream os);
4) filterWriter: usado para escrever filtro de fluxo de caracteres protegido FilterWriter (Writer w);
5) PipedWriter: corresponde a PipedOutputStream
6) StringWriter: Não há fluxo orientado a bytes correspondente
Métodos principais:
(1) publicvoidwrite(intc)throwsIOException; //Escreve os 16 bits inferiores do valor inteiro c no fluxo de saída (2) publicvoidwrite(charcbuf[])throwsIOException; //Escreve a matriz de caracteres cbuf[] no fluxo de saída ( 3) publicabstractvoidwrite(charcbuf[],intoff,intlen) throwsIOException; //Escreve caracteres len começando do índice na matriz de caracteres cbuf[] para o fluxo de saída (4) publicvoidwrite(Stringstr)throwsIOException; str são gravados no fluxo de saída (5) publicvoidwrite(Stringstr,intoff,intlen)throwsIOException; //Escreve caracteres len começando do índice off na string str para o fluxo de saída (6) flush() //Libera o fluxo de saída e gera todas as palavras em cache Festival.
(7)close() fecha o fluxo publicabstractvoidclose()throwsIOException
3. A diferença entre InputStream e Reader, a diferença entre OutputStream e Writer
public static void main(String args[]) lança IOException {
System.out.println("A codificação de caracteres Unicode é usada na memória: ");
char c='bom';
int bit baixo=c&0xFF; int bit alto=(c&0xFF00)>>8;
System.out.println(""+lowBit+" "+highBit);
String s="OK";
System.out.println("Codificação de caracteres padrão do sistema operacional local:");
readBuff(s.getBytes());
System.out.println("Usando codificação de caracteres GBK:");
readBuff(s.getBytes("GBK"));
System.out.println("Codificação de caracteres UTF-8:");
readBuff(s.getBytes("UTF-8"));
}
9. Subclasses da classe de exceção IOException
1. classe pública EOFException:
Esse tipo de exceção é lançado quando o final do arquivo ou do fluxo de entrada é atingido de forma anormal.
2.classe pública FileNotFoundException:
Exceção lançada quando o arquivo não pode ser encontrado.
3. classe pública InterruptedIOException:
Esse tipo de exceção é lançado quando uma operação de E/S é interrompida.