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

%\begin{document}

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

\chapter{Caracteres e cadeias de caracteres}

\begin{center}
\shabox{
  \begin{Bitemize}
    \item[]\textbf{Quais novidades veremos nesta aula?}
    \item Introdução do tipo \texttt{char}
    \item Uma classe da biblioteca padrão: \texttt{String}
  \end{Bitemize}
} % \shabox
\end{center}
\bigskip

\section{Um tipo para representar caracteres}

Até hoje já vimos diferentes tipos de variáveis, vimos os inteiros
(\texttt{int}) e os reais (\texttt{double}). Além disto, também vimos as
variáveis booleanas, que podem ter apenas dois valores, verdadeiro, ou falso
(\texttt{boolean}).  Parece intuitivo que as linguagens de programação também
ofereçam variáveis para a manipulação de caracteres. No caso de Java temos o
tipo \texttt{char}. Vejamos um exemplo de uso:

\begin{lstlisting}
 class Caracter1
 {
   void verificaResposta(char ch)
   {
     if ((ch == 's') || (ch =='S'))
       System.out.println("A resposta foi sim");
     else if ((ch == 'n') || (ch == 'N'))
       System.out.println("A resposta foi não");
     else
       System.out.println("Resposta inválida");
  }
}
\end{lstlisting}

No exemplo acima podemos ver que para se representar um caracter usamos
aspas simples ('). Também podemos ver que os caracteres minúsculos são
diferentes do mesmo caracter maiúsculo.

Um outro exemplo um pouco mais elaborado pode ser visto abaixo:

\begin{lstlisting}
class Caracteres
{

  void imprimeCaracteres(char ch, int n)
  {
    int i = 0;
    while (i < n)
    {
      System.out.print(ch);
      i = i + 1;
    }
  }
}
\end{lstlisting}

Neste exemplo, são impressos diversos caracteres do mesmo tipo. Observe
abaixo como podemos adicionar um novo método para desenhar letras grandes:

\begin{lstlisting}
class Caracteres
{

  void imprimeCaracteres(char ch, int n)
  {
    int i = 0;
    while (i < n)
    {
      System.out.print(ch);
      i = i + 1;
    }
  }
  void novaLinha()
  {
    System.out.println();
  }
  void imprimeCaracteresNL(char ch, int n)
  {
    imprimeCaracteres(ch, n);
    novaLinha();
  }
  void desenhaE()
  {
    imprimeCaracteresNL('*',20);
    imprimeCaracteresNL('E', 15);
    imprimeCaracteresNL('E', 14);
    imprimeCaracteresNL('E', 3);
    imprimeCaracteresNL('E', 3);
    imprimeCaracteresNL('E', 13);
    imprimeCaracteresNL('E', 13);
    imprimeCaracteresNL('E', 3);
    imprimeCaracteresNL('E', 3);
    imprimeCaracteresNL('E', 14);
    imprimeCaracteresNL('E', 15);
    imprimeCaracteresNL('*',20);
  }
}
\end{lstlisting}

A saída do programa é:

\begin{verbatim}
    ********************
    EEEEEEEEEEEEEEE
    EEEEEEEEEEEEEE
    EEE
    EEE
    EEEEEEEEEEEEE
    EEEEEEEEEEEEE
    EEE
    EEE
    EEEEEEEEEEEEEE
    EEEEEEEEEEEEEEE
    *********************
\end{verbatim}

Os diferentes métodos que imprimem caracteres pulando, ou sem pular
linha serão usados 

Para desenharmos letras onde é necessário intercalar espaços e letras em uma
única linha, a implementação fica um pouco mais longa. Por exemplo, para a
letra U, a primeira linha deve ser impressa como:

\begin{lstlisting}
  imprimeCaracteres('U', 3);
  imprimeCaracteres(' ', 9);  // espaço também é um caractere
  imprimeCaracteresNL('U", 3);
\end{lstlisting}

\section{Cadeias de Caracteres (\texttt{String}s)}

Uma forma de escrevermos palavras no computador seria usando grupos de
caracteres, entretanto isto depende de um conceito mais avançado que
ainda não vimos. A nossa outra opção é usar uma classe pronta, que já
vem com a linguagem Java, a classe \texttt{String}.

Nos nossos primeiros exemplos nós já havíamos feito algumas operações
com strings. Como por exemplo:

\begin{lstlisting}
  System.out.println("O triângulo é retângulo");
  System.out.println("A raiz de " + 4 + " é igual a " + 2 + ".");
\end{lstlisting}

Agora nós veremos com mais detalhes esta classe \texttt{String} . Podemos ver
que o operador \texttt{+} tem um significado natural o de concatenação. Logo,
as seguintes operações são válidas:

\begin{lstlisting}
String a = "abc";
String b = "cdf";
String c;

c = a + b;
System.out.println(c);
\end{lstlisting}

Podemos também concatenar números a uma \texttt{String}:

\begin{lstlisting}
String a = "O resultado é";
int i = 10;
String c;

c = a + i;
System.out.println(c);
\end{lstlisting}

Além disto, existem alguns métodos pré-definidos na classe String. Entre
eles podemos citar:

\begin{itemize}
\item \texttt{char charAt(int index)} - 
devolve o caracter na posição \texttt{index}. \\
  Os índices em uma string vão de zero ao seu tamanho menos um.  Exemplo:

\begin{lstlisting}
String s = "mesa";
System.out.println(s.charAt(0)); // Imprime  m
System.out.println(s.charAt(3)); // Imprime  a
\end{lstlisting}

\item \texttt{boolean endsWith(String suffix)} - verifica se a String acaba
  com o sufixo dado. Usado, entre outras coisas, para verificar as extensões
  dos arquivos. Por exemplo, verificar se o nome de um arquivo termina com
  \texttt{".java"}.
      
\item \texttt{int indexOf(char ch)} - devolve o índice da primeira
      ocorrência de \texttt{ch} na String ou -1 caso o caractere não ocorra na
      String. Exemplo:

\begin{lstlisting}
String s1 = "EP1.java";
System.out.println(s1.indexOf('.')); // imprime 3
System.out.println(s1.indexOf('x')); // imprime -1
\end{lstlisting}

\item \texttt{int length()} - devolve o tamanho da String. Exemplo:

\begin{lstlisting}
String s1 = "mesa";
System.out.println(s1.lenghth()); // imprime 4
\end{lstlisting}

\item \texttt{String toUpperCase()} - devolve a String convertida para letras
      maiúsculas. Exemplo:

\begin{lstlisting}
String s1 = "mesa";
System.out.println(s1.toUpperCase()); // imprime MESA
\end{lstlisting}

\item \texttt{int compareTo(String outra)} - compara duas Strings. \\
      Devolve um número positivo se a \texttt{outra} for menor, 0 se forem
      iguais, e um negativo caso contrário. Exemplo:

\begin{lstlisting}
String s1 = "mesa";
String s2 = "cadeira";
System.out.println(s1.compareTo(s2)); // imprime 10 que é > 0
\end{lstlisting}

\end{itemize}

\section{Exercícios:}

\begin{enumerate}
  
\item Escreva uma classe \texttt{Linha} que possua um método
  \texttt{imprimeLinha} que, ao ser chamado, imprime uma linha de caracteres
  \texttt{X} na diagonal, na tela de interações do DrJava. Use laços
  \texttt{while}.  DICA: você vai precisar do método
  \texttt{System.out.print()}, que imprime seu argumento na tela mas não passa
  para a linha seguinte; imprima linhas com número crescente de espaços no
  começo e o caracter \texttt{X} no final.
  
\item Escrever um método que devolveo número de ocorrências da vogal \texttt{a}
  em uma frase contida em uma \texttt{String}.
  
\item Implemente um método que determina a freqüência relativa de vogais em
  uma \texttt{String}. Considere as letras maiúsculas e minúsculas não
  acentuadas.

\end{enumerate}

%\end{document}
