Este artigo apresenta principalmente o uso dos fluxos Java InputStream.
(1) FileInputStream: subclasse, canal para leitura de dados
Etapas a serem usadas:
1. Obtenha o arquivo de destino: novo arquivo ()
2. Crie um canal: new FileInputString ()
3. Leia os dados: Leia ()
4. Recursos de liberação: Close ()
// Alguns pacotes a serem importados por importação de importação Java.io.file; importar java.io.fileInputStream; importar java.io.ioException;
public static void main (string [] args) lança IoException {// TODO Método Geralizado Auto test1 (); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------(2) Três maneiras de ler dados
1. Leia diretamente (apenas um byte de cada vez)
int date = fileInputStream.read (); char date3 = (char) fileInputStream.read ();
// Print public static void test1 () lança ioexception {// (1) Obtenha o arquivo do caminho do arquivo de destino FILE = novo arquivo ("c: //users//joke//desktop//demo1.java"); // (2) Crie um canal baseado no arquivo de alvo: o arquivo de alvo: novo arquivo de arquivo (file) (FileTream (File File); Dados: read (); int date = FileInputStream.read (); // aqui está int tipo int date2 = FileInputStream.read (); // char date3 = (char) fileInputStream.read (); // Show System.out.println (data+"//"+date2+"//"+date3); // (4) Libere o recurso FileInputStream.close ();}2. Uso apenas para loops (eficiência eficiência)
for (int i = 0; i <file.length (); i ++) {System.out.print ((char) fileInputStream.read ()); } // Método Troid Test2 () Test2 () lança IoException {// Eficiência de teste ao longo do tempo StartTime = System.currenttimemillis (); arquivo file = new File ("c: //users//Joke/Desktop/Demo1.java"); FileInputream Filein Filein FileAnTream (FileInpTream Filein Filein FileIn); = 0;3.Byte [] buffer (só pode ler o número especificado de bytes e não pode ler um arquivo completo)
byte [] bt = novo byte [1024]; int count = fileInputStream.read (bt); System.out.println (new String (BT, 0, contagem));
// Método 3 Crie um buffer (só pode ler o tamanho especificado, não ler um arquivo completo) public static void test3 () lança ioexception {arquivo file = new File ("c: //users//joke//desktop//demo1.java"); fileInputStream de fileIrtStream = new FileInputStream (FileIrtStream; ser lido byte [] bt = novo byte [1024]; // read () leia byte int conting = FileInputStream.read (bt); system.out.println (contagem); // Mostra o número de bytes Read System.out.println (new String (BT, 0, contagem)); // Converter bytes em string para exibir o FileInputStream.close ();}4. Combinando buffer e loop. O buffer geralmente é definido como um múltiplo de 1024. Quanto maior o conjunto de buffer, maior a eficiência da leitura.
byte [] bt = novo byte [1024]; int conting = 0; while ((count = FileInputStream.read (Bt))! = -1) {System.out.println (new String (Bt, 0, contagem)); } // Método Quatro loops são combinados com buffer (alta eficiência) public static void test4 () lança ioexception {// Eficiência de teste por tempo de longo tempo StartTime = system.currenttimemillis (); arquivo file = new File ("c: //users//Joke/Desktopin FilFTOP//Demo1.java"; O tampão geralmente é definido como múltiplo de 1024. Teoricamente, quanto maior o conjunto de tampões, maior o byte de eficiência de leitura [] Bt = novo byte [1024]; int conting = 0; // Quando read Retorna -1, é provado que (count (count thurn Display) System.out.println (new String (BT, 0, contagem));} FileInputStream.close (); long endtime = System.currenttimemillis (); System.out.println ("Tempo necessário para ler o arquivo:"+(Endtime-starttime));}Momo disse:
No exposto, comparando o segundo e o quarto métodos, você descobrirá que a eficiência do método 4 é relativamente alta, de modo que os quatro métodos recomendados são usados
Aqui nós jogamos diretamente exceções, além de jogar, também podemos usar
try{ }cater{ }finally{ }
Para lidar com exceções
O exposto acima é o uso do InputString (), o fluxo de entrada do java IO Stream apresentado a você. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!