basic i o operations java
Neste tutorial em vídeo, discutiremos o mecanismo de entrada-saída Java, como entrada do usuário Java, InputStream, Java Printf, Println, etc. com dispositivos de E / S padrão:
Em todas as linguagens de programação, precisamos ter um mecanismo para ler os dados de entrada e também enviar os dados processados, também conhecido como Saída para o usuário final.
Como você sabe, existem muitos dispositivos de entrada e saída no mundo do software que os programadores podem usar para ler e gravar ou enviar dados.
Leia nosso Série completa de treinamento Java para obter mais informações sobre os conceitos Java.
O que você aprenderá:
- Tutorial de vídeo sobre operações básicas de E / S em Java
- Exemplos adicionais - fluxos de entrada / saída
- Conclusão
Tutorial de vídeo sobre operações básicas de E / S em Java
Usando um programa Java, você pode ler e gravar dados de diferentes origens e destinos. Ler e gravar fontes de dados e destinos incluem:
- arquivos
- Tubos
- Conexões de rede
- Buffers na memória ( Por exemplo: matrizes)
- System.in, System.out, System.error
Neste tutorial em vídeo, teremos a entrada como um arquivo e exploraremos várias classes, interfaces e métodos que estão disponíveis para ler dados do arquivo.
Operações básicas de IO em Java:
Operações de arquivo Java:
E / S Java (entrada-saída) é um mecanismo padrão que processa a entrada e gera a saída. O pacote “java.io” contém os métodos para realizar todas as operações de entrada e saída.
Para realizar operações de I / O mais rapidamente, Java usa o conceito de fluxos. Um fluxo pode ser definido como uma sequência de dados que consiste em bytes.
Vamos aprender mais sobre os fluxos de I / O Java !!
Streams de E / S padrão em Java
A linguagem Java oferece acesso aos recursos do sistema, dispositivos de entrada-saída padrão, etc. usando uma classe “Sistema”. Esta classe implementa uma interface de programação dependente do sistema para acessar vários recursos.
A classe System pertence ao pacote “java.lang” do Java. Além de fornecer fluxos de E / S padrão, a classe System também fornece acesso a variáveis de ambiente, variáveis externas, carregamento de arquivos e bibliotecas e também um método utilitário arrayCopy para copiar parte de um array.
Como este tutorial é baseado apenas em E / S padrão, ignoraremos o restante dos recursos fornecidos pela classe System aqui.
Do ponto de vista de entrada-saída, a classe System oferece os seguintes fluxos:
# 1) Fluxo de entrada padrão (System.in)
O fluxo de entrada fornecido pela classe System, System.in, é usado para ler os dados de entrada de um dispositivo de entrada padrão como um teclado.
O fluxo permanece aberto e está pronto para ler os dados fornecidos pelo usuário ao dispositivo de entrada padrão.
O exemplo a seguir demonstra a função System.in.read para ler um único dígito inteiro.
public class Main { public static void main(String args()) throws java.io.IOException { int ch; System.out.println('Enter the character to be displayed : '); ch = System.in.read(); System.out.println('You entered : ' + (char)ch); } }Resultado:
perguntas básicas da entrevista em html e css
# 2) Fluxo de saída padrão (System.out)
A interface System.out da classe System é usada para gravar a saída do programa no dispositivo de saída padrão como o monitor. Na maioria dos casos, a interface System.out grava a saída do comando no dispositivo de saída padrão.
Ele usa três métodos da classe “PrintStream”, já que a saída padrão deriva dessa classe.
Esses métodos são:
- imprimir
- println
- Escreva
Os métodos “print” e “println” têm a mesma funcionalidade, exceto por uma única diferença de que o método println anexa um caractere de nova linha ( n) à saída.
O método de gravação não é usado com frequência, exceto nos casos em que dados não ASCII devem ser exibidos.
O exemplo a seguir demonstra o fluxo System.out.
public class Main { public static void main(String args()) throws java.io.IOException { String stringType = 'Java Tutorial Series'; char() charTypeArray = { 'a', 'e', 'i', 'o', 'u' }; boolean booleanType = true; int integerType = 10; double doubleType = Math.PI; long longType = Long.MAX_VALUE; float floatType = Float.MIN_VALUE; System.out.println('String::' + stringType); System.out.print('Character::'); System.out.println(charTypeArray); System.out.println('Boolean::' + booleanType); System.out.println('Integer::' + integerType); System.out.println('Double::' + doubleType); System.out.println('Long::' + longType); System.out.println('Float::' + floatType); } } Resultado:
O programa acima mostra as funções “print” e “println” usadas com a interface System.out. Aqui, definimos variáveis de diferentes tipos de dados e exibimos cada um deles usando a interface System.out.
# 3) Fluxo de erro padrão (System.err)
O fluxo de erro padrão, System.err, é usado para exibir erros, se houver, durante a execução do programa.
Como o fluxo System.out, o fluxo de erro também suporta os três métodos da classe PrintStream, print, println e write.
Métodos para ler a entrada do console
Além do fluxo de entrada descrito acima, existem mais alguns métodos usando os quais podemos ler dados de entrada do console em Java.
Esses métodos são discutidos abaixo.
# 1) Classe BufferedReader
A classe BufferedReader foi introduzida pela primeira vez no JDK 1.0 e é o método clássico de leitura de dados de entrada do console.
O fluxo de entrada (System.in) é encapsulado na classe InputStreamReader que, por sua vez, é encapsulada em BufferedReader.
O programa a seguir mostra o uso da classe BufferedReader para ler dados de entrada do usuário.
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main { public static void main(String() args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); System.out.println('Enter the input string'); String name = reader.readLine(); System.out.println('You entered: ' + name); } } Resultado:
eu preciso de um endereço de e-mail falso
No programa acima, declaramos um objeto da classe BufferedReader inicializado no fluxo System.in. Usando este objeto, lemos uma linha inteira de entrada.
Como você pode ver, você pode ler todos os dados armazenados em buffer, tornando essa funcionalidade muito eficiente. A única desvantagem é o código críptico que pode ser difícil de lembrar o tempo todo.
# 2) Classe de console
A classe “System.console” pode ser usada para ler a entrada do console. Isso é usado especialmente para ler caracteres de entrada como uma senha da linha de comando.
O método de leitura de dados de entrada usando a classe do console é atualmente o método mais eficiente e preferido em Java.
O programa a seguir demonstra a classe System.console.
public class Main { public static void main(String() args) { System.out.println('Enter the input string'); String name = System.console().readLine(); System.out.println('You entered: ' + name); } } Resultado:
Usando a classe System.console, você pode ler os caracteres de entrada sem ecoar os caracteres. Portanto, esse método é mais útil para ler senhas. Em segundo lugar, você também pode usar strings de formato para formatar os dados de entrada, semelhantes aos usados em System.out.printf ().
Embora essa seja a maneira preferida de ler dados de entrada, observe que a classe System.console não pode ser usada com um ambiente Java interativo como IDEs.
# 3) Scanner
Usar uma classe de scanner para ler dados de entrada é provavelmente o método mais rápido e preferido. O scanner é usado principalmente para analisar os tipos de dados, incluindo tipos primitivos e strings. Mas também pode ser usado para ler os dados de entrada e analisá-los usando a entrada tokenizada.
A classe scanner usa expressões regulares para esse propósito.
O programa a seguir lê os dados de entrada do usuário usando a classe de scanner.
import java.util.Scanner; class Main { public static void main(String args()) { Scanner myscan = new Scanner(System.in); System.out.println('Enter the input:'); String mystr = myscan.nextLine(); System.out.println('You entered a string:'+mystr); System.out.println('Enter Next input:'); int num = myscan.nextInt(); System.out.println('You entered an integer:'+num); } } Resultado:
No programa acima, usamos a classe scanner para ler a string e os dados inteiros.
Saída de formatação em Java usando printf
Já vimos como exibir a saída em um programa Java. Nesta seção, veremos como formatar essa saída. Fazemos uso da função printf da classe “PrintStream” junto com o fluxo “System.out” do Java para este propósito.
A função printf em Java é semelhante à função printf em C / C ++. Ao contrário das funções System.out.print e System.out.println que aceitam um único argumento, System.out.printf aceita mais de um argumento.
A seguir estão as variações da função printf em Java.
| Não | Protótipo de função | Descrição |
|---|---|---|
| 1 | System.out.printf (string); | Imprime uma string fornecida no argumento sem qualquer formatação |
| dois | System.out.printf (formato, argumentos); | Imprime a saída usando a string de formato especificada 'formato' e argumentos. |
| 3 | System.out.printf (localidade, formato, argumentos); | Imprime a saída usando a string de formato especificada, aplicando a localidade e os argumentos. |
Observe que a função System.out.format () é igual a System.out.printf ().
A sintaxe geral para especificar a string de formato é a seguinte:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.Por exemplo:
System.out.println(“ ‘%05.2f’%n”, 2.28);Irá gerar a seguinte saída:
‘02,28’
Discutiremos printf em Java em detalhes nos tópicos posteriores deste tutorial.
perguntas frequentes
Q # 1) O que são entrada e saída padrão?
Responda: Os fluxos de entrada e saída padrão são canais pré-conectados para a comunicação entre o programa de computador e o ambiente externo quando o programa começa sua execução. Os três fluxos de E / S de padrões diferentes são entrada padrão (stdin), saída padrão (stdout), erro padrão (stderr).
Q # 2) O que é entrada padrão na programação?
Responda: A entrada padrão ou stdin é o fluxo usado para ler a entrada de um dispositivo de entrada padrão como um teclado.
Q # 3) O que é o fluxo de entrada-saída?
Responda: Um fluxo de entrada-saída representa uma fonte de onde você lê a entrada e o destino para o qual direciona sua saída.
Um fluxo, em geral, representa muitos dispositivos que são usados como origem e destinos, a saber, teclado, arquivo de disco, monitores, etc.
Q # 4) O que é entrada padrão em Java?
Responda: A entrada padrão em Java é fornecida pela classe System como um fluxo System.in. A classe System faz parte do pacote java.lang.
Q # 5) Qual é a saída padrão em Java?
Responda: A saída padrão em Java é fornecida pela classe System como um fluxo System.out. A classe System faz parte do pacote java.lang.
Exemplos adicionais - fluxos de entrada / saída
Os fluxos representam o fluxo de dados e esses dados podem estar em qualquer formato (como byte, texto, tipo de dados primitivo, etc). Para gravar dados em um destino, o fluxo de saída é usado e, para ler os dados, o fluxo de entrada é usado.
Diferentes formatos de leitura e escrita
A entrada / saída pode ser lida / escrita nos seguintes formatos diferentes:
# 1) Lendo arquivo como fluxo de bytes
Aqui, os dados serão lidos em formato de byte. “ FileInputStream ” e ' FileOutputStream “Classes são usadas para ler o conteúdo como um byte. Desta forma, para cada byte, o compilador enviará uma solicitação ao SO.
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class ByteStreamsDemo { public static void main(String() args) throws IOException { FileInputStream fin =null; FileOutputStream fout =null; try { fin=new FileInputStream('input.txt'); fout=new FileOutputStream('out.txt'); int c; while((c=fin.read() )!= -1) { fout.write(c); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { if(fin!=null) { fin.close(); }if(fout!=null) { fout.close(); } } } } 
# 2) Leitura de arquivo como fluxo de caracteres
Desta forma, o fluxo de entrada será lido em formato de caractere. Assim, para cada caractere, o compilador enviará uma solicitação ao SO. “ FileReader ” e ' FileWriter ” classes são úteis para ler o conteúdo como o personagem.
public class CharStreamDemo { public static void main(String() args) throws IOException { FileReader input = null; FileWriter output = null; try { input = new FileReader('input.txt'); output = new FileWriter('out1.txt'); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 3) Buffer do fluxo de entrada / saída
Ao usar as classes FileInputStream ou FileReader, para cada operação de leitura ou gravação, uma nova solicitação será enviada ao sistema operacional. Portanto, isso pode levar a problemas de desempenho. Para evitar esse BufferedInputStream ou BufferedReader, as classes são usadas para envolver as classes sem buffer.
Isso lê o fluxo de entrada quando o buffer está vazio.
Da mesma forma, FileOutputStream ou FileWriter, as classes são agrupadas com BufferedOutputStream ou BufferedWriter para gravar a saída quando o buffer estiver cheio.
public class BufferedStreamDemo { public static void main(String() args) throws IOException { BufferedReader input = null; BufferedWriter output = null; try { input = new BufferedReader(new FileReader('input.txt')); output = new BufferedWriter(new FileWriter('out1.txt')); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 4) Leitura como fluxo de dados
Neste método, o DataInputStream ou DataOutputStream, as classes são usadas para ler e gravar o conteúdo como tipos de dados primitivos, como boolean, char, byte, short, int, long, float, double e String. Principalmente o DataInputStream e o DataOutputStream serão usados juntos.
public class DataInputOutputStreamDemo { public static void main(String() args) { File file = new File('read.bin'); FileOutputStream fos = null; DataOutputStream dos = null; try { fos=new FileOutputStream(file); dos=new DataOutputStream(fos); dos.writeInt(50244); dos.writeDouble(400.253); dos.writeChar('d'); dos.flush(); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fos!=null){ fos.close(); } if(dos!=null){ dos.close(); } } catch (Exception e) { e.printStackTrace(); } } /*Reading operation */ FileInputStream fis = null; DataInputStream dis = null; try { fis = new FileInputStream(file); dis = new DataInputStream(fis); System.out.println(dis.readInt()); System.out.println(dis.readDouble()); System.out.println(dis.readChar()); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fis!=null){ fis.close(); } if(dis!=null){ dis.close(); } } catch (Exception e) { e.printStackTrace(); } } } } 
# 5) Lendo como fluxo de objeto
ObjectInputStream / ObjectOutputStream, classes são úteis para escrever objetos em um arquivo e ler os objetos do arquivo. Para armazenar o objeto em um arquivo, a classe deve implementar a interface serializável.
public class ObjectStreamDemo implements Serializable { int age ; String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 
Vamos criar um objeto para esta classe “ObjectStreamDemo” e vamos escrever esse objeto em um arquivo e ler o mesmo objeto daquele arquivo.
como abrir um arquivo dat no windows
public class ObjectStreamDemoTest { public static void main(String() args) { // TODO Auto-generated method stub ObjectStreamDemo obj=new ObjectStreamDemo(); obj.setAge(32); obj.setName('bob'); try { FileOutputStream fos = new FileOutputStream('t.tmp'); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(obj); oos.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } FileInputStream fis; ObjectInputStream ois; try { fis = new FileInputStream('t.tmp'); ois = new ObjectInputStream(fis); ObjectStreamDemo obj1 = (ObjectStreamDemo)ois.readObject(); System.out.println(obj1.name); System.out.println(obj1.age); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch(Exception e) { e.printStackTrace(); } } } 
Operações de I / O de arquivo
A classe de arquivo é útil para fazer operações de arquivo.
Algumas das operações de arquivo realizadas usando a classe File incluem:
- Crie um arquivo
- Verifique se o arquivo existe
- Obtenha o caminho do arquivo
- Grave o arquivo
- Leia o arquivo
- Exclua um arquivo e renomeie-o
- Verifique as permissões do arquivo e altere as permissões do arquivo
- Mova o arquivo de um diretório para outro local
Programa de demonstração para criar, ler e gravar o arquivo:
public class CreateFileDemo { public static void main(String() args) throws IOException { File newfile=new File('created.txt'); if(!newfile.exists()) { newfile.createNewFile(); System.out.println('file not exist'); } try { String FILENAME='created.txt'; String content='hi how are u'; FileWriter fwt = new FileWriter(FILENAME); BufferedWriter bwt = new BufferedWriter(fwt); bwt.write(content); System.out.println('writing completed ...'); bwt.close(); } catch (IOException e) { e.printStackTrace(); } } } 
Pontos-chave a serem observados:
- Um fluxo é uma representação lógica do fluxo de dados.
- Você pode ler / gravar dados em um formato diferente, como byte, caractere, objeto, tipo de dados primitivo.
- A classe de arquivo é usada para criar um arquivo, excluir o arquivo e mover ou copiar ou renomear o arquivo.
- BufferedInputStream ou BufferedOutputStream é usado para melhorar o desempenho armazenando os dados em buffer.
Conclusão
Java tem um pacote java.lang que fornece recursos de entrada e saída padrão usando a classe System.
Além dos streams, System.in e System.out, que são usados para entrada e saída padrão, respectivamente, há também outros métodos como BufferedReader, classe de console e classe de scanner que são usados para ler a entrada do usuário.
O fluxo System.out usa a função de classe “PrintStream”, print e println para exibir a saída. Estas são as funções usadas para exibir a saída sem formatação. Outra função “printf” que é semelhante à função printf em C / C ++ também é usada em Java para saída formatada.
Exploraremos mais a classe de scanner e a função printf em Java em nossos próximos tutoriais.
=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.
PREV Tutorial | PRÓXIMO Tutorial
Leitura recomendada
- Operações básicas de entrada / saída em C ++
- Operações de entrada de arquivo e saída em C ++
- Tutorial do Java Collections Framework (JCF)
- Implantação Java: Criação e execução de arquivo JAR Java
- Java Virtual Machine: como a JVM ajuda na execução de aplicativos Java
- Entrada-saída e arquivos em Python (Python abrir, ler e gravar em arquivo)
- Modificadores de acesso em Java - Tutorial com exemplos
- Tutorial de reflexão Java com exemplos