--- a/PortugueseBook/Streams/Streams.tex
+++ b/PortugueseBook/Streams/Streams.tex
@@ -71,11 +71,9 @@ A escrita de um elemento significa substituir o primeiro elemento da sequência
 
 O protocolo de coleções suporta armazenamento, remoção e enumeração de elementos de uma coleção, mas não permite que essas operações sejam misturadas. Por exemplo, se os elementos de um \clsind{OrderedCollection} são processados por um método \mthind{OrderedCollection}{do:}, não é possível adicionar ou remover elementos dentro desse bloco \ct{do:}.
 Tampouco o protocolo de coleções fornece uma forma de se iterar em duas coleções ao mesmo tempo, escolhendo qual coleção avança e qual não avança. Procedimentos como este exigem que o índice transversal ou posição de referência seja mantido fora da própria coleção: é exatamente este o papel de \clsind{ReadStream}, \clsind{WriteStream} e \clsind{ReadWriteStream}.
-\clsind{ReadWriteStream}.
 
-These three classes are defined to \emph{stream over} some collection.
-For example, the following snippet creates a stream on an interval,
-then it reads two elements.
+Estas três classes são definidas para criar fluxos a partir de alguma coleção.
+Por exemplo, o trecho de código a seguir cria um fluxo a partir de um intervalo, e lê dois elementos.
 \needlines{5}
 \begin{code}{@TEST |r|}
 r := ReadStream on: (1 to: 1000).
@@ -84,7 +82,7 @@ r next.   --> 2
 r atEnd.--> false
 \end{code}
 
-\ct{WriteStream}s can write data to the collection:
+\ct{WriteStream}s podem escrever dados em uma coleção:
 \begin{code}{@TEST |w|}
 w := WriteStream on: (String new: 5).
 w nextPut: $a.
@@ -92,23 +90,17 @@ w nextPut: $b.
 w contents. -->  'ab'
 \end{code}
 
-It is also possible to create \ct{ReadWriteStream}s that support both
-the reading and writing protocols.
+Também é possível criar \ct{ReadWriteStream}s que suportem tanto o protocolo de leitura quanto o protocolo de escrita.
 
-The main problem with \ct{WriteStream} and \ct{ReadWriteStream} is
-that they only support arrays and strings in Squeak. This is currently
-being changed by the development of a new library named Nile, 
-but for now if you try to stream over another kind of
-collection, you will get an error:
+O principal problema com \ct{WriteStream} e \ct{ReadWriteStream} é que eles apenas suportam arrays e strings. Isso está sendo mudado com o desenvolvimento de uma nova biblioteca chamada Nile, mas por enquanto se você tentar criar fluxos a partir de outro tipo de coleção, você recebá um erro:
 
 \needlines{3}
 \begin{code}{}
 w := WriteStream on: (OrderedCollection new: 20).
-w nextPut: 12. -->  raises an error
+w nextPut: 12. -->  resulta numa excecao
 \end{code}
 
-Streams are not only meant for collections, they can be used for files or sockets
-too. The following example creates a file named \ct{test.txt}, writes two strings to it, separated by a carriage return, and closes the file.
+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.
 
 \needlines{3}
 \begin{code}{}
@@ -121,24 +113,19 @@ StandardFileStream
 \end{code}
 \cmindex{FileStream class}{fileNamed:do:}
 
-The following sections present the protocols in more depth.
+As seções a seguir apresentam tais protocolos em mais detalhes.
 
 %=============================================================
-\section{Streaming over collections}
+\section{Criando fluxos a partir de coleções}
 
-Streams are really useful when dealing with collections of
-elements. They can be used for reading and writing elements in
-collections. We will now explore the stream features for the
-collections.
+Fluxos são muito úteis quando trabalhamos com coleções de elementos, podendo ser usados tanto para ler quanto para escrever elementos em coleções. Nós iremos agora explorar os recursos dos fluxos para coleções.
 
 %-----------------------------------------------------------------
-\subsection{Reading collections}
+\subsection{Lendo coleções}
 
-This section presents features used for reading collections. Using a
-stream to read a collection essentially provides you a pointer into the collection. That pointer will move forward on reading and you can place it wherever you want. The class \clsindmain{ReadStream} should be used to read elements from collections.
+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.
 
-Methods \mthind{ReadStream}{next} and \mthind{ReadStream}{next:} are used to
-retrieve one or more elements from the collection.
+Os métodos \mthind{ReadStream}{next} e \mthind{ReadStream}{next:} são usados para obter um ou mais elementos da coleção.
 
 \begin{code}{@TEST |stream|}
 stream := ReadStream on: #(1 (a b c) false).
@@ -156,23 +143,18 @@ stream next: 3. -->   'bcd'
 stream next: 2. -->   'ef'
 \end{code}
 
-The message \mthind{PositionableStream}{peek} is used when you want to know what is the next element in
-the stream without going forward.
+A mensagem \mthind{PositionableStream}{peek} é usada quando você quer saber qual é o próximo elemento no fluxo sem precisar avançar.
 
 \begin{code}{@TEST |stream negative number|}
 stream := ReadStream on: '-143'.
-negative := (stream peek = $-).    "look at the first element without reading it"
+negative := (stream peek = $-).    "olha para o primeiro elemento sem avancar"
 negative. --> true
-negative ifTrue: [stream next].       "ignores the minus character"
+negative ifTrue: [stream next].       "ignora o caractere '-'"
 number := stream upToEnd.
 number. --> '143'
 \end{code}
 \noindent
-This code sets the boolean variable \ct{negative} according to the sign of the
-number in the stream and \ct{number} to its absolute value. The method
-\mthind{ReadStream}{upToEnd} returns everything from the current position to the end
-of the stream and sets the stream to its end. This code can be
-simplified using \mthind{PositionableStream}{peekFor:}, which moves forward if the following element equals the parameter and doesn't move otherwise.
+Este código define a variável \ct{negative} de acordo com o sinal do número no fluxo e a variável \ct{number} com o valor absoluto. O método \mthind{ReadStream}{upToEnd} retorna tudo a partir da posição corrente do fluxo até seu final. Este código pode ser simplificado usando \mthind{PositionableStream}{peekFor:}, que avança caso o elemento a seguir seja igual ao parâmetro.
 
 \begin{code}{@TEST |stream negative number|}
 stream := '-143' readStream.
@@ -180,22 +162,13 @@ stream := '-143' readStream.
 stream upToEnd         --> '143'
 \end{code}
 \noindent
-\ct{peekFor:} also returns a boolean
-indicating if the parameter equals the element.
+\ct{peekFor:} também retorna um valor booleano indicando se o parâmetro é igual ao elemento.
 
-You might have noticed a new way of constructing a stream in
-the above example: one can simply send \mthind{SequenceableCollection}{readStream} to a sequenceable collection to get a reading stream on that particular
-collection.
+Você pode ter percebido uma nova forma de se construir um fluxo no código acima: podemos simplesmente enviar \mthind{SequenceableCollection}{readStream} a uma coleção sequenciável para obter um fluxo de leitura nesta coleção em particular.
 
-\paragraph{Positioning.} There are methods to position the stream
-pointer. If you have the index, you can go directly to it using
-\mthind{PositionableStream}{position:}. You can request the current position using
-\mthind{PositionableStream}{position}. Please remember that a stream is not positioned on an
-element, but between two elements. The index corresponding to the
-beginning of the stream is 0.
+\paragraph{Posicionamento.} Existem métodos para posicionar o ponteiro do fluxo. Se você sabe o índice, você pode ir diretamente a ele usando \mthind{PositionableStream}{position:}. Você pode requisitar a posição atual usando \mthind{PositionableStream}{position}. Lembre-se que um fluxo não é posicionado em um elemento, mas entre dois elementos. O índice que corresponde ao início do fluxo é 0.
 
-You can obtain the state of the stream depicted in
-\figref{ab_cde} with the following code:
+Você pode obter o estado do fluxo mostrado na \figref{ab_cde} com o código a seguir:
 
 \begin{code}{@TEST |stream|}
 stream := 'abcde' readStream.
@@ -205,56 +178,49 @@ stream peek --> $c
 
 \begin{figure}[h!t]
 \centerline{\includegraphics[scale=0.5]{ab_cdeStef}}
-\caption{A stream at position 2}
+\caption{Um fluxo na posição 2.}
 \label{fig:ab_cde}
 \vspace{.2in}
 \end{figure}
 
-If you want to go to the beginning or at the end is what you want, you can use
-\mthind{PositionableStream}{reset} or \mthind{PositionableStream}{setToEnd}. \mthind{PositionableStream}{skip:} and \mthind{PositionableStream}{skipTo:} are used to
-go forward to a location relative to the current position: \ct{skip:}
-accepts a number as argument and skips that number of elements whereas
-\ct{skipTo:} skips all elements in the stream until it finds an
-element equals to its parameter. Note that it positions the stream
-after the matched element.
+Se você quer ir para o início ou final, você pode usar \mthind{PositionableStream}{reset} ou  \mthind{PositionableStream}{setToEnd}. \mthind{PositionableStream}{skip:} e \mthind{PositionableStream}{skipTo:} são usados para avançar para uma posição relativa à posição atual: \ct{skip:} aceita como argumento um número que representa a quantidade de elementos a serem omitidos enquanto \ct{skipTo:} omite todos os elementos no fluxo até que ele encontre um elemento igual ao valor recebido no parâmetro. Note que ele posiciona o ponteiro após o elemento encontrado.
 
 \begin{code}{@TEST |stream|}
 stream := 'abcdef' readStream.
-stream next.        --> $a    "stream is now positioned just after the a"
-stream skip: 3.                           "stream is now after the d"
+stream next.        --> $a    "ponteiro esta posicionado logo apos o 'a'"
+stream skip: 3.                           "ponteiro esta agora apos o 'd'"
 stream position.  -->   4
-stream skip: -2.                          "stream is after the b"
+stream skip: -2.                          "ponteiro esta agora apos o 'b'"
 stream position.  --> 2
 stream reset.
 stream position.  --> 0
-stream skipTo: $e.                      "stream is just after the e now"
+stream skipTo: $e.                      "ponteiro agora esta apos o 'e'"
 stream next.        --> $f
 stream contents. --> 'abcdef'
 \end{code}
 
-As you can see, the letter \ct{e} has been skipped.
+Como você pode ver, a letra \ct{e} foi omitida.
 
-The method \mthind{PositionableStream}{contents} always returns a copy of the entire stream.
+O método \mthind{PositionableStream}{contents} sempre retorna uma cópia do fluxo.
 
-\paragraph{Testing.} Some methods allow you to test the state of the current stream:
-\mthind{PositionableStream}{atEnd} returns true if and only if no more elements can be read whereas \mthind{PositionableStream}{isEmpty} returns true if and only if there is no element at all in the collection.
+\paragraph{Testando.} Alguns métodos permitem que você teste o estado atual do fluxo: \mthind{PositionableStream}{atEnd} retorna true se, e somente se, não existem outros elementos a serem lidos enquanto \mthind{PositionableStream}{isEmpty} retorna true se, e somente se, não existirem elementos na coleção.
 
-Here is a possible implementation of an algorithm using \ct{atEnd} that takes two sorted collections as parameters and merges those collections into another sorted collection:
+Aqui está uma possível implementação de um algoritmo usando \ct{atEnd} que recebe duas coleções ordenadas como parâmetros e as combina em uma terceira coleção ordenada:
 
 \needlines{4}
 \begin{code}{@TEST |stream1 stream2 result|}
 stream1 := #(1 4 9 11 12 13) readStream.
 stream2 := #(1 2 3 4 5 10 13 14 15) readStream.
 
-"The variable result will contain the sorted collection."
+"A variavel result ira conter a colecao ordenada."
 result := OrderedCollection new.
 [stream1 atEnd not & stream2 atEnd not]
   whileTrue: [stream1 peek < stream2 peek
-    "Remove the smallest element from either stream and add it to the result."
+    "Remove o menor elemento de ambos os fluxos e o adiciona em result."
     ifTrue: [result add: stream1 next]
     ifFalse: [result add: stream2 next]].
 
-"One of the two streams might not be at its end. Copy whatever remains."
+"Um dos dois fluxos podem nao ter chegado ao fim. Copia o que sobrar."
 result
   addAll: stream1 upToEnd;
   addAll: stream2 upToEnd.
@@ -263,11 +229,9 @@ result. -->   an OrderedCollection(1 1 2 3 4 4 5 9 10 11 12 13 13 14 15)
 \end{code}
 
 %-----------------------------------------------------------------
-\subsection{Writing to collections}
+\subsection{Escrevendo em coleções}
 
-We have already seen how to read a collection by iterating over its
-elements using a \ct{ReadStream}. We'll now learn how to create
-collections using \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 \clsindmain{WriteStream}{}s.
 
 \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: