--- a/PortugueseBook/Streams/Streams.tex
+++ b/PortugueseBook/Streams/Streams.tex
@@ -39,7 +39,7 @@ Fluxos podem ser facilmente convertidos para coleções e vice-versa.
 \section{Duas sequências de elementos}
 Uma boa metáfora para entender um fluxo é a seguinte: Um fluxo pode ser representada como duas sequências de elementos: a sequência de elementos visitados e a sequência de elementos a visitar. O fluxo é posicionado entre as duas sequências. Entender este modelo é importante uma vez que todos as operações de fluxo em \st dependem dele.
 Por esta razão, a maioria das classes de \clsind{Fluxo} são subclasses de \clsind{PositionableStream}.
-\figref{_abcde} apresenta um fluxo que contém cinco caracteres. Este fluxo está na sua posição original, \ie não há elementos já visitados. Você pode voltar a esta posição usando a mensagem \mthind{PositionableStream}{reset}.
+A \figref{_abcde} apresenta um fluxo que contém cinco caracteres. Este fluxo está na sua posição original, portanto a lista de elementos já visitados está vazia. Você pode voltar a esta posição usando a mensagem \mthind{PositionableStream}{reset}.
 
 \begin{figure}[ht]
 \centerline{\includegraphics[scale=0.5]{_abcdeStef}}
@@ -48,7 +48,7 @@ Por esta razão, a maioria das classes de \clsind{Fluxo} são subclasses de \cls
 \vspace{.2in}
 \end{figure}
 
-A leitura de um elemento conceitualmente significa remover o primeiro elemento da sequência de elementos a visitar e colocá-lo na sequência de elementos visitados. Após ter lido um elemento usando a mensagem \ct{next}, o estado do seu fluxo fica semelhante ao mostrado na \figref{a_bcde}.
+A leitura de um elemento conceitualmente significa remover o primeiro elemento da sequência de elementos a visitar e colocá-lo na sequência de elementos visitados. Após ter lido um elemento usando a mensagem \ct{next}, o estado do fluxo fica semelhante ao mostrado na \figref{a_bcde}.
 
 \begin{figure}[ht]
 \centerline{\includegraphics[scale=0.5]{a_bcdeStef}}
@@ -100,7 +100,7 @@ w := WriteStream on: (OrderedCollection new: 20).
 w nextPut: 12. -->  resulta numa excecao
 \end{code}
 
-Fluxos não são apenas direcionado a coleções, eles podem ser usados em arquivos ou sockets também. O exemplo a seguir cria um arquivo chamado \ct{test.txt}, escreve duas strings separadas por uma quebra de linha, e fecha o arquivo.
+Fluxos não são apenas direcionado a coleções, eles também podem ser usados em arquivos ou sockets. O exemplo a seguir cria um arquivo chamado \ct{test.txt}, escreve duas strings separadas por uma quebra de linha, e fecha o arquivo.
 
 \needlines{3}
 \begin{code}{}
@@ -113,7 +113,7 @@ StandardFileStream
 \end{code}
 \cmindex{FileStream class}{fileNamed:do:}
 
-As seções a seguir apresentam tais protocolos em mais detalhes.
+As seções a seguir apresentam tais protocolos em detalhes.
 
 %=============================================================
 \section{Criando fluxos a partir de coleções}
@@ -123,7 +123,7 @@ Fluxos são muito úteis quando trabalhamos com coleções de elementos, podendo
 %-----------------------------------------------------------------
 \subsection{Lendo coleções}
 
-Esta seção apresenta os recursos usados para a leitura de coleções. Ao usar um fluxo para ler uma coleção, você recebe um ponteiro para a coleção. Este ponteiro irá se mover para frente conforme a leitura é feita, e você pode posicionar este ponteiro onde desejar. A classe \clsindmain{ReadStream} deve ser usada par ler elementos de coleções.
+Esta seção apresenta os recursos usados para a leitura de coleções. Ao usar um fluxo para ler uma coleção, você recebe um ponteiro para a coleção. Este ponteiro irá se mover para frente conforme a leitura é feita, e você pode posicionar este ponteiro onde desejar. A classe \clsindmain{ReadStream} deve ser usada para fazer a leitura dos elementos.
 
 Os métodos \mthind{ReadStream}{next} e \mthind{ReadStream}{next:} são usados para obter um ou mais elementos da coleção.
 
@@ -231,27 +231,24 @@ result. -->   an OrderedCollection(1 1 2 3 4 4 5 9 10 11 12 13 13 14 15)
 %-----------------------------------------------------------------
 \subsection{Escrevendo em coleções}
 
-Nós acabamos de ver como iterar nos elementos de uma coleção usando \ct{ReadStream}. Agora nós iremos aprender como criar coleções usando \clsindmain{WriteStream}{}s.
+Nós acabamos de ver como iterar nos elementos de uma coleção usando \ct{ReadStream}. Agora nós iremos aprender como criar coleções usando a classe \clsindmain{WriteStream}{}.
 
-\ct{WriteStream}s are useful for appending a lot of data to a collection at various locations. They are often used to construct strings that are based on static and dynamic parts as in this example:
+\ct{WriteStream}s são úteis para incluir dados em vários pontos numa coleção. Esses objetos são frequentemente usados para construir strings baseadas em partes estáticas e dinâmicas, como no exemplo a seguir:
 
-\begin{code}{NB: can't be tested due to the changing number of classes}
+\begin{code}{NB: não pode ser testado em razão do número variável de classes.}
 stream := String new writeStream.
 stream
-  nextPutAll: 'This Smalltalk image contains: ';
+  nextPutAll: 'Esta imagem Smalltalk contem: ';
   print: Smalltalk allClasses size;
   nextPutAll: ' classes.';
   cr;
-  nextPutAll: 'This is really a lot.'.
+  nextPutAll: 'Muita coisa!'.
 
-stream contents. --> 'This Smalltalk image contains: 2322 classes.
-This is really a lot.'
+stream contents. --> 'Esta imagem Smalltalk contem: 2322 classes.
+Muita coisa!'
 \end{code}
 
-This technique is used in the different implementations of the method
-\ct{printOn:} for example. There is a simpler and more efficient way
-of creating streams if you are only interested in the content of the
-stream:
+Esta técnica é usada em diferentes implementações do método \ct{printOn:}, por exemplo. Existe uma forma mais simples e eficiente de criar fluxos se você está interessado apenas no seu conteúdo:
 
 \begin{code}{@TEST |string|}
 string := String streamContents:
@@ -267,33 +264,23 @@ string := String streamContents:
 string. -->   '#(1 2 3) size = 3'
 \end{code}
 
-The method \mthind{SequenceableCollection class}{streamContents:} \label{sec:streamContents} creates a collection and a stream on
-that collection for you. It then executes the block you gave passing
-the stream as a parameter. When the block ends, \ct{streamContents:}
-returns the content of the collection.
+O método \mthind{SequenceableCollection class}{streamContents:} \label{sec:streamContents} cria uma coleção e um fluxo para essa coleção. Ele então executa o bloco que foi passado como parâmetro. Quando o bloco termina, o método \ct{streamContents:} retorna o conteúdo da coleção.
 
-The following \ct{WriteStream} methods are especially useful in this context:
+O método \ct{WriteStream} a seguir é especialmente útil neste contexto:
 
 \begin{description}
-\item[\lct{nextPut:}] adds the parameter to the stream;
-\item[\lct{nextPutAll:}] adds each element of the collection, passed as a
-  parameter, to the stream;
-\item[\lct{print:}] adds the textual representation of the parameter to the
-  stream.
+\item[\lct{nextPut:}] adiciona o parâmetro ao fluxo;
+\item[\lct{nextPutAll:}] adiciona ao fluxo cada elemento da coleção passada como parâmetro;
+\item[\lct{print:}] adiciona ao fluxo a representação textual do parâmetro;
 	\cmindex{Stream}{print:}
 \end{description}
 
-There are also methods useful for printing different kinds of characters to
-the stream like \mthind{WriteStream}{space}, \mthind{WriteStream}{tab} and
-\mthind{WriteStream}{cr} (carriage return). Another useful
-method is \mthind{WriteStream}{ensureASpace} which ensures that the last character
-in the stream is a space; if the last character isn't a space it adds one.
+Ainda existem métodos úteis para imprimir diferentes tipos de caracteres ao fluxo como \mthind{WriteStream}{space}, \mthind{WriteStream}{tab} e \mthind{WriteStream}{cr} (\foreign{carriage return}). Outro método útil é \mthind{WriteStream}{ensureASpace}, que garante que o último caractere do fluxo seja um espaço; se não for, um espaço é adicionado.
 
-\paragraph{About Concatenation.}
-Using \mthind{WriteStream}{nextPut:} and \mthind{WriteStream}{nextPutAll:} on a \ct{WriteStream} is often the best way to
-concatenate characters. Using the comma concatenation operator (\ct{,}) is far
-less efficient:
-\index{Collection!comma operator}
+\paragraph{Sobre Concatenação.}
+Usando os métodos \mthind{WriteStream}{nextPut:} e \mthind{WriteStream}{nextPutAll:} num \ct{WriteStream} é, na maioria das vezes, a melhor forma de se concatenar caracteres. Usar o operador de concatenação (\ct{,}) é muito menos eficiente:
+
+\index{Coleção!operador vírgula}
 
 \begin{code}{}
 [| temp |
@@ -308,15 +295,9 @@ less efficient:
   temp contents] timeToRun --> 1262 "(milliseconds)"
 \end{code}
 
-The reason that using a stream can be much more efficient is that 
-comma creates a new string containing
-the concatenation of the receiver and the argument, so it must copy both of them.
-When you repeatedly concatenate onto the same receiver, it gets longer and longer each time,
-so that the number of characters that must be copied goes up exponentially.
-This also creates a lot of garbage, which must be collected. Using
-a stream instead of string concatenation is a well-known optimization.
+A razão de um fluxo ser muito mais eficiente é que a vírgula cria uma nova string contendo a concatenação do objeto receptor e do argumento, copiando então ambos os objetos. Quando você concatena repetidamente ao mesmo receptor, ele fica maior a cada vez, de modo que o número de caracteres que precisam ser copiados aumenta exponencialmente. Isso também cria muito lixo, que deve ser coletado. Usar um fluxo no lugar da concatenação de strings é uma otimização muito conhecida.
 \lr{About Concatenation. This is not true for real world examples (the example benchmark is unrealistic). Most of the time concatenation is simpler, cleaner and much faster, for example when being used on a small number of longer strings. (p. 257)}
-In fact, you can use \mthind{SequenceableCollection class}{streamContents:} (mentioned on page \pageref{sec:streamContents}) to help you do this:
+Na verdade, você pode usar \mthind{SequenceableCollection class}{streamContents:} (mencionado na página \pageref{sec:streamContents}) para te ajudar a fazer isso:
 
 \begin{code}{}
 String streamContents: [ :tempStream |
@@ -325,65 +306,62 @@ String streamContents: [ :tempStream |
 \end{code}
 
 %-----------------------------------------------------------------
-\subsection{Reading and writing at the same time}
+\subsection{Lendo e escrevendo ao mesmo tempo}
 
-It's possible to use a stream to access a collection for reading and
-writing at the same time.
-Imagine you want to create an \ct{History} class which will manage
-backward and forward buttons in a web browser.
-A history would react as in figures from \ref{fig:emptyStream} to
-\ref{fig:page4}.
+É possível usar um fluxo para acessar uma coleção para leitura e escrita ao mesmo tempo.
+Imagine que você queira criar uma classe \ct{History} que irá gerenciar os botões ``voltar'' e ``avançar'' em um navegador web. 
+O histórico reagiria de acordo com as figuras \ref{fig:emptyStream} a \ref{fig:page4}.
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{emptyStef}}
-\caption{A new history is empty. Nothing is displayed in the web browser.}
+\caption{O novo histórico está vazio. Nada é mostrado no navegador web.}
 \label{fig:emptyStream}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page1Stef}}
-\caption{The user opens to page 1.}
+\caption{O usuário abre a página 1.}
 \label{fig:page1}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page2Stef}}
-\caption{The user clicks on a link to page 2.}
+\caption{O usuário clica em um link para a página 2.}
 \label{fig:page2}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page3Stef}}
-\caption{The user clicks on a link to page 3.}
+\caption{O usuário clica em um link para a página 3.}
 \label{fig:page3}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page2_Stef}}
-\caption{The user clicks on the back button. He is now viewing page 2 again.}
+\caption{O usuário clica no botão ``voltar''. Ele está agora vendo a página 2 novamente.}
 \label{fig:page2_}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page1_Stef}}
-\caption{The user clicks again the back button. Page 1 is now displayed.}
+\caption{O usuário clica novamente no botão ``voltar''. A página 1 está agora sendo mostrada.}
 \label{fig:page1_}
 \vspace{.2in}
 \end{figure}
 
 \begin{figure}[!ht]
 \centerline{\includegraphics[scale=0.5]{page4Stef}}
-\caption{From page 1, the user clicks on a link to page 4. The history forgets pages 2 and 3.}
+\caption{Da página 1, o usuário clica em um link para a página 4. O histórico esquece das páginas 2 e 3.}
 \label{fig:page4}
 \vspace{.2in}
 \end{figure}
 
-This behaviour can be implemented using a \clsind{ReadWriteStream}.
+Este comportamento pode ser implementado sando um \clsind{ReadWriteStream}.
 
 \needlines{6}
 \begin{code}{}
@@ -398,34 +376,28 @@ History>>initialize
     stream := ReadWriteStream on: Array new.
 \end{code}
 
-Nothing really difficult here, we define a new class which contains a
-stream. The stream is created during the \ct{initialize} method.
+Nada de muito complicado aqui, apenas definimos uma nova classe que contém um fluxo. O fluxo é criado no método \ct{initialize}.
 
-We need methods to go backward and forward:
+Nós precisamos de métodos para voltar e avançar:
 
 \begin{code}{}
 History>>goBackward
-  self canGoBackward ifFalse: [self error: 'Already on the first element'].
+  self canGoBackward ifFalse: [self error: 'Ja estamos no primeiro elemento'].
   ^ stream back
 
 History>>goForward
-  self canGoForward ifFalse: [self error: 'Already on the last element'].
+  self canGoForward ifFalse: [self error: 'Ja estamos no ultimo elemento'].
   ^ stream next
 \end{code}
 
-Until then, the code was pretty straightforward. Now, we have to deal
-with the \ct{goTo:} method which should be activated when the user
-clicks on a link. A possible solution is:
+Até aqui, o código é bem simples. Agora, nós precisamos lidar com o método \ct{goTo:} que deve ser ativado quando o usuário clica em um link. Uma possível solução é:
 
 \begin{code}{}
 History>>goTo: aPage
     stream nextPut: aPage.
 \end{code}
 
-This version is incomplete however. This is because when the user
-clicks on the link, there should be no more future pages to go to,
-\ie the forward button must be deactivated. To do this, the simplest
-solution is to write \ct{nil} just after to indicate the history end:
+Esta versão está incompleta, entretanto. Isso porque quando o usuário clicar em um link, não deve mais haver páginas a se visitar, \ie o botão ``avançar'' deve ser desabilitado. Para fazer isso, a solução mais simples é escrever \ct{nil} em seguida para indicar o fim do histórico:
 
 \begin{code}{}
 History>>goTo: anObject
@@ -434,12 +406,9 @@ History>>goTo: anObject
   stream back.
 \end{code}
 
-Now, only methods \ct{canGoBackward} and \ct{canGoForward} have to be
-implemented.
+Agora, os métodos \ct{canGoBackward} e \ct{canGoForward} precisam ser implementados.
 
-A stream is always positioned between two elements. To go backward,
-there must be two pages before the current position: one page is the
-current page, and the other one is the page we want to go to.
+Um fluxo é sempre posicionado entre dois elementos. Para voltar, devem existir duas páginas anteriores à posição atual: uma página é a página atual, e a outra página é a página que queremos mostrar.
 
 \begin{code}{}
 History>>canGoBackward
@@ -449,13 +418,13 @@ History>>canGoForward
   ^ stream atEnd not and: [stream peek notNil]
 \end{code}
 
-Let us add a method to peek at the contents of the stream:
+Vamos adicionar um método para olhar o conteúdo do fluxo:
 \begin{code}{}
 History>>contents
   ^ stream contents
 \end{code}
 
-And the history works as advertised:
+E o histórico funciona como prometido:
 \begin{code}{}
 History new
 	goTo: #page1;
@@ -468,7 +437,7 @@ History new
 \end{code}
 
 %=============================================================
-\section{Using streams for file access}
+\section{Usando fluxos para acessar arquivos}
 
 You have already seen how to stream over collections of elements. It's
 also possible to stream over files on your hard disk.