%cabeçalho para todos os capítulos
%\input{cabecalho}

%\begin{document}

%Opções para o pacote listings
%\input{listingOptions}

\chapter{Arrays (vetores)}

\begin{center}
\shabox{
  \begin{Bitemize}
    \item[]\textbf{Quais novidades veremos nesta aula?}
    \item \emph{arrays} (vetores)
    \item programas independentes em Java (método \texttt{main})
  \end{Bitemize}
} % \shabox
\end{center}
\bigskip

\section{\emph{Arrays} (vetores)}

Muitas vezes, precisamos que um objeto guarde um grande número de
informações. Por exemplo, se precisamos calcular a temperatura média em
um dado mês poderíamos ter uma classe similar à seguinte:

\begin{lstlisting}
class TemperaturasDoMes
{
    double t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12
           t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23,
           t24, t25, t26, t27, t28, t29, t30, t31;
     // etc.
}
\end{lstlisting}

onde cada variável guarda a temperatura média de um dia do mês. Isso é
claramente indesejável. Imagine ainda se quiséssemos uma classe para
guardar as temperaturas médias de todos os dias do ano. Precisaríamos de
365 variáveis? Felizmente não!

A linguagem Java possui o conceito de \emph{array} que é uma estrutura de
dados que permite guardar uma seqüência de valores (números, caracteres,
ou objetos quaisquer) de uma forma única e organizada. Utilizando um
\emph{array}, a classe anterior ficaria assim:

\begin{lstlisting}
class TemperaturasDoMes
{
    double[] temperaturas = new double[31];
    //etc.
}
\end{lstlisting}

Note que, no exemplo acima, a linha que define o \emph{array} \texttt{temperaturas} faz
duas coisas simulataneamente e que podem ser separadas em dois passos:

\texttt{double[] temperaturas;} define um novo \emph{array} chamado temperaturas e que
irá conter valores do tipo double.

Por enquanto, o \emph{array} está vazio. Mas quando fazemos \texttt{temperaturas = new double[31];}
estamos especificando que o \emph{array} guardará exatamente 31 valores do tipo double. Neste
instante, o ambiente Java reserva a memória necessária para guardar estes 31 valores.

\begin{center}
\begin{boxedminipage}[t]{14cm}
\textbf{Nota Linguística:} a tradução padrão de \emph{array} para o português é
\emph{vetor}. No entanto, a linguagem Java contém um tipo de objeto chamado
\texttt{Vector} que é semelhante a \emph{arrays}, mas não é igual. Para evitar confusões
entre \emph{arrays} e Vectors, preferimos não traduzir a palavra \emph{array} para
vetor neste livro.
\end{boxedminipage}
\end{center}
\bigskip

Vejamos agora um exemplo simples de utilização de \emph{arrays}.

\begin{lstlisting}
class BrincadeirasComArrays
{
    String[] diasDaSemana = new String[7];
    int[] quadrados = new int[10];

    void defineDiasDaSemana ()
    {
        diasDaSemana[0] = "domingo";
        diasDaSemana[1] = "segunda-feira";
        diasDaSemana[2] = "terça-feira";
        diasDaSemana[3] = "quarta-feira";
        diasDaSemana[4] = "quinta-feira";
        diasDaSemana[5] = "sexta-feira";
        diasDaSemana[6] = "sábado";
    }

    void calculaQuadrados ()
    {
        int i = 0;
        while (i < 10)
        {
            quadrados[i] = i*i;
            i++;
        }
    }

    void listaDiasDaSemana ()
    {
        int i = 0;
        while (i < 7)
        {
            System.out.println (diasDaSemana[i]);
            i++;
        }
    }

    void listaQuadrados ()
    {
        int i = 0;
        while (i < 10)
        {
            System.out.println (i + " ao quadrado é " + quadrados[i]);
            i++;
        }
    }
}
\end{lstlisting}

\subsection{O atributo \texttt{length}}

\emph{Arrays} são na verdade um tipo especial de objeto em Java. Qualquer \emph{array}
já vem com um atributo pré-definido, chamado \texttt{length} e que contém o
comprimento do \emph{array}. Desta forma, o método \texttt{calculaQuadrados} acima
poderia ser re-escrito para

\begin{lstlisting}
    void calculaQuadrados ()
    {
        int i = 0;
        while (i < quadrados.length)
        {
            quadrados[i] = i*i;
            i++;
        }
    }
\end{lstlisting}

O valor do atributo length é definido automaticamente pelo ambiente
Java, o programador não pode alterá-lo. Assim, \texttt{quadrados.length = 2} é
uma operação ilegal.


\subsection{Inicialização de \emph{arrays}}

Existe também a opção de inicializar um \emph{array} no momento em que ela é
declarada. Assim, podemos inicializar \emph{arrays} de inteiros e de Strings
conforme o exemplo a seguir:

\begin{lstlisting}
int[] primos = {2, 3, 5, 7, 11, 13, 17, 19, 23};

String[] planetas = {"Mercúrio", "Vênus", "Terra", "Marte", "Jupiter", "Saturno",
                     "Urano", "Netuno", "Plutão"};
\end{lstlisting}

\section{Criação de Programas Java}

Até esta aula, todos os exemplos de códigos que vimos, a rigor, não eram
"programas", eles eram apenas classes Java que podiam ser usadas dentro
do interpretador do DrJava. Mas, e se nós quiséssemos criar um programa
para ser utilizado por alguém que não possui o DrJava em sua máquina.
Neste caso, precisamos criar um programa a ser executado ou na linha de
comando do sistema operacional ou dando-se um "clique duplo" com o mouse
em cima do ícone do programa. Para fazer isso, basta que a classe
principal do programa possua um método \texttt{main} como no exemplo a seguir.

\begin{lstlisting}
class BrincadeirasComArrays
{
    // aqui vão os demais métodos e atributos da classe

    public static void main (String[] arg)
    {
        BrincadeirasComArrays b = new BrincadeirasComArrays ();
        b.defineDiasDaSemana ();
        b.calculaQuadrados ();
        b.listaDiasDaSemana ();
        b.listaQuadrados ();
        b.imprimeArray (arg);
    }

    void imprimeArray(String[] array)
    {
            int i = 0;
        while (i < array.length)
        {
            System.out.println(array[i]);
            i++;
        }
    }
}
\end{lstlisting}

Para executar o seu programa após compilar a classe, basta abrir um
\emph{shell} (um interpretador de comandos do sistema operacional; no unix
pode ser, por exemplo, o bash; no windows pode ser, por exemplo, o
command) e digitar

\begin{verbatim}
java BrincadeirasComArrays um dois três
\end{verbatim}

\texttt{java} é o nome do interpretador Java
\texttt{BrincadeirasComArrays} é o nome da classe que será carregada e cujo
método \texttt{main} será executado.
\texttt{um dois três} são apenas um exemplo de 3 argumentos que estamos passando,
poderia ser qualquer outra coisa.

Neste exemplo, o programa \texttt{BrincadeirasComArrays} geraria a seguinte saída:

\begin{verbatim}
domingo
segunda-feira
terça-feira
quarta-feira
quinta-feira
sexta-feira
sábado
0 ao quadrado é 0
1 ao quadrado é 1
2 ao quadrado é 4
3 ao quadrado é 9
4 ao quadrado é 16
5 ao quadrado é 25
6 ao quadrado é 36
7 ao quadrado é 49
8 ao quadrado é 64
9 ao quadrado é 81
um
dois
três
\end{verbatim}


portanto, para que uma classe possa ser executada a partir da linha de
comando do sistema, é necessário que ele possua um método com a seguinte
assinatura:

\begin{lstlisting}
public static void main (String[] arg)
\end{lstlisting}

o nome do parâmetro não precisa ser exatamente \texttt{arg}, qualquer nome
funciona; mas o seu tipo tem que ser obrigatoriamente um \emph{array} de
Strings.

\section{Exercícios}

\begin{enumerate}
\item Escreva uma classe \texttt{Simples} contendo um método que recebe um \emph{array} de inteiros como parâmetro e que inicializa todos os elementos do \emph{array} com um valor, também dado como parâmetro. O método deve devolver o tamanho do \emph{array}. A assinatura do método deve ser a seguinte:

\begin{lstlisting}
int inicializaArray(int[] a, int v);
\end{lstlisting}

Escreva agora um método que recebe um \emph{array} de inteiros como parâmetro e imprime o seu conteúdo:

\begin{lstlisting}
void imprimeArray(int[] a);
\end{lstlisting}

Crie agora um método que dado um inteiro verifica se ele esta presente no \emph{array}.

\begin{lstlisting}
boolean estáNoArray(int []a, int v);
\end{lstlisting}

Finalmente, escreva um programa que cria um \emph{array}, cria um objeto \texttt{Simples} e chama os seus três métodos.

\item Crie um método \texttt{double[] frequenciaRelativa(int[] v, int n)} que recebe um vetor contendo números inteiros no intervalo [0, n] e devolve um vetor contendo a frequência relativa de cada um destes números.

\item Crie um método que, dados dois vetores \texttt{a} e \texttt{b}, verifica se o vetor de menor tamanho é uma subsequência do vetor de tamanho maior. \\
Ex: O vetor [9, 5] é uma subsequência de [3, 9, 5, 4, -1].

\item Crie uma classe contendo um método que, dado um vetor \texttt{v} de inteiros, imprime o segmento de soma máxima. \\
Ex: No vetor [ 1, 5, -4, 7, 2, -3] o segmento de soma máxima é [ 7, 2]

\end{enumerate}

%\end{document}
