Respostas:
O objetivo InputStream
e OutputStream
é abstrair maneiras diferentes de entrada e saída: se o fluxo é um arquivo, uma página da Web ou a tela não deve importar. O que importa é que você receba informações do fluxo (ou envie informações para esse fluxo.)
InputStream
é usado para muitas coisas que você lê.
OutputStream
é usado para muitas coisas nas quais você escreve.
Aqui está um código de exemplo. Ele assume o InputStream instr
e OutputStream osstr
já foi criado:
int i;
while ((i = instr.read()) != -1) {
osstr.write(i);
}
instr.close();
osstr.close();
InputStream é usado para leitura, OutputStream para gravação. Eles são conectados como decoradores um ao outro, para que você possa ler / gravar todos os tipos diferentes de dados de todos os tipos diferentes de fontes.
Por exemplo, você pode gravar dados primitivos em um arquivo:
File file = new File("C:/text.bin");
file.createNewFile();
DataOutputStream stream = new DataOutputStream(new FileOutputStream(file));
stream.writeBoolean(true);
stream.writeInt(1234);
stream.close();
Para ler o conteúdo escrito:
File file = new File("C:/text.bin");
DataInputStream stream = new DataInputStream(new FileInputStream(file));
boolean isTrue = stream.readBoolean();
int value = stream.readInt();
stream.close();
System.out.printlin(isTrue + " " + value);
Você pode usar outros tipos de fluxos para aprimorar a leitura / gravação. Por exemplo, você pode introduzir um buffer para eficiência:
DataInputStream stream = new DataInputStream(
new BufferedInputStream(new FileInputStream(file)));
Você pode gravar outros dados, como objetos:
MyClass myObject = new MyClass(); // MyClass have to implement Serializable
ObjectOutputStream stream = new ObjectOutputStream(
new FileOutputStream("C:/text.obj"));
stream.writeObject(myObject);
stream.close();
Você pode ler de outras fontes de entrada diferentes:
byte[] test = new byte[] {0, 0, 1, 0, 0, 0, 1, 1, 8, 9};
DataInputStream stream = new DataInputStream(new ByteArrayInputStream(test));
int value0 = stream.readInt();
int value1 = stream.readInt();
byte value2 = stream.readByte();
byte value3 = stream.readByte();
stream.close();
System.out.println(value0 + " " + value1 + " " + value2 + " " + value3);
Para a maioria dos fluxos de entrada, também existe um fluxo de saída. Você pode definir seus próprios fluxos para ler / escrever coisas especiais e existem fluxos complexos para ler coisas complexas (por exemplo, existem fluxos para leitura / gravação no formato ZIP).
No Tutorial Java :
Um fluxo é uma sequência de dados.
Um programa usa um fluxo de entrada para ler dados de uma fonte, um item de cada vez:
Um programa usa um fluxo de saída para gravar dados em um destino, um item de cada vez:
A fonte de dados e o destino dos dados mostrados acima podem ser qualquer coisa que retém, gera ou consome dados. Obviamente, isso inclui arquivos de disco , mas uma origem ou destino também pode ser outro programa, dispositivo periférico, soquete de rede ou matriz .
Código de exemplo do tutorial da Oracle:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBytes {
public static void main(String[] args) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("xanadu.txt");
out = new FileOutputStream("outagain.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
} finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
Este byte usos programa de fluxos para copiar xanadu.txt arquivo para outagain.txt , escrevendo um byte de cada vez
Dê uma olhada nesta pergunta SE para saber mais detalhes sobre fluxos de caracteres avançados, que são wrappers sobre os fluxos de bytes:
você lê de um InputStream e grava em um OutputStream.
por exemplo, suponha que você deseja copiar um arquivo. Você criaria um FileInputStream para ler o arquivo de origem e um FileOutputStream para gravar no novo arquivo.
Se seus dados forem um fluxo de caracteres, você poderá usar um FileReader em vez de um InputStream e um FileWriter em vez de um OutputStream, se preferir.
InputStream input = ... // many different types
OutputStream output = ... // many different types
byte[] buffer = new byte[1024];
int n = 0;
while ((n = input.read(buffer)) != -1)
output.write(buffer, 0, n);
input.close();
output.close();
close
sempre flush
es, então não.
OutputStream é uma classe abstrata que representa a saída de gravação. Existem muitas classes OutputStream diferentes, e elas gravam em determinadas coisas (como a tela, arquivos, matrizes de bytes ou conexões de rede, etc.). As classes InputStream acessam as mesmas coisas, mas elas lêem dados delas.
Aqui está um bom exemplo básico do uso de FileOutputStream e FileInputStream para gravar dados em um arquivo e, em seguida, lê-los novamente.
Um fluxo é um fluxo contínuo de líquido, ar ou gás.
O fluxo Java é um fluxo de dados de uma origem para um destino. A origem ou destino pode ser um disco, memória, soquete ou outros programas. Os dados podem ser bytes, caracteres ou objetos. O mesmo se aplica aos fluxos de C # ou C ++. Uma boa metáfora para os fluxos Java é a água que escorre de uma torneira para a banheira e depois para a drenagem.
Os dados representam a parte estática do fluxo; os métodos de leitura e gravação são a parte dinâmica do fluxo.
InputStream
representa um fluxo de dados da fonte, OutputStream
representa um fluxo de dados para o destino. Finalmente, InputStream
e OutputStream
são abstrações sobre o acesso de baixo nível aos dados, tais como ponteiros de arquivo C.
Fluxo : em termos leigos, fluxo é dados, o fluxo mais genérico é a representação binária de dados.
Fluxo de entrada : se você estiver lendo dados de um arquivo ou de qualquer outra fonte, o fluxo usado é o fluxo de entrada. Em termos mais simples, o fluxo de entrada atua como um canal para ler dados.
Fluxo de saída : se você deseja ler e processar dados de uma fonte (arquivo etc.), primeiro é necessário salvar os dados, o meio para armazenar dados é o fluxo de saída.
Um fluxo de saída geralmente está relacionado a algum destino de dados, como um arquivo ou uma rede, etc. No fluxo de saída java é um destino em que os dados são eventualmente gravados e terminam
import java.io.printstream;
class PPrint {
static PPrintStream oout = new PPrintStream();
}
class PPrintStream {
void print(String str) {
System.out.println(str)
}
}
class outputstreamDemo {
public static void main(String args[]) {
System.out.println("hello world");
System.out.prinln("this is output stream demo");
}
}