Introdução à linguagem Java

SUMÁRIO
1. ARQUITETURA E FERRAMENTAS ................................................................................................... 1

1.1. COMO COMPILAR E EXECUTAR UM PROGRAMA JAVA? ............................................................................. 1
1.2. CONFIGURANDO O JAVA NO LINUX..................................................................................................... 2
1.3. INSTALANDO O JAVA NA SUA MÁQUINA ................................................................................................ 3
1. Windows 95/98/ME: ............................................................................................................................ 4
2. Windows XP/2000: .............................................................................................................................. 4
2. O BÁSICO ...................................................................................................................................... 5
2.1. CONVENÇÃO DA LINGUAGEM ............................................................................................................. 5
2.2. SEQUÊNCIA { SEQUÊNCIA } ................................................................................................................. 5
2.3. PONTO E VÍRGULA, BLOCOS E O ESPAÇO EM BRANCO .............................................................................. 5
2.4. A DECLARAÇÃO IMPORT .................................................................................................................... 5
2.5. COMENTÁRIOS ................................................................................................................................ 5
2.6. PALAVRAS RESERVADAS .................................................................................................................... 6
2.7. O PRIMEIRO PROGRAMA EM JAVA....................................................................................................... 8
2.7.1.1. COMPILANDO UM PRIMEIRO PROGRAMA: ..........................................................................................................8
2.7.1.2. Explicação passo a passo do programa exemplo: .................................................................................................8
2.7.1.3. Curiosidade: ..........................................................................................................................................................9
2.8. IDENTIFICADORES ........................................................................................................................... 10

2.9. VARIÁVEIS E CONSTANTES ............................................................................................................... 11
2.10. MAIS SOBRE ATRIBUIÇÕES........................................................................................................... 11
2.11. DEFININDO VARIÁVEIS DE INSTÂNCIA ............................................................................................ 12
2.12. VARIÁVEIS DE CLASSE................................................................................................................. 12
2.13. ESCOPO DE VARIÁVEL ................................................................................................................ 12
2.14. TIPOS DE DADOS PRIMITIVOS ...................................................................................................... 12
2.14.1.1. Tipos Numéricos Inteiros.....................................................................................................................................13
2.14.1.2. Tipos Numéricos Reais ........................................................................................................................................13
2.14.1.3. Tipo caracter .......................................................................................................................................................13
2.14.1.4. Caracteres Especiais de Escape: ..........................................................................................................................13
2.14.1.5. Tipo Lógico ..........................................................................................................................................................13
2.15. CONVERSÃO ENTRE TIPOS PRIMITIVOS ........................................................................................... 13

2.15.1.1. Conversão............................................................................................................................................................14
2.15.1.2. Promoção Aritmética ..........................................................................................................................................14
2.16. STRING ................................................................................................................................. 14

2.17. EXPRESSÕES E OPERADORES ........................................................................................................ 15
2.17.1.1. Atribuição ............................................................................................................................................................15
2.17.1.2. 15
2.17.1.3. Aritméticos ..........................................................................................................................................................16
2.17.1.4. Incrementos e decrementos ...............................................................................................................................17
2.18. OPERADORES ........................................................................................................................... 17
2.18.1.1. Relacionais ..........................................................................................................................................................17
2.18.1.2. Binários ...............................................................................................................................................................17
2.18.1.3. Lógicos.................................................................................................................................................................17
2.18.1.4. Condicional ..........................................................................................................................................................17
2.18.1.5. Precedência dos Operadores ..............................................................................................................................18
2.18.1.6. Operadores Unários ............................................................................................................................................18
2.18.1.7. Operadores Aritméticos ......................................................................................................................................19
2.18.1.8. Operadores de Deslocamento.............................................................................................................................19
2.18.1.9. Operadores Comparações ...................................................................................................................................20
2.18.1.10. Operadores Lógico de curto-circuito ...................................................................................................................21
2.18.1.11. Operador Condicional .........................................................................................................................................21
2.18.1.12. Operadores de Atribuição ...................................................................................................................................22
3. LENDO E ESCREVENDO VARIÁVEIS ...............................................................................................22

4. ESTRUTURAS DE CONTROLE .........................................................................................................24
4.1. ESTRUTURA DE SELEÇÃO OU CONDICIONAL ......................................................................................... 24
4.1.1Comando if – else .......................................................................................................................................... 24
4.2. ESTRUTURA DE REPETIÇÃO............................................................................................................... 27
3. Comando while .................................................................................................................................. 27
4. Comando do while ............................................................................................................................. 28
5. Comando for ...................................................................................................................................... 29
4.3. ESTRUTURA DE SELEÇÃO MÚLTIPLA ................................................................................................... 30
6. Comando switch ................................................................................................................................ 30
4.4. INSTRUÇÕES.................................................................................................................................. 32
7. Comando break.................................................................................................................................. 32
8. Comando continue ............................................................................................................................. 33
5. RECURSIVIDADE ...........................................................................................................................34
5.1. FATORIAL ..................................................................................................................................... 34
5.2. SÉRIE DE FINOBACCI ....................................................................................................................... 35
6. ESTRUTURA DE DADOS ................................................................................................................36
6.1. ARRAY ......................................................................................................................................... 36
6.2. CURIOSIDADES SOBRE ARRAY ........................................................................................................... 38
7. FUNÇÃO E PROCEDIMENTO .........................................................................................................44
7.1. PROCEDIMENTO ............................................................................................................................ 44
7.2. FUNÇÕES ..................................................................................................................................... 45
8. BUSCA E ORDENAÇÃO ..................................................................................................................48
8.1. ORDENAÇÃO ................................................................................................................................. 48
8.1.1.1. Ordenação por seleção .......................................................................................................................................49
8.2. ORDENAÇÃO POR TROCAS – MÉTODO DA BOLHA .................................................................................. 50

8.3. BUSCA ......................................................................................................................................... 52
8.3.1. BUSCA LINEAR (OU SEQÜENCIAL) ................................................................................................. 52
8.3.2. BUSCA BINÁRIA (OU BUSCA LOGARÍTMICA) .................................................................................... 54
9. ESTRUTURAS DE DADOS DINÂMICAS ...........................................................................................58
9.1. LISTAS ......................................................................................................................................... 59
9.1.1. LISTA ENCADEADAS .................................................................................................................... 59
9.1.2. TIPOS DE LISTA ENCADEADAS ....................................................................................................... 61
9.1.2.1. Lista encadeamento Simples ...............................................................................................................................61
9.1.2.2. Lista Duplamente encadeadas ............................................................................................................................67
9.1.3. FILAS ...................................................................................................................................... 71

9.1.4. PILHAS .................................................................................................................................... 73
9.1.5. ÁRVORES ................................................................................................................................. 75
9.1.5.1. Árvores binárias ..................................................................................................................................................77
10. BIBLIOGRAFIA ..............................................................................................................................82

APRESENTAÇÃO
O que aprendemos em algoritmo:

“A automação é o processo em que uma tarefa deixa de ser desempenhada pelo
homem e passa a ser realizada por máquinas, sejam estes dispositivos mecânicos, eletrônicos
(como os computadores) ou de natureza mista”.
Para que a automação de uma tarefa seja bem-sucedida é necessário que a
máquina que passará a realizá-la seja capaz de desempenhar cada uma das etapas
constituintes do processo a ser automatizado com eficiência, de modo a garantir a
repetibilidade do mesmo. Assim, é necessário que seja especificado com clareza e exatidão o
que deve ser realizado em cada uma das fases do processo a ser automatizado, bem como a
seqüência em que estas fases devem ser realizadas.
“A especificação da seqüência ordenada de passos que deve ser seguida
para a realização de uma tarefa, garantindo a sua repetibilidade, dá-se o nome de
algoritmo.”
A Técnica de Programação vem complementar o estudo do algoritmo, passando da
forma da linguagem que o ser humano compreende para a forma que a máquina irá entender
(os conjuntos de instruções) e executar. Por outro lado temos a Estrutura de Dados para
ajudarmos a organizar, pesquisar nossos dados, ficando mais ágil seu programa nestas ações.
Temos e diversos tipos de linguagens de programação para podermos estar transformando o
algoritmo, por exemplo:
> PHP; > Delphi;
> Java; > C;
> C#; > C++;
> Fortran; >Python;
> Entre muitas outras...
A linguagem a ser usada neste curso será JAVA, veremos os conceitos da
linguagem, sintaxes...
Este curso explora os seguintes assuntos
• Como escrever programas em Java, como compilá-los e como executá-los;
• A sintaxe da linguagem Java;
• Boas práticas, testes e noções de padrões de projeto;
Técnico em Informática – Lógica de Programação e Estrutura de Dados 1
1. ARQUITETURA E FERRAMENTAS
1.1. Como compilar e executar um programa Java?
O conceito de um algoritmo foi formalizado em 1936 pela Máquina de Turing de O
processo de compilação de um programa Java é feito de acordo com os seguintes passos: o
código fonte (extensão .java) é compilado e armazenado em um arquivo de extensão .class.
De cara, percebe-se a impossibilidade de utilizar-se de DOS como sistema operacional para a
elaboração de aplicativos Java, uma vez que o mesmo tem um suporte limitado a nomes de
arquivos. Mas essa limitação quanto ao nome dos arquivos é somente a razão aparente da não-
portabilidade de Java para DOS. A grande razão reside no fato de que Java foi projetada para
sistemas de 32 bits, e só foram escritas Máquinas Virtuais Java para ambientes de 32 bits.
A portabilidade de Java depende fortemente da existência de JVMs que rodem em
diversas plataformas. Um programa Java rodará em um computador se existir uma JVM que
nele rode. Ao contrário de programas Java, as JVMs devem ser programas feitos e compilados
para máquinas específicas, de forma que serão as JVMs as responsáveis pela tradução de
bytecodes Java para as linguagens nativas das máquinas.
O conjunto de instruções da Máquina Virtual Java é otimizado para ser pequeno e
compacto, tendo sido elaborado para ser uma espécie de processador RISC(siginificado)
virtual: a rapidez da interpretação às vezes é sacrificada para garantir esse reduzido conjunto
de instruções.
O compilador mais utilizado para a transformação de arquivos-fonte java (.java) em
arquivos de bytecodes é o javac da Sun (há diversos outros compiladores no mercado, mas o
javac foi o primeiro e é o mais popular ainda hoje).
Figura 1Funcionamento da JVM(Java Virtual Machine)

Uma vez gerado o arquivo .class, ele deve ser passado à JVM instalada no
computador. No caso mais comum, a JVM utilizada é a distribuída pela Sun em seu JDK
(Java Developers Kit), denominada java. Isso no caso de aplicativos. No caso de Applets, os
browsers que suportam Java já contêm em si uma JVM que interpreta os bytecodes das
Applets
.
Figura 2 Funcionamento da JVM(Java Virtual Machine)
Com isso um programa Java é um conjunto de instruções para a JVM, dessa forma o
mesmo é independente de plataforma, pois basta que haja uma implementação de máquina
virtual para a plataforma a ser utilizada.
Figura 3 Funcionamento do Java em diferentes plataformas
Observação: Esse foi o modelo inicial para execução de programas Java, a fim de
possibilitar independência de plataforma, sendo que atualmente o processo de interpretação
foi substituído por outra compilação, sendo que, não mais para bytecodes e sim para código
executável dependente de plataforma. Dessa forma a perda de performance com a
interpretação foi eliminada e o programa em bytecodes continua independente de plataforma,
pois a JVM de cada plataforma será responsável pela compilação em executável.
Site http://www.javasoft.com/products/hotspot/
(s)
1.2. Configurando o JAVA no Linux
A configuração do pacote J2SDK (Java Software Development Kit - ou

simplesmente JDK - é o ambiente de desenvolvimento Java) é muito simples.
Primeiramente, entre no site http://java.sun.com/j2se/1.4/download.html e faça
download do pacote j2sdk-<versao>.bin e depois execute-o:
$ ./j2sdk-<versao>.bin
Feito isso, irá aparecer a licença do Java. Aperte "enter" para rolar a página ou "q"
para terminar. Após isso, digite "yes" para concordar com os termos da licença, e sendo
assim, irá começar a descompactar os arquivos. (será criado o diretório "j2sdk").
Pronto, o Java está instalado, porém agora falta configurá-lo.
Edite o arquivo /etc/profile (como root, claro) e adicione as seguintes linhas:
JAVA_HOME:/usr/local/j2sdk<versão>
CLASSPATH=.:$CLASSPATH
No "JAVA_HOME", coloque o diretório onde foi criado o j2sdk. (no meu caso foi
criado em /home/juniox/j2sdk).
Feito isso, procure pela linha PATH e adicione logo abaixo:
PATH=$JAVA_HOME/bin:$PATH
No artigo que fala sobre o J2DK, era para colocar a linha
"PATH=$JAVA_HOME/bin:$PATH", mas uma dúvida.
Digamos que eu tenha colocado o Java no /root ou na raíz, como que
ficaria?
No PATH não vai mudar nada, pois nele você está indicando o
valor da variável $JAVA_HOME:
PATH=$JAVA_HOME/bin:$PATH
Bom, se você instalou o JDK no /root, então ficou

/root/j2skd<versao> certo ?
pois bem, basta você colocar isso no $JAVA_HOME:
JAVA_HOME:/root/j2sdk<versão>
As linhas do /etc/profile. Eu inseri o que segue:
#
# /etc/profile
.
.
.
# final do /etc/profile
export PATH=/usr/local/j2sdk1.4.2:$PATH
# Eu criei um diretorio para minhas classes

export CLASSPATH=/usr/local/j2sdk1.4.2/minhas_classes
# As manpages som _muito_ importantes

export MANPATH=$MANPATH:/usr/local/j2sdk1.4.2/man
#<EOF>
1.3. Instalando o Java na sua máquina
- Após o término do download, execute o arquivo que você baixou, e siga as

instruções de instalação.
- Na primeira tela que aparecer (a de boas vindas), basta clicar em Next.
- A próxima tela é a de licensa de uso. Clique em "Yes" para continuar.
- Agora o instalador lhe dá a oportunidade de selecionar em que diretório instalar o SDK. Por
padrão fica em c:\j2sdk1.4.0_XX. Mude-o para "c:\java". Clique em Next.
- Na próxima tela é possível selecionar os componentes a serem instalados. Deixe todos
marcados. Clique em Next.
- Na próxima tela, chamada "Select Browsers", o instalador lhe pergunta em quais
navegadores é para ser habiltado o plugin Java. Como muito possivelmente o seu browser já
tem tal plugin, e levando em consideração que usar o plugin da Sun pode acarretar em certas
incompatibilidades, desmarque todas as opções. Clique em Next.
- O Java SDK irá ser copiado para o sistema. Aguarde a finalização. Apos o término, clique
em Finish.
- Agora será necessário configurar 3 variáveis de ambiente, JAVA_HOME, PATH e
CLASSPATH.
1. Windows 95/98/ME:
Edite o arquivo c:\autoexec.bat (clique nele com o botão direito, depois "Editar", ou abra-o no
Bloco de Notas) e adicione no final do arquivo exatamente o seguinte:
SET JAVA_HOME=<diretório onde o java foi instalado>
Por exemplo, levando em consideração que o java foi instalado no diretório "c:\java", a linha
ficará assim:
SET JAVA_HOME=c:\java
Agora devemos configurar o PATH:
SET PATH=%PATH%;%JAVA_HOME%\bin
É possível que já exista uma variável de ambiente chamada PATH. Nesse caso, basta
adicionar o exemplo acima logo após a existente. Por último, basta configurar a variável
CLASSPATH:
SET CLASSPATH=.;%JAVA_HOME%
Repare que logo após o sinal de igual ( = ) há um ponto seguido de um ponto-e-vírgula.
Não esqueça deste detalhe. Após ter feito a configuraçào, reboote o computador para que as
alterações façam efeito.
2. Windows XP/2000:
Para configurar as Variáveis de Ambiente no Windows XP/2000, você deve fazer da seguinte
maneira:
- Clique no menu "Iniciar", depois em "Painel de Controle". Escolha então "Sistema".
- Na janela que abrir, clique na aba "Avançado" e depois no botão "Variáveis de Ambiente".
- Na próxima tela, clique em "Adicionar"
- Insira as variáveis JAVA_HOME e CLASSPATH com os respectivos valores, da mesma
forma como mostrado na configuração anterior, porém lembrando que, neste caso não é
necessário adicionar o "SET" junto, ou seja, coloque apenas o nome da variável e o valor.
Para alterar a PATH, basta edite-a ( muito provavelmente já irá existir ) e adicione no fim:
";%JAVA_HOME%\bin".
Clique em "OK" e reinicie o micro.
O seu sistema deve estar pronto para compilar programas em Java. Para fazer um teste, abra
um prompt do MSDOS, e digite:
javac
Tudo estará funcionando caso apareça uma grande mensagem explicando como utilizar o
javac.
2. O Básico
2.1. Convenção da linguagem
Na linguagem Java é utilizada a seguinte convenção para formação de
identificadores:
• Constantes com todas as letras em maiúsculo:

o CONSTANTE
• Variáveis começam com letra minúscula:
o variável
• Classes começam com letra maiúscula:
o Classe
• Se o nome for composto, cada nome começa com letra maiúscula:
o VariávelComNomeComposto.Bloco
Um bloco é definido por ({}) e contém um grupo de outros blocos. Quando um novo
bloco é criado um novo escopo local é aberto e permite a definição de variáveis locais. As
variáveis definidas dentro de um bloco só podem ser vistas internamente a este, e são
terminadas ou extintas no final da execução deste(}).
2.2. Sequência { sequência }

Cria uma seqüência, a qual agrupa comandos e variáveis. Quando uma sequência
possuir apenas um comando os operadores { e } são opcionais, caso contrários são
obrigatórios e cada comando dentro da sequência deve ser terminado por “;”
2.3. Ponto e vírgula, Blocos e o espaço em branco

Class - Nomes de classes podem ser maiúsculas ou minúsculas ou misturadas
(maiúsculas e minúsculas), mas por convenção o nome das classes começam por letra
maiúscalas.
2.4. A declaração import

Em Java, quando você quer usar instalações de pacotes, você usa a declaração de
importação para contar para o compilador onde achar as classe que você vai usar.
A declaração de importação (import) deve preceder a declaração de todas as classes.
2.5. Comentários
Existem três tipos de comentários em Java, sendo eles :

// Usado para indicar comentários em uma única linha, pode ser inserido em qualquer posição de
uma linha, e todo o texto até o final do marcador de linha é tratado como comentário.
/ Usados para indicar comentários que se estendem por uma ou mais linhas.
* */
/ Comentário de documentação. Devem ser inseridos imediatamente antes de uma declaração de
** classes, variável ou método e indicam que o comentário deve ser incluído em qualquer documentação
*/ gerada automaticamente (como os arquivos HTML gerados pelo comando javadoc)
2.6. Palavras Reservadas

Modificadores de acesso
Private: Acesso apenas dentro da classe
Protected: Acesso por classes no mesmo pacote e subclasses
Public: Acesso de qualquer classe
Modificadores de classes, variáveis ou métodos.
Abstract: Classe que não pode ser instanciada ou método que precisa ser implementado
por uma subclasse não abstrata
Class: Especifica uma classe
Extends: Indica a superclasse que a subclasse está estendendo
Final: Impossibilita que uma classe seja estendida, que um método seja sobrescrito ou
que uma variável seja reinicializada.
Implements: Indica as interfaces que uma classe irá implementar
Interface: Especifica uma interface
Native: Indica que um método está escrito em uma linguagem dependente de
plataforma, como o C
New: Instancia um novo objeto, chamando seu construtor
Static: Faz um método ou variável pertencer à classe ao invés de às instâncias
Strictfp: Usado em frente a um 6 método ou classe para indicar que os números de ponto
flutuante seguirão as regras de ponto flutuante em todas as expressões
Synchronized: Indica que um método só pode ser acessado por uma thread de cada vez
Transient: Impede a serialização de campos
Volatile: Indica que uma variável pode ser alterada durante o uso de threads
Controle de fluxo dentro de um bloco de código
Break: Sai do bloco de código em que ele está
Case: Executa um bloco de código dependendo do teste do switch
Continue: Pula a execução do código que viria após essa linha e vai para a próxima
passagem do loop
Default: Executa esse bloco de código caso nenhum dos teste de switch-case seja
verdadeiro
Do: Executa um bloco de código uma vez, e então realiza um teste em conjunto
com o while para determinar se o bloco deverá ser executado novamente

Else: Executa um bloco de código alternativo caso o teste if seja falso
For: Usado para realizar um loop condicional de um bloco de código
If: Usado para realizar um teste lógico de verdadeiro o falso
Instanceof: Determina se um objeto é uma instância de determinada classe, superclasse ou
interface
Return: Retorna de um método sem executar qualquer código que venha depois desta
linha (também pode retornar uma variável)
Switch: Indica a variável a ser comparada nas expressões case
While: Executa um bloco de código repetidamente até que uma certa condição seja
verdadeira
Tratamento de erros
Assert: Testa uma expressão condicional para verificar uma suposição do programador
Catch: Declara o bloco de código usado para tratar uma exceção
Finally: Bloco de código, após um try-catch, que é executado independentemente do
fluxo de programa seguido ao lidar com uma exceção
Throw: Usado para passar uma exceção para o método que o chamou
Throws: Indica que um método pode passar uma exceção para o método que o chamou
Try: Bloco de código que tentará ser executado, mas que pode causar uma exceção.
Controle de pacotes
Import: Importa pacotes ou classes para dentro do código
Package: Especifica a que pacote todas as classes de um arquivo pertencem
Primitivos
Boolean: Um valor indicando verdadeiro ou falso
Byte: Um inteiro de 8 bits (signed)
Char: Um caracter unicode (16-bit unsigned)
Double: Um número de ponto flutuante de 64 bits (signed)
Float: Um = número de ponto flutuante de 32 bits (signed)
Int: Um inteiro de 32 bits (signed)
Long: Um inteiro de 64 bits (signed)
Short: Um inteiro de 32 bits (signed)
Variáveis de referência
Super: Refere-se à superclasse imediata
This: Refere-se à instância atual do objeto
Retorno de um método
Void: Indica que o método não tem retorno
Palavras reservadas não utilizadas
Const: Não utilize para declarar constantes; use public static final
Goto: Não implementada na linguagem Java por ser considerada prejudicial
Literais reservados
De acordo com a Java Language Specification, null, true e false são tecnicamente chamados de valores
literais, e não keywords. Se você tentar criar algum identificador com estes valores, você também terá um erro de
compilação.
2.7. O primeiro Programa em Java

2.7.1.1. COMPILANDO UM PRIMEIRO PROGRAMA:
a. Certifique-se de ter adicionado a sua lista de path’s o path do compilador e

interpretador Java. Javac e Java respectivamente.
b. Crie o arquivo ao lado em um diretório qualquer (“folder” para usuários mac) e salve
com o nome: HelloInternet.Java
c. Chame o compilador Java para este arquivo: Javac HelloInternet.Java
d. Seu diretório deve ter recebido um novo arquivo após essa compilação:
HelloInternet.class
e. Chame o interpretador Java para este arquivo (omita a extensão .class de arquivo):
Java HelloInternet
f. Observe o resultado na tela: Hello Internet!
//Comentario de uma linha
public class HelloInternet {
public static void main (String args[])

{
System.out.println("Hello!");
Resultado:
Hello!
2.7.1.2. Explicação passo a passo do programa exemplo:
//Comentario de uma linha
Comentários em Java seguem a mesma sintaxe de C++, “//” inicia uma linha de
comentário, todo o restante da linha é ignorado. Existe também um outro tipo de comentário
formado por /* Insira aqui o texto a ser ignorado */ , este tipo de comentário pode ser
intercalado em uma linha de código. Comentários são tratados como espaços em branco. E
por último o comentário para documentação /** até o final */ deve vir antes da declaração da
classe.
public class HelloInternet {
class é a palavra reservada que marca o inicio da declaração de uma classe. Public é um
especificador, por enquanto guarde public class como o início da declaração de uma classe.
Toda classes serão declaradas assim até o tópico POO (Programação Orientada a Objetos).
HelloInternet
É o nome dado a esta classe. O “abre chaves” marca o início das declarações da classe
que são os atributos e métodos. Esta classe só possui uma declaração, a do método main, note
que um método, ao contrário de C++, só pode ser declarado {internamente} a classe a qual
pertence, evitando as confusões sobre “escopo”. Desta forma, todo pedaço de código em Java
deve pertencer ao abre chaves, fecha chaves da definição de uma classe.
public static void main (String args[]) {

System.out.println("Hello Internet!");
}
public
É um qualificador do método que indica que este é acessível externamente a esta classe
(para outras classes que eventualmente seriam criadas), não se preocupe com ele agora,
apenas declare todos os métodos como public. Voltaremos a este assunto em outro capitulo.
static
É outro qualificador ou “specifier”, que indica que o método deve ser compartilhado por
todos os objetos que são criados a partir desta classe. Os métodos static podem ser invocados,
mesmo quando não foi criado nenhum objeto para a classe, para tal deve-se seguir a sintaxe:
<NomeClasse>.<NomemetodoStatic>(argumentos);. Retornaremos a esta explicação mais
tarde, por hora você precisa saber que particularmente o método main precisa ter essa
qualificação porque ele é chamado sem que se crie nenhum objeto de sua classe (a classe
HelloInternet).
2.7.1.3. Curiosidade:
Se você gosta de paradoxos e já conhece um pouco de orientação a objetos, pense que se o

método main tivesse que ser chamado para um objeto (o que não é o caso) este objeto teria
que ter sido criado em algum outro lugar então este lugar seria o início do programa e main
deixaria de ter esta finalidade.
A linguagem de programação Eiffel adota uma técnica diferente para resolver este
problema: todo programa começa com a criação de um objeto (e não mais a chamada
automática de main), este objeto é chamado ROOT, ele pode conter atributos que são
inicializados e um método de inicialização, construtor do objeto, que é o início do código do
programa.
void
Semelhante ao void C++ ou C, é o valor de retorno da função, quando a função não

retorna nenhum valor ela retorna void, uma espécie de valor vazio que tem que ser
especificado.
main
Este é um nome particular de método que indica para o compilador o início do programa,
é dentro deste método e através das iterações entre os atributos, variáveis e argumentos
visíveis nele que o programa se desenvolve.
(String args[])
É o argumento de main e por conseqüência do programa todo, ele é um vetor de Strings

que é formado quando são passados ou não argumentos através da invocação do nome do
programa na linha de comando do sistema operacional, exemplo:
Java HelloInternet argumentotexto1 argumentotexto2
No nosso caso, ignoramos a possível passagem de argumentos via linha de comando,

retornaremos a este assunto posteriormente.
{ ... }
“Abre chaves” e “fecha chaves”. Para quem não conhece C ou C++, eles podem ser
entendidos como algo semelhante ao BEGIN END de Pascal ou Modula-3, ou seja: delimitam
um bloco de código. Os programadores Pascal notarão que variáveis locais dos métodos
podem ser declaradas em qualquer local entre as chaves. Mas por motivos de clareza do
código declararemos todas no início do abre chaves.
2.8. Identificadores
Os identificadores em Java devem seguir as seguintes regras:
1 A primeira posição deverá ser com uma letra, “_” ou “$”

.
2 Ser formado por caracteres UNICODE
.
3 Não ser uma palavra reservada
.
4 Não ser igual as literais : true, false ou null
.
5 Não ser repetido dentro do seu escopo
.
Observação: Os identificadores Java são case-sensitive
2.9. Variáveis e Constantes

Podem ser declaradas em qualquer lugar dentro de uma classe ou de um método. Todas as
instancias, classes e variáveis globais suportam maiúsculas e minúsculas.
Uma constante é definida com a palavra reservada final e o seu conteúdo uma vez
atribuído não poderá mais ser alterado.
A declaração de variáveis e constantes em Java é feita colocando o identificador do tipo
seguido do identificador da variável.
tipo variável [ = ValorInicial ];

final tipo CONSTANTE [ = ValorInicial ];
Em Java as constantes são variáveis declaradas como final.
final int a = 10;

int b = 15;
// a = 11; -> iria dar um

erro
b = 11; // atribuição
válida
Em Java a conversão de dados entre variáveis é automática quando:

As variáveis são de tipo compatível
A variável de destino é maior do que a de origem
Quando isso não acontece, temos de usar uma conversão explícita, denominada cast:
var = (tipo-var-destino) var2
Exemplos:
long a = 1;
int b = 2;
a = b; // Conversão válida
//b = a; // Conversão
inválida
b = (int) a; // Conversão
válida
2.10. Mais sobre atribuições

Variáveis podem atribuidas em forma de expressões como:
int x, y, z;
x = y = z = 0;
No exemplo as três variáveis recebem o valor 0;
2.11. Definindo Variáveis de Instância

As variáveis de instância, aparentemente, são declaradas e definidas quase exatamente da
mesma forma que as variáveis locais, a principal diferença é que a alocação delas é na
definição da classe. Exemplo:
class Bike extends Veículo {

String tipo;
int correia;
int pedal;
}
2.12. Variáveis de Classe

As variáveis de classe são boas para a comunicação entre os diferentes objetos da mesma
classe, ou para manter travamento de estados globais sobre um conjunto de objetos. Exemplo:
static int soma;

static final int maxObjects= 10;
2.13. Escopo de Variável

class MinhaClasse {
// variáveis globais - válidas em todos os métodos da classe
...
public void metodoA( argumentos ) {
// variáveis locais - validas dentro do método onde estão definidas
for ( ... ) {
// variáveis temporárias - validas apenas no código dentro do ciclo
}
...
}
...
}
2.14. Tipos de Dados Primitivos

Java é uma linguagem de programação fortemente orientada a objetos e, com exceção dos
tipos primitivos, “qualquer” coisa em Java é uma classe/objeto.
Tipos Primitivos:
Numéricos Inteiros;
Numéricos Reais;
Caracter;
Lógico.
2.14.1.1. Tipos Numéricos Inteiros
Tipo Tamanho em bits Faixa

byte 8 -128 até +127
short 16 -32,768 até +32,767
int 32 -2,147,483,648 até+2,147,483,647
long 64 -9,223,372,036,854,775,808 até
+9,223,372,036,854,775,807
2.14.1.2. Tipos Numéricos Reais

float 32 -3.40292347E+38 até +3.40292347E+38
double 64 -1.79769313486231570E+308 até
+1.79769313486231570E+308
2.14.1.3. Tipo caracter

char 16 UNICODE - 65536 caracteres possíveis
Observação: Um caracter é delimitado por apóstrofos ‘caracter’. O que causa confusão,
pois as Strings são delimitadas por aspas “String”.
2.14.1.4. Caracteres Especiais de Escape:
'\u0000' a caracteres Unicode

'\uFFFF'
\b retrocesso
\t tab
\n avanço de linha
\r retorno de carro
\” aspas
\' apóstrofo
\\ barra invertida
Observação: A linguagem Java não possui o tipo primitivo string, bastante conhecido em
várias outras linguagens. Para manipulação de texto são utilizadas as classes String e
StringBuffer.
2.14.1.5. Tipo Lógico
Tipo Faixa
boolean true ou false
2.15. Conversão entre tipos primitivos

É possível transformar um tipo primitivo em outro, através de uma operação chamada
typecast, colocando o tipo destino da transformação, entre parêntesis, antes da expressão a ser
convertida. Esse tipo de conversão é chamado de conversão explícita. Por outro lado existe a
conversão implícita, a qual é realizada pela MVJ, mesmo sem possuir operador de typecast,
isso quando o tipo de retorno é menos abrangente que o tipo que o recebe.
long bigval = 6; // Operação válida

int smallval = 99L; // Operação inválida porque são de tipos diferentes

float z = 12.414F; // Operação válida
float zp = 12.414; // Operação inválida porque esta tentando atribuir um valor double.
2.15.1.1. Conversão
Permite a conversão entre tipos diferentes

Deve ser explícito quando for de um tipo maior para um menor (narrowing)
Pode ser implícito (ou explícito) de um tipo menor para um maior (widening)
Conversão para tipos menores pode causar perda de precisão e truncamento
Char
Int Long Float Double
Short
Byte
Figura 4 O widening segue o sentido das flechas. Narrowing é no sentido contrário
2.15.1.2. Promoção Aritmética
Ocorre com as operações aritméticas entre tipos primitivos numéricos diferentes.

O menor tipo é automaticamente convertido para o maior tipo.
public class PromocaoMatematica {

public static void main( String[] args ) {
double d = 100.99;
int i = 100; //aqui ocorre a promoção matemática
d = d * i; //i é convertido para double e então multiplicado
//ao contrário é necessário informar o casting
d = d * (double) i;
long x = 12345;
float pi = 3.14f;
x = x * (long) pi; //ou então, converte apenas o resultado
x = (long) (x * pi);
}
}
2.16. STRING
String é uma classe que manipula cadeias de caracteres
A classe String possui métodos para essas manipulações
Trabalha com Pool de Strings para economizar memória
Exemplo:
String str = “Isto é uma String do Java”;

String xyz = new String(“Isto é uma String do Java”);
if( str == xyz )

System.out.println(“IGUAL”);
else
System.out.println(“DIFERENTE”);
if( str.equals( xyz ) ) {
//MANEIRA CORRETA DE SE COMPARAR O CONTEÚDO DAS STRINGS
}
System.out.println( “Tamanho da String: “ + str.length() );
System.out.println( “SubString: “ + str.substring(0, 10) );
System.out.println( “Caracter na posição 5: “ + str.charAt(5) );
Outros métodos úteis da classe String:
String str = “Isto é uma String do Java”;
// O método split quebra a String e várias outras,

// pelo separador desejado
String[] palavras = str.split(“ ”);
int i = str.indexOf(“uma”); //retorna o índice da palavra na

String
if( str.startsWith(“Olá”) || str.endsWith(“Mundo!”) ) {
// testa o começo e o fim da String – retorna boolean
}
str = str.trim(); // elimina os espaços em branco no início e fim
str = str.replace(‘a’,’@’); // substitui os caracteres
// substitui uma palavra (usa expressões regulares)
str = str.replaceAll(“String”,”Cadeia de caracteres”);
2.17. Expressões e operadores
2.17.1.1. Atribuição
2.17.1.2.
Operador Uso Equivale a

=
+= Op1 += op2 Op1 = op1 + op2
-= Op1 -= op2 Op1 = op1 - op2
*= Op1 *= op2 Op1 = op1 * op2
/= Op1 /= op2 Op1 = op1 / op2
%= Op1 %= op2 Op1 = op1 % op2
&= Op1 &= op2 Op1 = op1 & op2
|= Op1 |= op2 Op1 = op1 | op2
^= Op1 ^= op2 Op1 = op1 ^ op2
<<= Op1 <<= op2 Op1 = op1 << op2
>>= Op1 >>= op2 Op1 = op1 >> op2
>>>= Op1 >>>= op2 Op1 = op1 >>> op2
2.17.1.3. Aritméticos
Operado Uso Descrição

r
+ op1 + op2 Adiciona op1 e op2
- op1 - op2 Subtrai op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Resto de op1 / op2
Exemplo Aritmético:
public class Aritmeticos {
public static void main ( Strings args[] ) {
short x = 6;
int y = 4;
float a = 12.5f;
float b = 7f;
System.out.println ( “x é “ + x + “, y é “ + y );
System.out.println ( “x + y = “ + (x + y) );
System.out.println ( “x - y = “ + (x - y) );
System.out.println ( “x / y = “ + (x / y) );
System.out.println ( “x % y = “ + ( x % y ) );
System.out.println ( “a é “ + a + “, b é “ + b );
System.out.println ( “ a / b = “ + ( a / b ) );
}
}
A saída do programa acima é :
x é 6, y é 4
x + y = 10
x-y=2
x/y=1
x%y=2
a é 12.5, b é 7
a / b = 1.78571
2.17.1.4. Incrementos e decrementos
Como no C e no C++ o Java também possui incrementadores e decrementadores:

Operador Uso Descrição
++ var++ usa a variável e depois incrementa
++var incrementa a variável e depois usa
-- var-- usa a variável e pois decrementa
--var decrementa a variável e depois usa
As duas expressões dão resultados diferentes, pois existe uma diferença entre prefixo e
sufixo. Quando se usa os operadores ( x++ ou x-- ), y recebe o valor de x antes de x ser
incrementado, e usando o prefixo ( ++x ou –x ) acontece o contrario, y recebe o valor
incrementado de x.
2.18. Operadores
2.18.1.1. Relacionais
Operador Descrição
== Igual
!= Diferente
< Menor
> Maior
<= Menor ou igual
>= Maior ou igual
2.18.1.2. Binários
Operador Descrição
>> shift binário para direita
<< shift binário para esquerda
>>> shift binário para direita (unsigned)
& AND binário
| OR binário
^ XOR binário
~ Inversão de Bits
2.18.1.3. Lógicos
Operador 1.1.1.5.1.1.1.1 Descrição

&& AND com curto-circuito
|| OR com curto-circuito
! NOT
& AND sem curto-circuito
| OR sem curto-circuito
2.18.1.4. Condicional
Operador Uso Descrição

?: expressão_logica? Caso a expressão lógica seja verdade o val1 será retornado,

val1:val2 caso contrário será retornado val2.
2.18.1.5. Precedência dos Operadores
Os operadores estão listados na ordem decrescente de precedência;

Os operadores na mesma linha têm a precedência igual;
Todos os operadores binários, à exceção dos operadores de atribuição, são avaliados da
esquerda para direita;
Descrição Operadores
operadores do sufixo [ ] . () Chamada de função
operadores unários !, ~, +, -, ++, --
Criação (Type-cast), new
multiplicativos *, /, %
aditivos +, -
SHIFT <<, >>, >>>
relacional <, >, <=, >= instanceof
igualdade ==, !=
AND binário &
XOR binário ^
OR binário |
AND lógico &&
OR lógico ||
Condicional ?:
Atribuição +=, -=, *=, /=, %=, &=, ^=, |=, <=, <=, >>, >=, >>, =
2.18.1.6. Operadores Unários
Incremento e Decremento: ++ e --
int a = 0;
int b = a++; // incrementado depois de atribuir
int c = ++a; // incrementado antes de atribuir
b = a--; // decrementado depois de atribuir
c = --a; // decrementado antes de atribuir
Mais e Menos Unário: + e -
int x = +3; // x recebe o positivo 3

x = -x; // x recebe -3, neste caso
Inversão de Bits: ~
int i = ~1; // i = -2 (os bits foram invertidos)
Complementar booleano: !
boolean falsidade = ! (true); // inverte o valor booleano
Conversão de Tipos: (tipo)jj

double d = 1.99;
int i = (int) d; // converte de double p/ int (perda de
//precisão)
2.18.1.7. Operadores Aritméticos
Multiplicação e Divisão: * e /
int um = 3 / 2; // divisão de inteiros gera um inteiro

float umEmeio = (float) 3 / 2; // ocorre promoção aritmética
para float
double xyz = umEmeio * um; // ocorre promoção aritmética para
float
Módulo: %
int resto = 7 % 2; // resto = 1

Adição e Subtração: + e -
long l = 1000 + 4000;
double d = 1.0 – 0.01;
Concatenação:
long var = 12345;

String str = “O valor de var é “ + var;
Na concatenação de Strings, as variáveis ou literais são promovidos a String antes:
String str = “O valor de var é “ + Long.toString( var );
2.18.1.8. Operadores de Deslocamento
Deslocamento à direita: >>
Número: 192
Binário: |00000000|00000000|00000000|11000000|
Right Shift de 1 bit: |00000000|00000000|00000000|01100000|
Right Shift de 7 bits: |00000000|00000000|00000000|00000001|
Resultado
int i = 192 >> 1
int i = 192 >> 7
Número: -192
Binário: |11111111|11111111|11111111|01000000|
Resultado
int i = -192 >> 1
int i = -192 >> 7
Deslocamento à esquerda: <<

Número: 192
Binário: |00000000|00000000|00000000|11000000|
Left Shift de 1 bit: |00000000|00000000|00000001|10000000|
Left Shift de 7 bits: |00000000|00000000|01100000|00000000|
Resultado
int i = 192 << 1
int i = 192 << 7
Número: -192
Binário: |11111111|11111111|11111111|01000000|
Left Shift de 1 bit: |11111111|11111111|11111110|10000000|
Left Shift de 7 bits: |11111111|11111111|10100000|00000000|
Resultado
int i = -192 << 1
int i = -192 << 7
Deslocamento à direita, sem sinal: >>>
Número: 192
Binário: |00000000|00000000|00000000|11000000|
Resultado
int i = 192 >>> 1
int i = 192 >>> 7
Número: -192
Binário: |11111111|11111111|11111111|01000000|
Resultado
int i = -192 >>> 1
int i = -192 >>> 7
2.18.1.9. Operadores Comparações
Comparação ordinal: >, >=, < e <=
Compara tipos primitivos numéricos e o tipo char.

boolean b = ( 10 < 3 );
boolean w = (x <= y);
if( x >= y ) { }
Operador instanceof
Compara o tipo da classe de uma referência de um objeto.

String str = “Uma String”;
if( str instanceof String ) { } // true
if( srt instanceof Object ) { } // true
Comparação de Igualdade: == e !=
Comparam tipos primitivos, valores literais e referências de objetos.

if( abc == 10 ) { }
boolean b = ( xyz != 50 );
if( refObj1 == refObj2 ) { }
2.15.6.5. Operadores de BITS: &, | e ^
Numéricos Inteiros:
Operando A: 1
Operando B: 3
Binário de A: 00000001
Binário de B: 00000011
A & B: 00000001 = 1
A ^ B: 00000010 = 2
A | B: 00000011 = 3
Booleanos:
true & true = true

true & false = false
true ^ true = false
true ^ false = true
false | false = false
2.18.1.10. Operadores Lógico de curto-circuito
Estes operadores não precisam testar toda a expressão.

Ele pára assim que uma das condições o satisfaça.
O retorno da expressão é um boolean.
if( (a>10) && (b<5) ) {

// isso
}
if( (x==y) || (b<5) ) {
// aquilo
}
boolean b = x && y || z;
2.18.1.11. Operador Condicional
É também conhecido como operador ternário, pois trabalha com 3 operandos.

Ele avalia o primeiro operando.
Caso a avaliação retorne true, ele executa o segundo operando.
Senão, ele executa o terceiro operando.
O segundo e terceiro operandos DEVEM ser do mesmo tipo (senão, use cast).
O código do operador ternário abaixo:
int x = 10;
int y = (x > 10) ? x : x+1;
é semelhante ao código abaixo:
int x = 10;
int y;
if( x > 10 ) {
y = x;
} else {
y = x + 1;
}
2.18.1.12. Operadores de Atribuição
Estes operadores atribuem um novo valor a uma variável ou expressão.

O operador = apenas atribui um valor.
Os operadores +=, -=, *= e /= calculam e atribuem um novo valor.
int i = 10;
int dois = 1;
dois += 1; // dois = dois + 1;
int cinco = 7;
cinco -= 2; // cinco = cinco - 2;
int dez = 5;
dez *= 2; // dez = dez * 2;
int quatro = 12;
quatro /= 3; // quatro = quatro / 3;
3. Lendo e Escrevendo Variáveis

A linguagem Java não possui comandos específicos para leitura de variáveis, pois a
entrada e saída de dados são tratadas de forma independente de dispositivo, através das
classes do pacote java.io. Dessa forma usaremos duas classes que veremos em estrutura de
dados, a classe Scanner e a Classe BufferedReader contendo métodos "estáticos" para leitura
de variáveis do tipo int, char, float e String, a fim de facilitar a prática dos conceitos, que
teremos durante o aprendizado de Técnicas de Programação.
Para escrever variáveis na saída padrão podem ser utilizados os comando:
System.out.print(String);
System.out.println(String); //Salta Linha
Observação: Tipos primitivos/ “objetos” podem ser concatenados com o sinal "+".
Vejamos o seguinte começo de código, que nos ajudará na inserção dos dados, sem
discutirmos cada classe e método, pois, veremos em Estrutura de Dados.
import java.util.Scanner; // importação da Classe Scanner

import java.io.BufferedReader; /* importação da Classe BufferedReader*/
import java.io.InputStreamReader; /* importação da Classe InputStreamReader*/
import java.io.IOException; // importação da Classe IOException
public class LendoEscrevendo // nome da classe

{
public static void main( String args[] )
{
//cria Scanner e p BufferedReader para obter input do teclado
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
Scanner input = new Scanner( System.in );
“Estas linhas acima mostram que estamos utilizando as classes

BufferedReader,InputStreamReader e IOException cada qual dentro do pacote java.io e a
Classe Scanner no pacote java.util. Essas APIs ou Interfaces de Programação de Aplicações
(Application Programming Interface) contêm centenas de classes pré-definidas que se pode
usar nos programas. Essas classes são organizadas dentro do que chamamos de pacotes.
Pacotes contêm classes que se relacionam com um determinado propósito. No exemplo,
so pacotes java.io e java.util contém as classes que permitem capturar dados de entrada e
saída. Estas linhas poderiam ser reescritas da seguinte forma:
import java.io.*;
import java.util.*;
O import que importará todas as classes encontradas no pacote java.io e java.util,

deste modo é possível utilizar todas classes desses pacotes no programa.”
Na instrução:
10. BufferedReader dataIn = new BufferedReader(new

InputStreamReader(System.in));
Declaramos a variável dataIn do tipo BufferedReader. Não se preocupe com o

significado da sintaxe, pois será abordado mais à frente. Utilizamos a variável dataIn para
chamarmos o método que fará o recebimento dos dados digitados:
String name = dataIn.nextLine();
As seguinte linhas definem um bloco try-catch:
try {
name = dataIn.readLine();
}
catch (IOException e) {
System.out.println("Error!");
}
Que asseguram, caso ocorram exceções serão tratadas.
Falaremos sobre o tratamento de exceções no módulo de desenvolvimento de

software para desktop . Por hora, é necessário adicionar essas linhas para utilizar o método
readLine() e receber a entrada de dados do usuário.
Alguns Método e Finalidade da Classe BufferedReader e InputStreamReader:
􀀗 readInt() – captura um número inteiro

􀀗 readDouble() – captura um número Double
􀀗 readBoolean() – captura um Boolean(true ou false)
􀀗 readChar() - captura um caracter
􀀗 readLine() - captura String
Na instrução:
9. Scanner input = new Scanner( System.in );
Definimos uma variável, denominada input, que será criada a partir da classe
Scanner e direcionada para a entrada padrão.
Alguns Método e Finalidade da Classe Scanner:
next() - guarda uma entrada em formato String sem espaço.

nextInt() - guarda uma entrada em formato Inteiro
nextByte() - guarda uma entrada em formato Inteiro
nextLong() - guarda uma entrada em formato Inteiro Longo
nextFloat() - guarda uma entrada em formato Número Fracionário
nextDouble() - guarda uma entrada em formato Número Fracionário
nextLine() - guarda uma entrada em formato String com espaço.
4. Estruturas de Controle
4.1. Estrutura de Seleção ou Condicional
4.1.1Comando if – else
Comando de seleção, o qual permite analisar uma expressão lógica e direcionar a
execução do programa. Caso a expressão lógica seja verdadeira (true) a sequência do if será
executado e caso a expressão lógica seja falsa (false), e exista a cláusula else, a sequência do
else será executada.
Uma alternativa para o uso do if e else é um operador ternário condicional. Este operador
ternário (?: ) , é chamado assim porque tem três termos como parâmetro.
Exemplo:
test ? trueresult : falseresult

int menor = x < y ? x : y ; // A variável menor recebe o valor do menor entre x e y.
if ( expressão_lógica )
Sequência;
Sequência_1;
else
Sequência_2;
Sequência_1;
else if ( expressão_lógica )
Sequência_2;
Sequência_3;
Sequência_4;
else
Sequência_5;
Programa(s) Demonstração ComandoIF.java

/**
* Demonstração do comando if else
*/
import util.Scanner;
public class ComandoIF {
public static void main(String[] args) {
Scanner input = new Scanner( System.in );
/* Validando uma data */
int dia, mes, ano;

System.out.print("Dia : ");
dia = input.nextInt();
System.out.print("Mês : ");
mes = input.nextInt();
System.out.print("Ano : ");
ano = input.nextInt();
boolean data = false;
/* meses de 30 dias */
if ( mes == 4 || mes == 6 || mes == 9 || mes == 11) {
if ( dia >= 1 && dia <= 30 ) {
data = true;
}
} else {
if ( mes == 1 || mes == 3 || mes == 5 || mes == 7 ||
mes == 8 || mes == 10 || mes == 12 ) {
if ( dia >= 1 && dia <= 31 ) {
data = true;
}
} else {
/* fevereiro */
if ( mes == 2 ) {
if ( dia >= 1 && dia <= 28 ) {
data = true;
} else {
/* 29 de fevereiro */
if ( dia == 29 ) {
/* Ano bissexto */
boolean bissexto = ( (ano % 4 == 0) &&
(ano % 100 != 0) ) ||
(ano % 400 == 0);
if ( bissexto ) {
data = true;
}
}
}
}
}
}
System.out.print(dia + "/" + mes + "/" + ano + " : ");
if ( data )
System.out.println("Data Válida");
else
System.out.println("Data Inválida");
}
}
Cláusula if( )
public class ClausulaIf {

int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criança" );
}
if( idade > 12 && idade <= 19 ) {
System.out.println( "Adolescente" );
}
if( idade > 19 && idade <= 60 ) {
System.out.println( "Adulto" );
}
if( idade > 60 ){
System.out.println( "Idoso" );
}
}
}
Cláusula if( )/ else
public class ClausulaIf {

int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criança" );
}
else if( idade <= 19 ) {
System.out.println( "Adolescente" );
}
else if( idade <= 60 ) {
System.out.println( "Adulto" );
}
else {
System.out.println( "Idoso" );
}
}
}
4.2. Estrutura de Repetição
3. Comando while
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que,
antes de cada execução a expressão lógica é analisada.
while ( expressão_lógica )
Sequência;
A condição é uma expressão booleana. Exemplo:
int count=0;
while( count < array1.length && array1[count]!=0){
array2[count]=(float) array1[count++];
}
Cláusula While( )
public class LacoWhile {

int i = 0;
//laço while() com bloco de código definido
while( i < 10 ) {
System.out.println( "Linha: " + i );
i++;
}
}
}
A expressão é avaliada antes de executar o bloco de código

Ele repete enquanto a expressão for verdadeira (true)
Programa(s) Demonstração ComandoWhile.java

/**
* Demonstração do comando while
*/
import java.util.Scanner;
public class ComandoWhile {

int numero;
int fatorial;
Scanner input = new Scanner(System.in);

System.out.println("Calculo do fatorial (flag < 0)");
System.out.print("Número : ");
numero = input.nextInt();
while ( numero >= 0 ) {
fatorial = 1;
while ( numero > 1 ) {
fatorial *= numero;
numero--;
}
System.out.println( "Fatorial : " + fatorial );
System.out.print( "Número : ");
}
System.out.println( "Fim" );
}
}
4. Comando do while
Executa a seqüência do comando enquanto a expressão lógica for verdadeira. Sendo que,
após a execução da sequência a expressão lógica é analisada.
do
Sequência;
while ( expressão_lógica );
Cláusula do while( )
public class LacoWhile {

int i = 0;
//laço do / while() com bloco de código definido
do {
i++;
} while( i < 10 );
}
}
O bloco é executado ao menos uma vez.

Após a primeira repetição é que a expressão é avaliada.
Programa(s) Demonstração ComandoDoWhile.java

/**
* Demonstração do comando do while
*/
public class ComandoDoWhile {

int numero;
int fatorial;
System.out.println("Calculo do fatorial (flag = 0)");
do {
System.out.print("Número : ");
fatorial = 1;
while (numero > 1) {
fatorial *= numero;
numero--;
}
System.out.println("Fatorial : " + fatorial);
} while (numero != 0);
}
}
5. Comando for
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que
permite inicializar variável, na entrada do comando e incrementar variável a cada repetição.
for ( expressão_inicializacao ; expressão_lógica ; expressão_incremento ){

Sequência;
}
Você também pode incluir um comando simples, sendo assim não há necessidade da
utilização de chaves. Exemplo:
String strArray[] = new String[10];

for ( i=0; i< strArray.length; i++)
strArray[i]=””;
Inicializa um array de 10 elementos com “”;
Cláusula For( )
public class LacoFor {

for( int i=0; i < 10; i++ ) {
}
}
}
Programa(s) Demonstração ComandoFor.java

/**
* Demonstração do comando for
*/
public class ComandoFor {

final int inicio = 10;
final int fim = 10;

int resultado = 0;
System.out.print("Tabuada de (+ x) : ");
char tabuada = input.next();
for (int i = 0; i <= inicio; i++ ) {

for (int j = 0; j <= fim; j++) {
switch (tabuada) {
case '+' :
resultado = i + j;
break;
case 'x' :
resultado = i * j;
break;
}
System.out.print(i + " " + String.valueOf(tabuada) + " " +
j + " = " + resultado + "\t");
}
System.out.println();
}
}
}
4.3. Estrutura de Seleção Múltipla

6. Comando switch
Compara (igualdade) uma variável ( byte, char, short ou int ) a uma relação de valores,
permitindo associar comandos a cada valor da relação.
O valor é comparado com cada um dos casos relacionados. Se a combinação não for
encontrada, o bloco default executado. O default é opcional, então caso este não esteja
associado ao comando, o bloco do swicth sem executar nada.
switch (variável) {
case valor1 : sequência_1;
case valor2 : sequência2;
...
case valorN : sequênciaN;
[ default : sequênciaDefault; ]
}
Obs : O comando break normalmente é utilizado como último comando de cada

sequência, indicando que, quando uma sequência for executada todas as outras serão
ignoradas.
Cláusula Switch( )
public class ClausulaSwitch {

int numero = 1;
switch( numero ) {
case 1 :
System.out.println( "UM" );
break;
case 2 :
System.out.println( "DOIS" );
break;
case 3 :
System.out.println( "TRES" );
break;
default :
System.out.println( "NENHUM" );
break;
}
}
}
O switch recebe um argumento do tipo int ou char.
Programa(s) Demonstração ComandoSwitch.java

/**
* Demonstração do comando switch
*/
package Comando;
public class ComandoSwitch {

/* Validando uma data */
int dia, mes, ano;
System.out.print("Dia : ");
dia = input.nextInt();
System.out.print("Mês : ");
mes = input.nextInt();
System.out.print("Ano : ");
ano = input.nextInt();
boolean data = false;
switch (mes) {
case 4 :
case 6 :
case 9 :
case 11 :
if ( dia >= 1 && dia <= 30 )
data = true;
break;
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10 :
case 12 :
if ( dia >= 1 && dia <= 31 )
data = true;
break;
/* fevereiro */
case 2 :
if ( dia >= 1 && dia <= 28 ) {
data = true;
} else {
/* 29 de fevereiro */
if ( dia == 29 ) {
/* Ano bissexto */
boolean bissexto = ( (ano % 4 == 0)&&
(ano % 100 != 0) ) ||
(ano % 400 == 0);
if ( bissexto ) {
data = true;
}
}
}
default : data = false;
}
System.out.print(dia + "/" + mes + "/" + ano + " : ");

if ( data )
System.out.println("Data Válida");
else
System.out.println("Data Inválida");
}
}
4.4. Instruções
7. Comando break
Força a saída de um comando de repetição ou do comando switch
Cláusula break()
Aborta a execução de um laço, quando executado.
public class ClausulaBreak {

char letras[] = { 'A', 'B', 'C', 'D', 'E' };
int i;
for( i=0; i<letras.length; i++ ) {
if( letras[i] == 'C' ) {
break;
}
}
System.out.println( "Último índice: " + i );
}
}
Cláusula break rotulada

Aborta a execução de um laço rotulado, quando executado.
int j = 0, i = 0;
principal1: while( true ) {
for( i=0; i<1000; i++ ) {
if( j == 10 && i == 100 )
break principal1;
}j++;
}
8. Comando continue
Força o início da próxima iteração de um comando de repetição.
Cláusula continue()
Ignora a execução dos comandos seguintes do bloco, no laço, quando executado.
public class ClausulaContinue {

char letras[] = { 'B', 'X', 'R', 'A', 'S', 'I', 'L' };
int i;
for( i=0; i<letras.length; i++ ) {
if( letras[i] == 'X' ) {
continue;
}
System.out.print( letras[i] );
}
}
}
Cláusula continue rotulada
Ignora a execução dos comandos seguintes do bloco, do laço rotulado, quando executado.
int i=0, j=0;

principal2: for( j=1; j<10; j++ ) {
for( i=1; i<10; i++ ) {
if( (i % j) == 0 ) {
System.out.println( "i=" + i + " j=" + j );
continue principal2;
}
}
j++;
}
Programa(s)Demonstração ComandoBreakContinue.java
/**
* Demonstração do comando break e continue
*/
public class ComandoBreakContinue {

for (int i = 0; i <= 1000 ; i++ ) {
if ( i == 10 )
break;
System.out.print(i + " ");
}
System.out.println();
for (int i = 0; i <= 20 ; i++) {

if ( i <= 10 )
continue;
System.out.print(i + " ");
}
}
}
5. Recursividade
Recursividade é um termo usado de maneira mais geral para descrever o processo de
repetição de um objeto de um jeito similar ao que já fora mostrado. Um bom exemplo disso
são as imagens repetidas que aparecem quando dois espelhos são apontados um para o outro.
5.1. Fatorial
Na matemática, o fatorial de um número natural n, representado por n!, é o produto de
todos os inteiros positivos menores ou iguais a n. A notação n! foi introduzida por Christian
Kramp em 1808.
Por exemplo,
Note que esta definição implica em particular que
Porque o produto vazio, isto é, o produto de nenhum número é 1.
O método abaixo mostra o calculo do Fatorial
// Método recursivo Fatorial
public class FatorialCalculador

{
// declaração recursiva do método fatorial
public long fatorial( long number )
{
if ( number <= 1 ) // testa caso básico
return 1; // caso básico: 0! = 1 e 1! = 1
else // passo de recursão
return number * fatorial( number - 1 );
} // final do método fatorial
// gera saída de fatoriais para valores 0-10

public void displayFatorial()

{
// calcula o factorial de 0 a 10
for ( int counter = 0; counter <= 10; counter++ )
System.out.printf( "%d! = %d\n", counter, fatorial( counter ) );
} // fim do método displayFatorial
} //
O codigo abaixo chama o código acima:
public class FactorialTest

{
// calcular factorial de 0-10
{
FatorialCalculador fatorialCalculador = new FatorialCalculador();
fatorialCalculador.displayFatorial();
} // fim do método main
} // fim da classe FatorialTest
5.2. Série de Finobacci

Na matemática, os Números de Fibonacci são uma seqüência.
Na prática: você começa com 0 e 1, e então produz o próximo número de Fibonacci

somando os dois anteriores para formar o próximo. Os primeiros Números de Fibonacci
(sequência A000045 na OEIS) para n = 0, 1,… são
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
6765…
Esta sequência foi descrita primeiramente por Leonardo de Pisa, também conhecido
como Fibonacci (Dc. 1200), para descrever o crescimento de uma população de coelhos. Os
números descrevem o número de casais em uma população de coelhos depois de n meses se
for suposto que:
No primeiro mês nasce apenas um casal, Casais amadurecem sexualmente (e
reproduzem-se) apenas após o segundo mês de vida, Não há problemas genéticos no
cruzamento consangüíneo, Todos os meses, cada casal fértil dá a luz a um novo casal, e Os
coelhos nunca morrem.
// Metodo recursivo fibonacci
public class FibonacciCalculator

{
// declaração recursiva do método fibonacci
public long fibonacci( long number )
{
if ( ( number == 0 ) || ( number == 1 ) ) // caso base

return number;
else // etapa de recursão
return fibonacci( number - 1 ) + fibonacci( number - 2 );
} // end method fibonacci
public void displayFibonacci()

{
for ( int counter = 0; counter <= 10; counter++ )
System.out.printf( "Fibonacci of %d is: %d\n", counter,
fibonacci( counter ) );
} // end method displayFibonacci
} // end class FibonacciCalculator
// Testando o método recursive fibonacci
public class FibonacciTest

{
{
FibonacciCalculator fibonacciCalculator = new FibonacciCalculator();
fibonacciCalculator.displayFibonacci();
} // fim main
} // fim da classe FibonacciTest
6. Estrutura de Dados
Como percebemos, se quisermos guardar dados de diferentes tipos teremos problemas,
pois, variáveis (de tipos primitivos) não suportam tipos diferentes de dados, não agora. Para
resolvermos teremos de agora para frente estudarmos Estrutura de Dados.
É o modo particular de armazenamento e organização de

dados em um computador para que possamos usá-los de um
modo eficiente. (Wikipédia, 2010)
Além disto, temos as estruturas de dados dinâmicas que crescem e encolhem em tempo de
execução. Que são elas: Listas, Pilhas, Filas, Árvores.
6.1. Array
Array é uma coleção ordenada de primitivos, referências para objetos e outras arrays. Os
arrays em Java são homogêneos, ou seja, eles só podem conter dados do mesmo tipo. Os
arrays são objetos, e devem ser construídos antes de serem usados.
Lembrando que o nome array servirá para os conhecidos vetores e matrizes em outra
linguagem, aqui no Java trataremos com Array.
Passos para utilizar arrays:
- Declaração
- Criação
- Iniciação
int[ ] umArray; //declarando uma array (vetor)
umArray = new int[ 10 ]; //criando uma array(vetor) de 10 posições
umArray[ 0 ] = 0; //já preenchendo a array no índice escolhido
umArray[ 1 ] = 999; //já preenchendo a array no índice escolhido
short[][] jogoDaVelha = new short[3][3]; //declarando e criando

//uma array(matriz)
double[] d = { 1.0d, 0.99, 3.14 };//já preenchendo a array
Podemos percorrer os array de forma automática, usando o laço for( ). O índice dos arrays
vai de 0 (zero) até N-1 (onde N é o tamanho do array).
Obs: É aconselhável sempre que criar uma Array inicializa-lá.
Exemplo:
public class PreencherComPesos {
double[] pesos = new double[10];
//aqui sabemos o tamanho do array
for(int i=0; i<10; i++) {
peso[i] = 0;
}
}
}
public class PercorrendoArray {
double[] precos = new double[100];
//aqui sabemos o tamanho do array
for(int i=0; i<100; i++) {
precos[i] = i * 2.99;
}
//aqui não importa o tamanho do array
for(int i=0; i<precos.length; i++) {
precos[i] = i * 2.99;
}
}
}
Os arrays não mudam de tamanho. Acessar um índice inexistente causa uma exceção:
ArrayIndexOutOfBoundsException.
import java.util.*;
public class ExemploException1 {

private Vector v = new Vector();
public ExemploException1() {
v.add("Disciplina 1");
v.add("Disciplina 2");
imprimeVetor();
}
public void imprimeVetor() {
System.out.println("O número de elementos do vetor é "+v.size());
for (int i = 0; i <= v.size(); i++) {
System.out.println(v.elementAt(i).toString());
}
} Irá produzira exceção
ArrayIndexOutOfBoundsException
public static void main (String par[]) {
ExemploException1 exemploExc = new ExemploException1();
}
}
Arrays possuem um atributo tamanho, que pode ser usado para determinar o tamanho, em
bytes, de um Array:
int arrayLength = intArray.length; // determinando o tamanho do Array
Lembre-se que isto é o número total de bytes ocupado pelo array e não o número de
elementos contidos nele. Como na maioria das linguagens de programação, em Java, não é
possivel alterar o tamanho de um Array depois da sua criação.
6.2. Curiosidades sobre Array
Sobre as Arrays temos algo que devemos estudar, array é uma matriz mesmo que seja de
uma coluna e uma linha (vetor), mais de uma linha e coluna(matriz), como chego nos
números inseridos na diagonal principal, na diagonal secundária, nos números abaixo da
diagonal principal, acima da diagonal secundária, os números impares do lado esquerdo entre
as diagonais, os números do lado direito entre a diagonal principal e a secundária? Todas estas
perguntas sanaremos no exemplo abaixo que será de uma matriz 5 X 5.
Obs: O encontro de uma linha com uma coluna forma uma célula
Achando as diagonais:
I. Diagonal Principal:
a. A Linha = Coluna
1 2 3 4 5
1 L1XC1
2 L2XC2
3 L3XC3
4 L4XC4
5 L5XC5
A linha é IGUAL a coluna.
II. Diagonal Secundária:

a. A Linha + Coluna = 6
1 2 3 4 5
1 L1XC5
2 L2XC4
3 L3XC3
4 L4XC2
5 L5XC1
A SOMA da linha com a coluna é IGUAL a 6.

III. Células acima da diagonal principal:

a. A Linha < Coluna
1 2 3 4 5
1 L1XC1 L1XC2 L1XC3 L1XC4 L1XC5
2 L2XC2 L2XC3 L2XC4 L2XC5
3 L3XC3 L3XC4 L3XC5
4 L4XC4 L4XC5
5 L5XC5
A linha é MENOR que a coluna.
IV. Células abaixo da diagonal principal:

a. A Linha > Coluna
1 2 3 4 5
1 L1XC1
2 L2XC1 L2XC2
3 L3XC1 L3XC2 L3XC3

A linha é MAIOR que coluna.
V. As células acima da Diagonal Secundária:

a. A Linha + Coluna < 6
1 2 3 4 5
3 L3XC1 L2XC2 L3XC3
4 L4XC1 L4XC2
5 L5XC1
A soma da linha com a coluna é MENOR 6.
VI. As células abaixo da Diagonal Secundária:

a. A Linha + Coluna > 6
1 2 3 4 5
1 L1XC5
2 L2XC4 L2XC5
3 L3XC3 L3XC4 L3XC5
A soma da linha com a coluna é MAIOR 5.

VII. Célula igual para a diagonal principal e a secundária:

a. A se (L = C) e (L + C = 6)
1 2 3 4 5
1 L1XC1 L1XC5
2 L2XC2 L2XC4
3 L3XC3
4 L4XC2 L4XC4
5 L5XC1 L5XC5
A Linha é IGUAL a Coluna e a SOMA da linha com a coluna é IGUAL a 6, ficará:
VIII. Células ABAIXO da diagonal principal e a secundária:

a. se (C + L > 6 )
1 2 3 4 5
1 L1XC1 L1XC5
2 L2XC2 L2XC4
3 L3XC3
4 L4XC2 L4XC4
5 L5XC1 L5XC5
A SOMA da linha com a coluna é MAIOR a 6.

IX. Células ACIMA da diagonal principal e a secundária:

a. A se (C + L < 6)
1 2 3 4 5
1 L1XC1 L1XC5
2 L2XC2 L2XC4
3 L3XC3
4 L4XC2 L4XC4
5 L5XC1 L5XC5
A SOMA da linha com a coluna é MENOR que 6.
X. Células LADO ESQUERDO diagonal Principal e Secundária:

a. se (L > C) e (L + C < 6)
1 2 3 4 5
1 L1XC1 L1XC5
2 L2XC2 L2XC4
3 L3XC3
4 L4XC2 L4XC4
5 L5XC1 L5XC5
A LINHA é maior que A COLUNA e soma DE LINHA E COLUNA é menor que 6 .
XI. Células LADO DIREITO diagonal Principal e Secundária:

a. A se (L < C) e (L + C > 6)
1 2 3 4 5
1 L1XC1 L1XC5
2 L2XC2 L2XC4
3 L3XC3
4 L4XC2 L4XC4
5 L5XC1 L5XC5
A LINHA é menor que A COLUNA e soma DE LINHA E COLUNA é maior que 6 .
7. Função e Procedimento
7.1. Procedimento
O procedimento é conhecido como sub-rotina, é um conjunto de instruções que

realiza determinada tarefa. Um método de procedimento é criado da mesma maneira que
outro método qualquer, deve ser identificado e possuir variáveis, operações e até funções.
Para construir este método em Java, representado procedimento, utiliza-se a seguinte
sintaxe:
Static void nome_Método (<argumentos>)
{
<instruções>;
}
Onde
Static: é um modificador que indica que o método será alocado em memória sem que
haja necessidade de ser instanciado. Não necessita objeto; pode ser invocado com base no
nome da classe.
Os modificadores são elementos que caracterizam o método quanto à visibilidade
(esxcopo) e à qualidade. Os métodos, bem como as classes e as variáveis, podem possuir
mais de um modificador, não importando sua ordem. Alem do static, outros
modificadores muito utilizados são:
• public - pode ser invocado livremente e indica um método que é visível para
qualquer um que enxergue a classe;
• protected – pode ser utilizado apenas no mesmo pacote e em subclasses;
• private – pode ser invocado apenas na classe;
• final – não pode ser sobrescrito e equivale à declaração de constante.
Existem outros modificadores, como abstract, native, transient, volatile e

syncronized.
• void - indica que não será retornado nenhum valor do programa que realizou
a chamada;
• <nome_Método>\- é um identificador válido da linguagem, obedece às
mesmas regras que os identificadores de classe, objeto e variável;
• <argumentos> - indica a lista de argumentos que serão passados como
parâmetros para o método. A sintaxe dos argumentos é a mesma da
declaração de variáveis: tipo_dado identificador, e os vários parâmetros são
separados por vírgulas.
7.2. Funções
As funções são criadas da mesma maneira que os procedimentos. A diferença entre os

dois é que elas podem ser utilizadas em expressões, como se fossem variáveis, pois as funções
retornam valores que são associados ao seu nome, e para esses valores é necessária a pó de
dado a ser retornado.
Obs: Tanto funções como procedimentos podem utilizar outras funções e procedimentos.
Exemplo:
public class ExFatorial {

public static void main(String args []) {
int num;
int fat;
printf ("Informe um número para fatorar");
num = input.nextInt();
fat = fatorial (num);
System.out.printf ("O fatorial de " + " " + num + " é "+
fat);
}
static int fatorial (int num) {
int f = 1;
for (int I = 1;I <= num; i++)
f = f + i;
return f;
}
Parâmetros
Parâmetros são variáveis ou valores que podem ser transferidos do algoritmo principal
para um módulo que está sendo chamado. Eles funcionam como comunicadores entre os
módulos. Existem dois tipos de parâmetros: os formais e os reais.
Formais – são declarados nos módulos e tratados como as variáveis. Tem a função de
receber os valores passados do algoritmo que o chama. O algoritmo que chama a função ou o
procedimento informa os valores que substituirão esses parâmetros.
Exemplo:
Static void multiplicar (double a, double b) {
double res;
res = a + b;
System.out.println("Resultado é " + res);
}
Reais – são os valores passados pela rotina chamadora ao módulo (função ou
procedimento). Esses valores substituem os parâmetros formais.
Exemplo:
public class ExMultiplica {

public static void main(String args []) {
int num, num2;
printfln ("Informe o primeiro número: ");
num = input.nextInt();
printfln ("Informe o segundo número: ");
num2 = input.nextInt();
multiplicar (num, num2);
}
Static void multiplicar (double a, double b) {
double res;
res = a + b;
System.out.println("Resultado é " + res);
}
Passagem de parâmetros por valor e por referência

Na passagem de parâmetros por valor, o valor do parâmetro real é copiado para o
parâmetro formal do módulo, preservando, assim, o valor original do parâmetro.
O Exemplo é conforme o exemplo ExMultiplica.
Na passagem de parâmetros por referência, toda alteração feita nos parâmetros formais
reflete-se nos parâmetros reais. Assim, o parâmetro é de entrada e saída.
Exemplo.
public class Classe1{
int valor;
String nome;
public Classe1(){
valor = 0;
nome = "ninguem";
}
public class Classe2{
public Classe2(){
Classe1 c = new Classe1();
System.out.println(c.nome + " , " + c.valor);
altera(c); //por referencia
System.out.println(c.nome + " , " + c.valor);
}
public void altera(Classe1 newC){

newC.valor = 100;
newC.nome = "Isso é referencia";
}
public static void main(String args[]){

new Classe2();
}
}
8. Busca e Ordenação
Quando o usuário insere os dados não se preocupa em como ordená-los ou como achará
algum valor dentro de suas variáveis (vetor, matrizes). Assim, é comum encontrarmos
elementos armazenados de maneira aleatória em nossos sistemas.
Para se ter um melhor desempenho em um programa a necessidade desta ordenação é de
grande importância.
8.1. Ordenação
A realização de comparações sucessivas e troca de elementos de posição, os quais, muitas

vezes, estão relacionados ou trabalham em conjunto com algoritmo de busca, destinados a
localizar determinado elemento de forma mais eficiente é chamado de ordenação.
8.1.1.1. Ordenação por seleção
É o método considerado um dos mais simples e constitui-se na execução dos passos

indicados a seguir:
1. Selecione o menor elemento da sequência.
2. Troque-o com o que está na primeira posição.
3. Repita as operações anteriores para os demais elementos, até que reste apenas um.
O exemplo a seguir ilustra a aplicação dessa técnica para um conjunto de números
inteiros, sendo que cada linha corresponde a uma iteração.
Posição 1 2 3 4 5 6 7 8
Valores Iniciais 23 4 33 45 19 12 28 40
Iteração 1 4 23 33 45 19 12 28 40
Iteração 2 4 12 33 45 19 23 28 40
Iteração 3 4 12 19 45 33 23 28 40
Iteração 4 4 12 19 23 33 45 28 40
Iteração 5 4 12 19 23 28 45 33 40
Iteração 6 4 12 19 23 28 33 45 40
Iteração 7 4 12 19 23 28 33 40 45
Tabela 1 Exemplo de ordenação por seleção
O conjunto apresentado faz parte de um vetor, a técnica procura o menor consumo de

memória, evitando, por exemplo, a criação de um novo vetor ordenado partindo do
primeiro.
A eficiência de um programa de ordenação deve considerar, além do menor consumo de
memória, o menor número de iterações e trocas de elementos para obter o resultado final.
public class ordencaoselecao{

public static void main (String args[]){
int numeros[] = {23, 4, 33, 45, 19, 12, 28, 40};
int menor, x;
for(int i = 0; i < numeros.length; i++){

System.out.printf("\nnumeros[ " + i + " ] = " +
numeros[i]);
}
System.out.printf("\n");
System.out.printf("\n*************Ordenados*************");
for(int i = 0; i < numeros.length-1; i++){
menor = i;
x = numeros[i];
for(int j = i + 1;j < numeros.length;j++){
if(numeros[j] < x){
menor = j;
x = numeros[j];
}
}
numeros[menor] = numeros[i];
numeros[i] = x;
}
for(int i = 0; i < numeros.length; i++){
System.out.printf("\nnumeros[ " + i + " ] = "
+ numeros[i]);
}
}
}
8.2. Ordenação por trocas – método da bolha
O método de ordenação por trocas consiste em comparar pares consecutivos de valores e

permutá-los caso estejam fora de ordem. O algoritmo determina uma sequência de com de
comparações sistemáticas que varrem a sequência de dados como um todo, fazendo com que
o menor valor (ou maior, de acordo com a ordem desejada) acabe no início da sequência, e
tenha início uma nova série de comparações sistemáticas.
Valores Inicias
Iteração 1
Iteração 2
Iteração 3
Iteração 4
Iteração 5
Iteração 6
Iteração 7
Posição
1 23 4 4 4 4 4 4 4
2 4 23 12 12 12 12 12 12
3 33 12 23 19 19 19 19 19
4 45 33 19 23 23 23 23 23
35 19 45 33 28 28 28 28 28
6 12 19 45 33 33 33 33 33
7 28 28 28 45 40 40 40 40
8 40 40 40 40 45 45 45 45
Tabela 2Exemplo de ordenação por trocas
Em cada passagem, um elemento é deslocado para a posição inicial, isto é, um elemento é

ordenado. Assim, uma sequência com n elementos terá, após a primeira passagem, um
elemento ordenado e n-1 elementos por ordenar. Na segunda passagem, a sequência terá dois
elementos em-2 elementos por ordenar, e assim sucessivamente.
O deslocamento do elemento menor para a posição inicial é feito por comparações e
trocas sucessivas, iniciando-se pelo penúltimo e ultimo. Se o valor do elemento com índice 07
for maior que o elemento com índice 08, eles são trocados de posição, no exemplo 02, 28 não
é maior que 40, então eles permanecem na mesma posição. O processo prossegue até que seja
feita a comparação entre o primeiro e o segundo elementos, lembrando que a cada valores são
trazidos para as primeira posições, ao mesmo tempo que os de maiores valores são levados
para as últimas.
Para vermos a eficiência da ordenação pelo método da bolha, teremos que olhar os dois
exemplos mostrados anteriormente e constataremos nele já na quarta iteração tínhamos os
elementos ordenados. E na ordenação por seleção somente na 07 e última iteração.
Código:
public class metodobolha {
public static void main (String args[]) {
int numeros[] = {23, 4, 33, 45, 19, 12, 28, 40};
int x,i ;
for (i = 0; i<8;i++){
System.out.printf("\n numeros[ " + i + " ] = " + numeros[i]);

}
System.out.printf("\n****** OS NÚMEROS ORDENADOS MÉTODO BOLHA *****");
//Logo abaico é a ordenação com o metodo Bolha
for ( i = 1;i < numeros.length; i++) {
for (int j = numeros.length-1;j >= i; j--) {
if (numeros[j-1] > numeros[j]) {
x = numeros[j-1];
numeros[j-1] = numeros[j];
numeros[j] = x;
}
}
}
for (i = 0; i<8;i++){
System.out.printf("\n numeros[ " + i+ " ] = " + numeros[i]);
}
}
}
8.3. Busca
Possuímos os dados e o que fazer com eles? Como recuperá-los com eficiência? A
responsabilidade é do programador.
Procurar por nomes e números em uma lista pequena é rápido, mas, quando esta lista
é enorme temos problema. Sistemas trabalham, frequentemente, com a busca de números,
códigos, nomes, siglas, etc. e precisam de uma resposta rápida para não comprometer seu
desempenho.
Os algoritmos de buscas são alguns dos mais utilizados no mundo da informática,
sendo aplicados em bancos dedados, internet e jogos, entre outros. Aqui serão apresentados
alguns exemplos de algoritmos de busca linear e busca binária.
8.3.1. Busca Linear (ou seqüencial)
A maneira mais fácil de fazer uma busca é comparar o elemento que se está
procurando com todos os elementos guardados, um a um, isto é, procurar o elemento
sequencialmente até que ele seja encontrado.
O algoritmo que realiza essa busca é uma estrutura de repetição que percorre toda a
sequência de elementos, realizando uma condicional que compara o elemento desejado
com os elementos existentes na sequência.
Comparações sucessivas são feitas entre o elemento que se procura e os

elementos da lista, até que uma igualdade seja estabelecida ou que não
contenha o elemento desejado na lista.
Figura 5Busca Linear
Quando o elemento é encontrado, retorna-se o valor verdadeiro, o que indica o

sucesso da busca e encerra a estrutura de repetição. É claro que a maneira de encerrar
essa estrutura dependerá da linguagem de programação a ser utilizada, assim como o que
o programador necessitar.
public class Busca {

public static boolean linear (int x, int dados [ ]) {
final int n = dados.length;
for (int i = 0; i < n; i++)
if (x == dados [i])
return true;
return false;
}
plubic static boolean linear(String x, String dados [ ]) {
for (int i = 0; i < n; i++)
if (x.equalsIgnoreCase (dados [i]))
return true;
return false;
}
}
A classe Busca incorpora os dois métodos de busca referenciados pelo nome linear
que, como já dissemos, estão sobrecarregados, diferenciados pelos tipos dos dados passados
como parâmetros.
Além do método já citado, a classe String possui alguns métodos de comparação
direta entre dois string. O método equals (Object) é derivado da superclasse Object e pode ser
utilizado para comparar o conteúdo completo de dois objetos quaisquer, inclusive String. Esse
método é bastante utilizado,mas para nossos exemplos é mais conveniente utilizar o método
equalsIghoreCase (String), que faz a comparação apenas entre objetos do tipo String,
eliminando o problema de comparações entre minúsculas e maiúsculas.
public class Busca {
public static boolean linear(int x, int dados[]){
for(int i = 0; i < n; i++)
if (x == dados[i])
return true;
return false;
}
//com equalsIgnoreCase para eliminar problemasde
comparações entre minúsculas e maiúsculas
public static boolean linear(String x,String dados[]){

for(int i = 0; i < n; i++)
if(x.equalsIgnoreCase(dados[i]))
return true;
return false;
}
}
A classe Busca tem os dois métodos de busca referenciadospelo nome linear, estão
sobrecarregados, diferenciados pelos tipos dos dados passados como parâmetros.
8.3.2. Busca Binária (ou busca logarítmica)
O método de busca linear é o mais adequado quando não se tem nenhuma

informação a respeito da estrutura em que a busca será realizada. Contudo, se o
elemento\procurado estiver entre os últimos ou não estiver no conjunto, esse método
poderá ser demasiadamente lento, pois ocorrerão comparações com todos os elementos
de um conjunto que pode ser muito grande.
Quando temos uma sequência ordenada de elementos, existem outros métodos de

busca que são muito mais adequados, pois permitem realizar uma busca por meio de
algoritmos mais eficientes, que podem utilizar um número menor de comparações.
Considere uma sequência ordenada de elementos de qualquer tipo. Em vez de
comparar o elemento procurado ao primeiro elemento da sequência, pode-se compará-lo
a um elemento do meio da sequência. Se o elemento comparado é o desejado, a busca
termina; senão, pode-se verificar se o elemento desejado é maior ou menor que o
elemento encontrado. Como todos os elementos estão ordenados, essa verificação
elimina a metade da sequência onde o elemento não pode estar.
A segunda comparação será feita com o elemento do meio da sequência que restou, e
o procedimento anterior se repetirá. Dessa forma, cada vez que o elemento não for
encontrado, o conjunto a ser pesquisado será reduzido pela metade, aproximadamente,
até que o elemento seja encontrado ou até que a lista não possa mais ser dividida.
Esse método foi chamado de método de busca logarítmica pelo fato de haver uma
redução logarítmica de elementos a serem pesquisados, porem, como essa redução
ocorre pela metade dos elementos da busca em cada comparação, ele também é
conhecido como método de busca binária.
Vamos considerar o exemplo abaixo. Suponha que o elemento a ser localizado seja o
número 329, que será chamado de x:
500 178 2 487 158 47 35 78 329 215 19 25 214 38 77
1º. Passo – Ordenar o conjunto:

2 19 25 35 38 47 77 78 158 178 214 215 329 487 500
2º. Passo – Dividir o conjunto ao meio:
2 19 25 35 38 47 77 78 158 178 214 215 329 487 500
3º. Passo – Efetuar a comparação para verificar se o elemento procurado é igual ao

elemento central, que será chamado de meio:
x = meio
Se o resultado for verdadeiro, a busca deverá ser encerrada. Caso contrario, serão
executados os passo seguintes. No caso de nosso exemplo:
329 = 78, a resposta é falso.

4º. Passo – Efetuar a comparação para verificar se o elemento procurado é maior ou
menor do que o elemento central:
329 >= 78, a resposta é verdadeira.
5º. Passo, Proceder a uma nova divisão do conjunto que atenda à condição do 4º.
Passo, isto é , se x for maior que o meio, será dividido o conjunto da direita, senão, o
conjunto da esquerda. No caso do exemplo, será utilizado o conjunto da direita.
158 178 214 215 329 487 500
Repetir os passos 4 e 5 até que o elemento seja encontrado.
329 487 500
public class BuscaBinaria {

public static boolean binária (int x, int numeros []){
int inicio = 0, fim = numeros.length-1;
int meio;
while (inicio <= fim) {
meio = (inicio + fim) / 2;
if ( x == numeros[meio])
return true;
if (x < numeros[meios])
fim = meio - 1;
else
inicio = meio + 1;
}
return false;
}
}
Esta classe somente apresenta a criação de um método para busca de números

inteiros. Seguindo-se as mesmas considerações de comparações dadas anteriormente, pode-se
modificar ou ampliar essa classe para fazer pesquisa por meio do método de busca binária
para outro tipo qualquer ou para strings.
Exemplo completo com inserção de números no vetor, ordenação e pesquisa.
package tecest;
import java.util.Scanner; // importação da Classe Scanner
public class exemplobusca // nome da classe

{
{
BuscaBinaria busca = new BuscaBinaria();
int qte,num, x, numpesq;
boolean achou;
Scanner input = new Scanner( System.in ); //cria entrada para teclado
System.out.print("Informe quantos números: ");
qte = input.nextInt();
int numeros []= new int [qte];
System.out.println("Informe a quantidade de:");
System.out.println(qte);
// laço de repetição para preenchimento do vetor
for (int i = 0; i < qte; i++){
numeros[i]=input.nextInt();
}
System.out.println(numeros[i]);
}
//Logo abaico é a ordenação com o metodo Bolha
for ( int k = 1;k < numeros.length; k++) {
for (int j = numeros.length-1;j >= k; j--) {
if (numeros[j-1] > numeros[j]) {
x = numeros[j-1];
numeros[j-1] = numeros[j];
numeros[j] = x;
}
}
}
System.out.println(numeros[i]);
}
System.out.println("Informe número a ser pesquisado: ");
numpesq = input.nextInt();
if (busca.binária(numpesq, numeros)==true)
System.out.println("O número pesquisado encontrado");
else
System.out.println("O número pesquisado não encontrado");
}
}
9. Estruturas de dados Dinâmicas

As estruturas de dados são, muitas vezes, a maior dificuldades do programador
inexperiente.
Quando falamos em listas, filas, pilhas e árvores podemos dizer que todas são, na
verdade "listas de informações" cujas diferença principal está no acesso a essas "listas" para
inclusão e remoção de informações.
Quando falamos em alocação dinâmica, utilizamos posições descontinuadas da
memória RAM. Isso é possível pois cada um dos elementos da "lista" deve possuir uma
referência para os elementos seguintes e anterior. Essa referência é o endereço da posição de
memória em que se encontra tal elemento.
Obs: a linguagem Java não suporta ponteiros. Assim, serão utilizados objetos que
farão referência aos elementos.
9.1. Listas
Uma lista é uma coleção de elementos do mesmo tipo dispostos linearmente que
podem ou não seguir determinada organização, por exemplo [E1, E2, E3, E4, E5,..., En], onde n
deve ser >= 0.
Exemplo de lista de pagamentos a serem efetuados em um mês:
Lista de pagamentos
Prestação do carro
Cartão de crédito
Conta de luz
Condomínio
TV a cabo
Supermercado
Quando criamos uma lista para ser utilizada como estrutura de dados, podemos usar
como contêiner para armazenamento dos dados um vetor ou uma matriz, então dizemos que
se trata de uma lista implementada por meio de arranjo (array). Por outro lado, também
podemos utilizar a alocação dinâmica, isto é, não criamos um contêiner para armazenar os
dados, mas precisamos referenciar os elementos seguinte e anterior de cada elemento, então
teremos uma lista encadeada.
Veja o exemplo acima de lista simples:
Lista de pagamentos ← [prestação do carro, cartão de credito, conta de luz, condomínio,
TV a cabo, supermercado]
Essa é uma lista que possui seis elementos do tipo literal, e os elementos estão
armazenados em um vetor.
9.1.1. Lista encadeadas
É um conjunto de elementos que estão dispostos em uma dada organização física

não-linear, isto é, estão espalhados pela memória. Para organizar a lista de maneira para que
ela possa ser utilizada como um conjunto linear, é necessário que cada elemento do conjunto
possua informações sobre o seu elemento anterior e o seu elemento seguinte. Para
exemplificar será utilizada a lista de pagamentos que devem ser efetuados no mês. Os
pagamentos estão dispostos em uma ordem linear:
Lista de pagamentos
Prestação do carro
Cartão de crédito
Conta de luz
Condomínio
TV a cabo
Supermercado
Olhando para a lista, pode-se perceber qual é o primeiro, qual o é o segundo e assim
por diante. Porém, quando desejamos implementar essa lista em uma estrutura de dados,
precisamos dizer qual será o próximo elemento. Para isso, cada elemento da lista é
representado por um nó, e cada nó deve conter os dados e um campo que indique qual é o
próximo elemento da lista – esse campo é chamado de referência (ou ponteiro como em outras
linguagens). Observe a seguinte lista com um campo para encadeamento.
Lista de pagamentos Referência para o próximo elemento
Prestação do carro 2
Cartão de crédito 3
Conta de luz 4
Condomínio 5
TV a cabo 6
Este é o último elemento do conjunto,
Supermercado
então não aponta para nenhum outro.
1
Prestação do carro 2 Cartão de crédito 3 Conta da luz
4 Condomínio 5 TV a cabo 6 Supermercado

Vantagens:
• A inserção ou remoção de um elemento na lista não implica a mudança de
lugar de outros elementos;
• Não é necessário definir, no momento da criação da lista, o número máximo
de elementos que esta poderá ter. Ou seja, é possível alocar memória
"dinamicamente", apenas para o número de nós necessários.
Desvantagens:
• A manipulação torna-se mais "perigosa" uma vez que, se o encadeamento
(ligação) entre elementos da lista for mal feito, toda a lista pode ser perdida;
• Para aceder ao elemento na posição n da lista, deve-se percorrer os n - 1
anteriores.
9.1.2. Tipos de Lista encadeadas
As listas encadeadas podem ser do tipo:

• Encadeamento simples: os elementos da lista possuem apenas uma
referência que aponta para o elemento sucessor ou próximo;
• Duplamente encadeadas: cada elemento possui um campo que aponta
para o seu predecessor (anterior) e outro para o seu sucessor (próximo);
• Ordenadas: a ordem linear da lista corresponde à ordem lienar dos
elementos, ist é, quando um novo elemento é inserido na lista ele deve ser
colocado em tal posição que garanta que a ordem da lista será mantida.
Essa ordem pode ser definida por um campo da área de dados, por
exemplo, se tivermos uma lista ordenada com os seguintes valores
[1,5,7,9] e desejarmos incluir um novo elemento com o valor 6, este valor
deverá ser incluído entre os valores 5 e 7.
Uma lista ordenada pode ser de encadeamento simples ou duplo, mas o princípio
para a ordenação é o mesmo.
• Circulares: a referência do próximo do último elemento aponta para o
primeiro; e a referência do anterior do primeiro aponta para o último.
9.1.2.1. Lista encadeamento Simples

A seguir será apresentado o algoritmo que representa a criação e a

manipulação de uma lista de encadeamento simples.
Classe que cria a estrutura de um nó simples:
class IntNoSimples {
int valor;
IntNoSimples prox;
IntNoSimples(int ValorNo){
valor = ValorNo;
prox = null;
}
Classe ListaSimples cria a estrutura de uma lista, cujos nós terão a estrutura definida
pela classe IntNoSimples. Neste exemplo, os nós são inseridos sempre no final da lista.
class ListaSimples {
IntNoSimples primeiro, ultimo;
int numero_nos;
ListaSimples() {
primeiro = ultimo = null;
numero_nos = 0;
}
void insereNo_fim(IntNoSimples novoNo) {

novoNo.prox = null;
if (primeiro == null)
primeiro = novoNo;
if (ultimo != null)
ultimo.prox = novoNo;
ultimo = novoNo;
numero_nos++;
}
O funcionamento da Lista encadeada simples:

class ExecListaSimples {

ListaSimples Slist = new ListaSimples105 ();
Slist.insereNo_fim (new IntNoSimples (1));
}
}
O acréscimo dos métodos buscar, contar, excluir e exibir:
class ExeListaSimplesCompleta {
IntNoSimples primeiro, ultimo;
int numero_nos;
ExeListaSimplesCompleta (){
}
void insereNo_fim (IntNoSimples novoNo){
novoNo.prox = null;
primeiro = novoNo;
if (ultimo != null)
ultimo = novoNo;
}
void insereNo_inicio (IntNoSimples novoNo){
if (primeiro != null)
{novoNo.prox = primeiro;
primeiro = novoNo;
}
else
{if (primeiro == null)
primeiro = novoNo;
ultimo = novoNo;
}
}
int ContarNos(){
int tamanho = 0;
IntNoSimples temp_no = primeiro;
while (temp_no != null)
{tamanho++;
temp_no = temp_no.prox;
}
return tamanho;
}
void insereNo_posicao(IntNoSimples novoNo, int posicao){
int numero_nos = ContarNos();
int pos_aux;
if(posicao == 0)
{novoNo.prox = primeiro;
if(primeiro == ultimo)
{ultimo = novoNo;}
primeiro = novoNo;}
else
{if (posicao <= numero_nos)
{pos_aux = 1;
while(temp_no != null && posicao > pos_aux)
{temp_no = temp_no.prox;
pos_aux ++;
}
novoNo.prox = temp_no.prox;
temp_no.prox = novoNo;
}
else
{if(posicao > numero_nos)
{ultimo.prox = novoNo;
ultimo = novoNo;
}
}
}
}
IntNoSimples buscaNo (int buscaValor){
int i = 0;
{if (temp_no.valor == buscaValor)
{System.out.println ("No " + temp_no.valor + " posição " + i);
return temp_no;
}
i++;
}
return null;
}
void excluiNo (int valor){
IntNoSimples noAnterior = null;
while (temp_no.prox != null && temp_no.valor != valor)
{noAnterior = temp_no;
}
System.out.println(temp_no.valor + "proximo" + temp_no.prox.valor);
temp_no = noAnterior.prox.prox;
System.out.println(temp_no.valor + "proximo" + temp_no.prox.valor);
}
void exibeLista(){

int i = 0;
{System.out.println("Valor " + temp_no.valor + " posição " + i);
i++;
}
}
}
O funcionamento da lista encadeada simples completa:

import javax.swing.JOptionPane;
class ListEncaSimples {
static ExeListaSimplesCompleta Slist = new ExeListaSimplesCompleta ();
int i = 0;
IntNoSimples temp_no;
int valor;
public static void main(String args[]){

int opcao = 1, valor, posicao;
while (opcao != 7) {
opcao = Integer.parseInt (JOptionPane.showInputDialog(null, "Escolha uma Opçao
\n" + "1-Inserir Nó no início \n" + "2-Inserir Nó no fim \n" + "3-Inserir Nó em uma
posição\n" + "4-Localizar Nó \n" + "5-Excluir Nó \n" + "6-Exibir lista \n" + "7-Sair"));
switch (opcao) {
case 1 :
valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Inserir um Nó no
início da lista \n" + "Digite um valor"));
Slist.insereNo_inicio(new IntNoSimples(valor));
break;
case 2 :
valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Inserir um Nó no
final da lista \n" + "Digite um valor"));
Slist.insereNo_fim(new IntNoSimples(valor));
break;
case 3 :
valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Inserir um Nó em
uma posição \n" + "Digite um valor"));
posicao = Integer.parseInt (JOptionPane.showInputDialog(null, "Digite a
posição"));
Slist.insereNo_posicao(new IntNoSimples(valor),posicao);
break;
case 4:
valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Localiza
um valor \n" + "Digite um valor"));
Slist.buscaNo(valor);
break;
case 5:
valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Exlui um
nó da lista \n" + "Digite um valor"));
Slist.excluiNo(valor);
break;
case 6:
JOptionPane.showMessageDialog(null,"Exibe a lista");
Slist.exibeLista();
break;
default : JOptionPane.showMessageDialog(null,"Sair");
}
}
}
}
9.1.2.2. Lista Duplamente encadeadas
Quando se percorre uma lista de encadeamento simples é bastante difícil

fazer o caminho inverso. Na listas de encadeamento duplo esse problema não existe,
pois cada nó possui uma referência para o próximo elemento da lista e outra para o
anterior.
Criação do nó:
class IntNoDuplo {
int valor;
IntNoDuplo prox;
IntNoDuplo ant;
IntNoDuplo (int ValorNo){

valor = ValorNo;
prox = ant = null;
}
}
Implementação dos métodos inserir, alterar(pegar), excluir:

public class ListaDupla {
IntNoDuplo primeiro, ultimo;
int numero_nos;
ListaDupla(){
numero_nos = 0;
}
void insereNo (IntNoDuplo novoNo){
novoNo.prox = null;
novoNo.ant = ultimo;
primeiro = novoNo;
if (ultimo != null)
ultimo = novoNo;
numero_nos++;
}
IntNoDuplo pegarNo (int indice){
IntNoDuplo temp_no = primeiro;
for (int i = 0; (i < indice) && (temp_no != null); i++)

return temp_no;
}
void incluiNo (IntNoDuplo novoNo, int indice){
IntNoDuplo temp_no = pegarNo (indice);
novoNo.prox = temp_no;
if (novoNo.prox != null){
novoNo.ant = temp_no.ant;
novoNo.prox.ant = novoNo;
} else {
novoNo.ant = ultimo;
ultimo = novoNo;
}
if (indice == 0){
primeiro = novoNo;
} else {
novoNo.ant.prox = novoNo;
}
numero_nos++;
}
void excluiNo (int indice){
if (indice == 0){
primeiro = primeiro.prox;
if (primeiro != null)
primeiro.ant = null;
} else {
IntNoDuplo temp_no = pegarNo (indice);
temp_no.ant.prox = temp_no.prox;
if (temp_no != ultimo){
temp_no.prox.ant = temp_no.ant;
} else {
ultimo = temp_no;
}
}
numero_nos--;
}
}
Utilização das classes criadas anteriormente:

class ExListaDupla{
public static void main(String[] args){
ListaDupla Slist = new ListaDupla ();
Slist.insereNo (new IntNoDuplo (1));
IntNoDuplo temp_no = Slist.primeiro;
while (temp_no != null){
System.out.println (temp_no.valor);
}
Slist.incluiNo (new IntNoDuplo (2), 1);
System.out.println ("Apos incluir o no 2...");
temp_no = Slist.primeiro;
}
Slist.excluiNo (2);
System.out.println ("Apos excluir o no 3...");
temp_no = Slist.primeiro;
}
}
}
9.1.3. Filas
O conceito de fila em programação é o mesmo das filas dos nosso dia a dia, nas quais
esperamos ser atendidos em ordem: o primeiro elemento a entrar na fila será o primeiro
elemento a sair. Esse conceito é conhecido como first in, first out ou FIFO, expressão
conhecida em português como PEPS ou "primeiro que entra, primeiro que sai". Então, no
conceito de Fila, os elementos são atendidos, ou utilizados, sequencialmente, na ordem em
que são armazenados.
As filas (queues) são conjuntos de elementos (ou listas) cujas operações de inserção
são feitas por uma extremidade, e as de remoção, por outra.
Como exemplo, pode-se implementar uma fila de impressão, na qual os arquivos que
devem ser impressos são organizados em uma lista e serão impressos na ordem de chegada, à
medida que a impressora estiver disponível.
Podemos utilizar a para implementação das filas ou por objetos(referência). Primeiro
iremos utilizar os objetos (referência), utilizando para isto uma array. Para isto precisamos
construir um registro que contenha as informações da fila, como o início, o final e o contêiner
de elementos que é um vetor; neste caso cada um dos elementos da fila será representado por
uma posição no vetor. Veja a estrutura:
class Fila {
int tamanho;
int inicio;
int fim;
int total;
int vetor[];
Fila(int tam) {
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new int [tam];
}
public boolean vazia () {

if (total == 0)
return true;
else
return false;
}
public boolean cheia () {
if (total >= tamanho)
return true;
else
return false;
}
public void enfileirar(int elem) {
if (!cheia())
{ vetor[fim] = elem;
fim++;
total++;
if (fim >= tamanho)
fim = 0;
}
else
{ System.out.println("Fila Cheia");
}
}
public String desenfileirar()
{String elem = "Fila vazia";
{ if (vazia() == false)
{elem = String.valueOf(vetor[inicio]);
inicio++;
if (inicio >= tamanho)
inicio = 0;
total --;
return elem;
} else
return elem;
}
}
public void exibeFila()
{for (int i = 0; i < total; i++)
{System.out.println("posicao " + i + " valor " + vetor[i]);
}
}
}
Vantagens:
•
A inserção ou remoção de um elemento na lista não implica a mudança de
lugar de outros elementos;
• Não é necessário definir, no momento da criação da lista, o número
máximo de elementos que esta poderá ter. Ou seja, é possível alocar
memória "dinamicamente", apenas para o número de nós necessários.
Desvantagens:
• A manipulação torna-se mais "perigosa" uma vez que, se o encadeamento

(ligação) entre elementos da lista for mal feito, toda a lista pode ser perdida;
• Para aceder ao elemento na posição n da lista, deve-se percorrer os n - 1
anteriores.
9.1.4. Pilhas
As pilhas também são conhecidas como lista LIFO ou PEPS. Trata-se de uma lista
linear em que todas as operações de inserção e remoção são feitas por um único extremo
denominado topo. Um exemplo bastante comum em que se aplica o conceito de pilhas é o de
uma pilha de pratos que estão guardados no armário: quando a pessoa utiliza um deles, pega
sempre o prato que se encontra no topo da pilha, assim como, quando um novo prato for
guardado, será colocado no topo. Isso acontece porque apenas uma das extremidades da pilha
está acessível.
Método pilha:
public class pilha {

int tamanho;
int topo;
Object vetor[];
pilha (int tam){
topo = -1;
tamanho = tam;
vetor = new Object [tam];
}
public boolean vazia(){
if(topo == -1)
return true;
else
return false;
}
public boolean cheia(){

if (topo == tamanho -1)
return true;
else
return false;
}
public void empilhar (Object elem){

if (cheia()== false){
topo++;
vetor[topo] = elem;
}
else
System.out.println("Pilha Cheia");
}
public Object desempilhar(){
Object valorDesempilhado;
if (vazia() == true)
valorDesempilhado = "Pilha Vazia";
else{
valorDesempilhado = vetor[topo];
topo--;
}
return valorDesempilhado;
}
public void exibePilha(){

if (vazia() == true)
System.out.println ("Pilha Vazia");
else {
for (int i = topo;i >= 0;i--)
System.out.println("Elemento " + vetor[i] + " posiÃ§Ã£o
" + i);
}
}
Utilização do método Pilha:

public class usaPilha {
public static void main (String args[]){

pilha P = new pilha(5);
int i = 0;
int valor = 0;
int opcao = 1;
while (opcao != 4){
System.out.println("Escolha uma OpÃ§Ã£o: ");
System.out.println("1 - Inserir um elemento na pilha:
");
System.out.println("2 - Excluir elemento da Pilha: ");
System.out.println("3 - Exibir elementos da fila: ");
System.out.println("4 - Sair: ");
opcao = input.nextInt();
switch (opcao){
case 1 :
System.out.println("Empilhar elemento \n" +
"Digite um Valor" );
valor = input.nextInt();
P.empilhar(valor);
break;
case 2 :
System.out.println("Empilhar desempilhado " +
P.desempilhar() );
break;
case 3 :
P.exibePilha();
break;
default:
System.out.println("Sair !");
break;
}
}
}
}
9.1.5. Árvores
Uma árvore é uma estrutura de dados bidimensional, não-linear, que possui

propriedades especiais e admite muitas operações de conjuntos dinâmicos, tais como:
pesquisa, inserção, remoção, entre outros. É diferente das listas e pilhas, uma vez que estas
são estruturas de dados lineares. As árvores são muito úteis para implementação de algoritmos
que necessitam de estruturas hierárquicas, como, por exemplo, os diretórios ou as pastas de

arquivos de um computador.
Figura – um exemplo de árvore (Windows Explorer)

Uma árvore, de modo geral, possui as seguintes características:
• Nó raiz – nó do topo da árvore, do qual descendem os demais nós. É o
primeiro nó da árvore;
• Nó interior – nó do interior da árvore (que possui descendentes);
• Nó terminal – nó que não possui descendentes;
• Trajetória – número de nós que devem ser percorridos até o nó determinado;
• Grau do nó – número de nós descendentes do nó, ou seja, o número de
subárvores de um nó;
• Grau da árvore – número máximo de subárvores de um nó;
• Altura da árvore – número máximo de níveis dos seus nós;
• Altura do nó – número máximo de níveis dos seus nós.
As árvores podem ser do tipo lista generalizadas ou binárias, entre outras. As árvores
do tipo listas generalizadas possuem nós com grau maior ou igual a zero, enquanto uma
árvore do tipo binária sempre possui nós com grau menor ou igual a 02.
Classe representa o nó da árvore:
class BIntNo{
int valor;
BIntNo esq, dir;
BIntNo (int novoValor){

valor = novoValor;
}
}
9.1.5.1. Árvores binárias
Uma árvore binária sempre possui nós com grau menor ou igual a 02, isto é, nenhum
nó possui mais do que dois descendentes diretos (dois filhos). Nesse tipo de árvore também
existe uma particularidade quanto à posição dos nós: os nós da direita sempre possuem valor
superior ao do nó pai, e os nós da esquerda sempre possuem valor inferior ao do nó pai.
Figura – árvore binária

Classe completa de uma árvore:
class BArvore{
BIntNo Raiz;
private BIntNo inserir (BIntNo arvore, int novoNo){
if (arvore == null)
return new BIntNo(novoNo);
else
{if (novoNo < arvore.valor)
arvore.esq = inserir (arvore.esq, novoNo);
else
arvore.dir = inserir (arvore.dir, novoNo);
return arvore;}
}
public void inserirNo (int novoValor){
Raiz = inserir (Raiz, novoValor);
}
private void exibir_esquerdo (BIntNo arv){
if (arv != null){
exibir_esquerdo (arv.esq);
System.out.println (arv.valor);
}}
private void exibir_direito (BIntNo arv){
if (arv != null){
exibir_direito (arv.dir);
System.out.println (arv.valor);
}
}
public void exibir_raiz()
{System.out.println("Raiz " + Raiz.valor);
}
public void exibirNo_esq (){
exibir_esquerdo (Raiz);
}
public void exibirNo_dir (){
exibir_direito (Raiz);
}
public void excluirNo (int item){
try{
BIntNo tempNo = Raiz, pai = null, filho = Raiz, temp;
while (tempNo != null && tempNo.valor != item){
pai = tempNo;
if (item < tempNo.valor)
tempNo = tempNo.esq;
else
tempNo = tempNo.dir;
}
if (tempNo == null)
System.out.println ("Item nao localizado.");
if (pai == null){
if (tempNo.dir == null)
Raiz = tempNo.esq;
else
if (tempNo.esq == null)
Raiz = tempNo.dir;
else{
for (temp = tempNo, filho = tempNo.esq;
filho.dir != null; temp = filho, filho = filho.dir);
if (filho != tempNo.esq){
temp.dir = filho.esq;
filho.esq = Raiz.esq;
}
filho.dir = Raiz.dir;
Raiz = filho;
}
} else if (tempNo.dir == null){
if (pai.esq == tempNo)
pai.esq = tempNo.esq;
else
pai.dir = tempNo.esq;
} else if (tempNo.esq == null){
pai.esq = tempNo.dir;
else
pai.dir = tempNo.dir;
} else {
for (temp = tempNo, filho = tempNo.esq;
filho.dir != null; temp = filho, filho = filho.dir);
if (filho != tempNo.esq){
temp.dir = filho.esq;
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
pai.esq = filho;
else
pai.dir = filho;
}
} catch (NullPointerException erro) {
//Item nao encontrado
}
}
}
Utilização do código acima:
class usaArvore{
public static void main(String[] args){
BArvore arvore1 = new BArvore ();
arvore1.inserirNo (14);
arvore1.exibirNo_esq();
arvore1.exibirNo_dir();
arvore1.exibir_raiz();
System.out.println ("Nós a esquerda ");
System.out.println ("Nós a direita ");
System.out.println("Exclusão de nó");
arvore1.excluirNo(12);
arvore1.exibir_raiz();
System.out.println ("Árvore após a exclusão do nó de valor 12");
System.out.println ("Nós a esquerda ");
System.out.println ("Nós a direita ");
}
}
10. Bibliografia
Puga, Sandra; issetti, Gerson. Lógica de programação e estrutura de dados com aplicações em
Java. 2ª ed, São Paulo: Pearson,2009.
T. Goodrich, Michael; Tamassia, Roberto. Estruturas de dados e Algoritmos em Java. 4ª ed,
São Paulo: Bookman, 2006.
http://www.gforum.tv/board/1345/120437/manual-java-arrays-em-java.html
http://pt.wikipedia.org/wiki/Fatorial

Introdução à linguagem Java

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introdução à linguagem Java

Uploaded by

Copyright:

Available Formats

SUMÁRIO

1. ARQUITETURA E FERRAMENTAS ................................................................................................... 1

2.8. IDENTIFICADORES ........................................................................................................................... 10

2.15. CONVERSÃO ENTRE TIPOS PRIMITIVOS ........................................................................................... 13

2.16. STRING ................................................................................................................................. 14

3. LENDO E ESCREVENDO VARIÁVEIS ...............................................................................................22

8.2. ORDENAÇÃO POR TROCAS – MÉTODO DA BOLHA .................................................................................. 50

9.1.3. FILAS ...................................................................................................................................... 71

10. BIBLIOGRAFIA ..............................................................................................................................82

O que aprendemos em algoritmo:

Figura 1Funcionamento da JVM(Java Virtual Machine)

Figura 3 Funcionamento do Java em diferentes plataformas

1.2. Configurando o JAVA no Linux

A configuração do pacote J2SDK (Java Software Development Kit - ou

Bom, se você instalou o JDK no /root, então ficou

pois bem, basta você colocar isso no $JAVA_HOME:

# Eu criei um diretorio para minhas classes

# As manpages som _muito_ importantes

- Após o término do download, execute o arquivo que você baixou, e siga as

• Constantes com todas as letras em maiúsculo:

2.2. Sequência { sequência }

2.3. Ponto e vírgula, Blocos e o espaço em branco

2.4. A declaração import

Existem três tipos de comentários em Java, sendo eles :

2.6. Palavras Reservadas

com o while para determinar se o bloco deverá ser executado novamente

2.7. O primeiro Programa em Java

a. Certifique-se de ter adicionado a sua lista de path’s o path do compilador e

c. Chame o compilador Java para este arquivo: Javac HelloInternet.Java

f. Observe o resultado na tela: Hello Internet!

//Comentario de uma linha

public class HelloInternet {

public static void main (String args[])

//Comentario de uma linha

public class HelloInternet {

public static void main (String args[]) {

Se você gosta de paradoxos e já conhece um pouco de orientação a objetos, pense que se o

Semelhante ao void C++ ou C, é o valor de retorno da função, quando a função não

É o argumento de main e por conseqüência do programa todo, ele é um vetor de Strings

Java HelloInternet argumentotexto1 argumentotexto2

No nosso caso, ignoramos a possível passagem de argumentos via linha de comando,

1 A primeira posição deverá ser com uma letra, “_” ou “$”

Observação: Os identificadores Java são case-sensitive

2.9. Variáveis e Constantes

tipo variável [ = ValorInicial ];

Em Java as constantes são variáveis declaradas como final.

final int a = 10;

// a = 11; -> iria dar um

Em Java a conversão de dados entre variáveis é automática quando:

2.10. Mais sobre atribuições

2.11. Definindo Variáveis de Instância

class Bike extends Veículo {

2.12. Variáveis de Classe

static int soma;

2.13. Escopo de Variável

2.14. Tipos de Dados Primitivos

2.14.1.1. Tipos Numéricos Inteiros

Tipo Tamanho em bits Faixa

2.14.1.2. Tipos Numéricos Reais

Tipo Tamanho em bits Faixa

2.14.1.3. Tipo caracter

Tipo Tamanho em bits Faixa