APOSTILA.AEDs1.UniBH

Prévia do material em texto

1 
 
 
 
 
 
 
 
 
Dep. Ciências Exatas e Tecnologia 
 
 
_______________________________ 
 
Algoritmos e Estruturas de Dados 
com ênfase em Java 
(AEDs 1) 
_______________________________ 
 
 
 
Versão 1.0 
 
Publicação interna 
Reprodução Restrita 
 
 
 
 
Profa: Pollyanna Miranda de Abreu 
 
 
 
 
 
 2 
 
 
 
 
Sumário 
 
APRESENTAÇÃO ................................................................................................................. 4 
1. Introdução à Lógica de Programação .......................................................................... 5 
1.1 Lógica ...................................................................................................................... 5 
1.2 Seqüência Lógica .................................................................................................... 5 
1.3 Instruções ................................................................................................................ 5 
1.4 Algoritmo ................................................................................................................. 6 
1.5 Programas ............................................................................................................... 8 
1.6 EXERCÍCIOS .......................................................................................................... 8 
2. Desenvolvendo algoritmos ........................................................................................ 10 
2.1 Pseudocódigo ........................................................................................................ 10 
2.2 Regras para construção do Algoritmo .................................................................... 10 
2.3 Fases..................................................................................................................... 10 
2.4 Exemplo de Algoritmo ............................................................................................ 11 
2.5 Teste de Mesa ....................................................................................................... 12 
2.6 EXERCÍCIOS ........................................................................................................ 13 
3. Diagrama de Bloco .................................................................................................... 14 
3.1 O que é um diagrama de bloco? ............................................................................ 14 
3.2 Simbologia ............................................................................................................. 14 
3.3 14 
3.4 Simbologia ............................................................................................................. 16 
4. Constantes, Variáveis e Tipos de Dados ................................................................... 17 
4.1 Constantes ............................................................................................................ 17 
4.2 Variáveis ................................................................................................................ 17 
4.3 Tipos de Variáveis ................................................................................................. 18 
4.4 Declaração de Variáveis ........................................................................................ 18 
4.5 EXERCÍCIOS ........................................................................................................ 18 
5. Operadores ............................................................................................................... 21 
5.1 Operadores Aritméticos ......................................................................................... 21 
5.2 Operadores Relacionais ........................................................................................ 21 
5.3 Operadores Lógicos .............................................................................................. 23 
5.4 Operadores Relacionais ........................................................................................ 23 
 
 
 
 
 3 
 
 
 
8.Introdução Linguagem de Programação Java ................................................................... 32 
8.1 O que é Java? ........................................................................................................ 32 
8.2 A história do Java ................................................................................................... 33 
8.3 A máquina virtual ................................................................................................... 34 
8.4 Versões do Java ................................................................................................... 36 
8.5 JVM? JRE? JDK? .................................................................................................. 36 
8.6 Objetivos do java ................................................................................................... 37 
8.7 Instalando o java ................................................................................................... 37 
8.8 Compilando o primeiro programa em Java ............................................................ 38 
8.9 Variáveis primitivas e controle de fluxo .................................................................. 39 
Instruções de laço for e while, controle de fluxo com break e continue. ............................... 39 
8.10 Comentários em Java ............................................................................................ 39 
9.Testando código em Java ............................................................................................. 40 
10.Tipos primitivos em Java ................................................................................................. 41 
10.1. Exercício de fixação .................................................................................................... 42 
11. Casting e Promoção ...................................................................................................... 43 
12. Instruções de desvio ...................................................................................................... 45 
18. Vetores e matrizes em Java ........................................................................................... 53 
20. Algoritmos de ordenação ............................................................................................... 57 
REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................................... 63 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 4 
 
 
 
 
 
APRESENTAÇÃO 
 
 
 
“Muda a forma de trabalhar, agir, sentir, pensar na chamada sociedade do 
conhecimento”. 
Peter Drucker 
 
 
 
O ingresso na sociedade da informação exige mudanças profundas em todos os 
perfis profissionais, especialmente naqueles diretamente envolvidos na produção, 
coleta, disseminação e uso da informação. 
 
O UniBh, o melhor centro universitário de Belo Horizonte (fonte: MEC),sabe isso, 
e ,consciente do seu papel formativo , educa o aluno sob a égide do conceito da 
competência:” formar o profissional com responsabilidade no processo 
produtivo, com iniciativa na resolução de problemas, com conhecimentos 
técnicos aprofundados, flexibilidade e criatividade, empreendedorismo e 
consciência da necessidade de educação continuada.” 
 
Vivemos numa sociedade da informação. O conhecimento, na sua área tecnológica, 
amplia-se e se multiplica a cada dia. Uma constante atualização se faz necessária. 
Para o UniBH, cuidar do seu acervo bibliográfico, da sua infovia, da conexão da 
faculdade à rede mundial de informações – internet- é tão importante quanto zelar 
pela produção de material didático. 
 
Isto porque, nos embates diários, professores e alunos, nas diversas salas de aulas 
e laboratórios do UniBH, fazem com que as informações, contidas nos materiais 
didáticos, tomemsentido e se concretizem em múltiplos conhecimentos. 
 
O UniBH deseja, por meio dos diversos materiais didáticos, aguçar a sua 
curiosidade, responder às suas demandas de informações e construir links entre os 
diversos conhecimentos, tão importantes para sua formação continuada ! 
 
 Profa. Pollyanna Abreu 
 
 
 
 
 
 
 
 
 
 
 
 
 5 
 
 
 
 
1. Introdução à Lógica de Programação 
1.1 Lógica 
 
A lógica de programação é necessária para pessoas que desejam trabalhar com 
desenvolvimento de sistemas e programas, ela permite definir a seqüência lógica 
para o desenvolvimento. 
Então o que é lógica? 
 
1.2 Seqüência Lógica 
Estes pensamentos, podem ser descritos como uma seqüência de instruções, que 
devem ser seguidas para se cumprir uma determinada tarefa. 
 
1.3 Instruções 
Na linguagem comum, entende-se por instruções “um conjunto de regras ou 
normas definidas para a realização ou emprego de algo”. 
 
Convém ressaltar que uma ordem isolada não permite realizar o processo completo, 
para isso é necessário um conjunto de instruções colocadas em ordem seqüencial 
lógica. 
 
Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em 
prática uma série de instruções: descascar as batatas, bater os ovos, fritar as 
batatas, etc... 
 
Lógica de programação é a técnica de encadear pensamentos para atingir 
determinado. 
Seqüência Lógica são passos executados até atingir um objetivo ou solução 
de um problema. 
 
 
 
 6 
 
 
 
É evidente que essas instruções tem que ser executadas em uma ordem adequada 
– não se pode descascar as batatas depois de fritá-las. 
 
Dessa maneira, uma instrução tomada em separado não tem muito sentido; para 
obtermos o resultado, precisamos colocar em prática o conjunto de todas as 
instruções, na ordem correta. 
 
1.4 Algoritmo 
Um algoritmo é formalmente uma seqüência finita de passos que levam a execução 
de uma tarefa. Podemos pensar em algoritmo como uma receita, uma seqüência de 
instruções que dão cabo de uma meta específica. Estas tarefas não podem ser 
redundantes nem subjetivas na sua definição, devem ser claras e precisas. 
 
Como exemplos de algoritmos podemos citar os algoritmos das operações básicas 
(adição, multiplicação, divisão e subtração) de números reais decimais. Outros 
exemplos seriam os manuais de aparelhos eletrônicos, como um videocassete, que 
explicam passo-a-passo como, por exemplo, gravar um evento. 
 
Até mesmo as coisas mais simples, podem ser descritas por seqüências lógicas. 
Por exemplo: 
 
“Chupar uma bala”. 
 
• Pegar a bala 
• Retirar o papel 
• Chupar a bala 
• Jogar o papel no lixo 
 
Instruções são um conjunto de regras ou normas definidas para a realização 
ou emprego de algo. Em informática, é o que indica a um computador uma 
ação elementar a executar. 
 
 
 
 7 
 
 
 
“Somar dois números quaisquer”. 
• Escreva o primeiro número no retângulo A 
• Escreva o segundo número no retângulo B 
• Some o número do retângulo A com número do retângulo B e coloque o 
resultado no retângulo C 
 
 
 
 
História dos Algoritmos 
 
 
Conceitos importantes: 
Software: parte lógica do computador (programas). 
Hardware: parte física do computador (periféricos) 
Peopleware: Pessoa que utiliza o computador e seus recursos. 
 
 
Retângulo 
A 
Retângulo 
B 
Resultado 
 
 
 
 8 
 
 
 
 
1.5 Programas 
 
Os programas de computadores nada mais são do que algoritmos escritos numa 
linguagem de computador (Pascal, C, Cobol, Fortran, Visual Basic entre outras) e 
que são interpretados e executados por uma máquina, no caso um computador. 
Notem que dada esta interpretação rigorosa, um programa é por natureza muito 
específico e rígido em relação aos algoritmos da vida real. 
 
1.6 EXERCÍCIOS 
 
1) Crie uma seqüência lógica para tomar banho: 
 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________ 
 
2) Faça um algoritmo para somar dois números e multiplicar o resultado pelo 
primeiro número. 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________ 
 
3) Descreva com detalhes a seqüência lógica para Trocar um pneu de um carro. 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
 
 
 
 9 
 
 
 
_________________________________________________________________
_________________________________________________________________ 
 
4) Faça um algoritmo para trocar uma lâmpada. Descreva com detalhes: 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________ 
 
 
 
 10 
 
 
 
 
2. Desenvolvendo algoritmos 
2.1 Pseudocódigo 
Os algoritmos são descritos em uma linguagem chamada pseudocódigo. Este nome 
é uma alusão à posterior implementação em uma linguagem de programação, ou 
seja, quando formos programar em uma linguagem, por exemplo Visual Basic, 
estaremos gerando código em Visual Basic. Por isso os algoritmos são 
independentes das linguagens de programação. Ao contrário de uma linguagem de 
programação não existe um formalismo rígido de como deve ser escrito o algoritmo. 
 
O algoritmo deve ser fácil de se interpretar e fácil de codificar. Ou seja, ele deve ser 
o intermediário entre a linguagem falada e a linguagem de programação. 
 
 
2.2 Regras para construção do Algoritmo 
Para escrever um algoritmo precisamos descrever a seqüência de instruções, da 
maneira mais simples e objetiva. Para isso utilizaremos algumas técnicas: 
 
• Usar somente um verbo por frase 
• Imaginar que você está desenvolvendo um algoritmo para pessoas que não 
trabalham 
• com informática 
• Usar frases curtas e simples 
• Ser objetivo 
• Procurar usar palavras que não tenham sentido dúbio. 
 
2.3 Fases 
 
No capítulo anterior vimos que ALGORITMO é uma seqüência lógica de instruções 
que podem ser executadas. 
 
É importante ressaltar que qualquer tarefa que siga determinado padrão pode ser 
descrita por um algoritmo, como por exemplo: 
 
COMO FAZER ARROZ DOCE 
 
ou então 
 
CALCULAR O SALDO FINANCEIRO DE UM ESTOQUE 
 
Entretanto ao montar um algoritmo, precisamos primeiro dividir o problema 
apresentado em três fases fundamentais. Onde temos: 
 
 
 
 
 
 11 
 
 
 
 
ENTRADA: São os dados de entrada do algoritmo 
PROCESSAMENTO: São os procedimentos utilizados para chegar ao resultado final 
SAÍDA: São os dados já processados 
Analogia com o homem 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2.4 Exemplo de Algoritmo 
Imagine o seguinte problema: Calcular a média final dos alunos da 3ª Série. Os 
alunos realizarão quatro provas: P1, P2, P3 e P4. 
 
Onde: 
 
Para montar o algoritmo proposto, faremos três perguntas: 
 
a) Quais são os dados de entrada? 
R: Os dados de entrada são P1, P2, P3 e P4 
 
b) Qual será o processamento a ser utilizado? 
R: O procedimento será somar todos os dados de entrada e dividi-los por 4 
(quatro) 
 
c) Quais serão os dados de saída? 
R: O dado de saída será a média final 
 
 
 
 
 12 
 
 
 
 
Algoritmo 
 
Receba a nota da prova1 
Receba a nota de prova2 
Receba a nota de prova3 
Recebaa nota da prova4 
Some todas as notas e divida o resultado por 4 
Mostre o resultado da divisão 
 
2.5 Teste de Mesa 
 
Após desenvolver um algoritmo ele deverá sempre ser testado. Este teste é 
chamado de TESTE DE MESA, que significa, seguir as instruções do algoritmo de 
maneira precisa para verificar se o procedimento utilizado está correto ou não. 
 
Veja o exemplo: 
 
Nota da Prova 1 
Nota da Prova 2 
Nota da Prova 3 
Nota da Prova 4 
 
Utilize a tabela abaixo para entrar com dados: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 13 
 
 
 
2.6 EXERCÍCIOS 
 
1) Identifique os dados de entrada, processamento e saída no algoritmo abaixo 
 
• Receba código da peça 
• Receba valor da peça 
• Receba Quantidade de peças 
• Calcule o valor total da peça (Quantidade * Valor da peça) 
• Mostre o código da peça e seu valor total 
2) Faça um algoritmo para “Calcular o estoque médio de uma peça”, sendo que 
TOQUEMÉDIO= (QUANTIDADE MÍNIMA + QUANTIDADE MÁXIMA) /2 
 
3) Teste o algoritmo anterior com dados definidos por você. 
 
 
 
 
 14 
 
 
 
 
3. Diagrama de Bloco 
 
3.1 O que é um diagrama de bloco? 
 
O diagrama de blocos é uma forma padronizada e eficaz para representar os passos 
lógicos de um determinado processamento. 
 
Com o diagrama podemos definir uma seqüência de símbolos, com significado bem 
definido, portanto, sua principal função é a de facilitar a visualização dos passos de 
um processamento. 
 
3.2 Simbologia 
Existem diversos símbolos em um diagrama de bloco. No decorrer do curso 
apresentaremos os mais utilizados. Veja no quadro abaixo alguns dos símbolos que 
iremos utilizar: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3.3 
Dentro do símbolo sempre terá algo escrito, pois somente os símbolos não nos 
dizem nada. Veja no exemplo a seguir: 
 
 
 
 
 15 
 
 
 
Exemplos de Diagrama de Bloco 
 
“CHUPAR UMA BALA” “CALCULAR A MÉDIA DE 4 NOTAS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Veja que no exemplo da bala seguimos uma seqüência lógica somente com 
informações diretas, já no segundo exemplo da média utilizamos cálculo e exibimos 
o resultado do mesmo. 
 
 
 
 
 16 
 
 
 
3.4 Simbologia 
 
1) Construa um diagrama de blocos que : 
 
• Leia a cotação do dólar 
• Leia um valor em dólares 
• Converta esse valor para Real 
• Mostre o resultado 
 
2) Desenvolva um diagrama que: 
 
• Leia 4 (quatro) números 
• Calcule o quadrado para cada um 
• Somem todos e 
• Mostre o resultado 
 
3) Construa um algoritmo para pagamento de comissão de vendedores de 
peças, levando-se em consideração que sua comissão será de 5% do total 
da venda e que você tem os seguintes dados: 
 
• Identificação do vendedor 
• Código da peça 
• Preço unitário da peça 
• Quantidade vendida 
 
E depois construa o diagrama de blocos do algoritmo desenvolvido, e por 
fim faça um teste de mesa. 
 
 
 
 
 
 
 
 17 
 
 
 
4. Constantes, Variáveis e Tipos de Dados 
 
Variáveis e constantes são os elementos básicos que um programa manipula. Uma 
variável é um espaço reservado na memória do computador para armazenar um tipo 
de dado determinado.Variáveis devem receber nomes para poderem ser 
referenciadas e modificadas quando necessário. Um programa deve conter 
declarações que especificam de que tipo são as variáveis que ele utilizará e as 
vezes um valor inicial. Tipos podem ser, por exemplo: inteiros, reais,caracteres, etc. 
As expressões combinam variáveis e constantes para calcular novos valores. 
 
 
4.1 Constantes 
Constante é um determinado valor fixo que não se modifica ao longo do tempo, 
durante a execução de um programa. Conforme o seu tipo, a constante é 
classificada como sendo numérica, lógica e literal. 
 
Exemplo de constantes: 
 
 
 
 
 
 
4.2 Variáveis 
 
Variável é a representação simbólica dos elementos de um certo conjunto. Cada 
variável corresponde a uma posição de memória, cujo conteúdo pode ser alterado 
ao longo do tempo durante a execução de um programa. Embora uma variável 
possa assumir diferentes valores, ela só pode armazenar um valor a cada instante. 
 
 
 
 
 
 
 
 
 18 
 
 
 
4.3 Tipos de Variáveis 
 
As variáveis e as constantes podem ser basicamente de quatro tipos: Numéricas, 
caracteres, Alfanuméricas ou lógicas. 
 
Numéricas Específicas para armazenamento de números, que posteriormente 
poderão ser utilizados para cálculos. Podem ser ainda classificadas 
como Inteiras ou Reais. As variáveis do tipo inteiro são para 
armazenamento de números inteiros e as Reais são para o 
armazenamento de números que possuam casas decimais. 
 
Caracteres Específicas para armazenamento de conjunto de caracteres que não 
contenham números (literais). Ex: nomes. 
 
Alfanuméricas Específicas para dados que contenham letras e/ou números. Pode 
em determinados momentos conter somente dados numéricos ou 
somente literais. Se usado somente para armazenamento de 
números, não poderá ser utilizada para operações matemáticas. 
 
Lógicas Armazenam somente dados lógicos que podem ser Verdadeiro ou Falso. 
 
4.4 Declaração de Variáveis 
 
As variáveis só podem armazenar valores de um mesmo tipo, de maneira que 
também são classificadas como sendo numéricas, lógicas e literais. 
 
4.5 EXERCÍCIOS 
 
1) O que é uma constante? Dê dois exemplos. 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
 
 
 
 19 
 
 
 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________ 
 
2) O que é uma variável? Dê dois exemplos. 
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________ 
 
3) Faça um teste de mesa no diagrama de bloco abaixo e preencha a tabela ao 
lado com os dados do teste: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 20 
 
 
 
 
4) Sabendo-se que José tem direito a 15% de reajuste de salário, complete o 
diagrama abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 21 
 
 
 
5. Operadores 
 
Os operadores são meios pelo qual incrementamos, decrementamos, comparamos e 
avaliamos dados dentro do computador. Temos três tipos de operadores: 
 
• Operadores Aritméticos 
• Operadores Relacionais 
• Operadores Lógicos 
 
5.1 Operadores Aritméticos 
 
Os operadores aritméticos são os utilizados para obter resultados numéricos. Além 
da adição, subtração, multiplicação e divisão, podem utilizar também o operador 
para exponenciação. Os símbolos para os operadores aritméticos são: 
 
 
 
 
 
 
 
 
Exemplo 
 
 
 
 
 
 
 
 
5.2 Operadores Relacionais 
Os operadores relacionais são utilizados para comparar String de caracteres e 
números. Os valores a serem comparados podem ser caracteres ou variáveis. 
 
Estes operadores sempre retornam valores lógicos (verdadeiro ou falso/ True ou 
False) 
 
1 + 7 * 2 ** 2 –1 = 28 
3 * (1 – 2) + 4 * 2 = 5 
TOTAL = PREÇO * QUANTIDADE 
 
 
 
 22 
 
 
 
Para estabelecer prioridades no que diz respeito a qual operação executar primeiro, 
utilize os parênteses. 
 
Os operadores relacionais são: 
 
 
 
 
 
 
 
 
 
 
 
 
Exemplo: 
Tendo duas variáveis A = 5 e B = 3 
Os resultados das expressões seriam: 
 
 
 
 
 
 
 
 
 
 
 
Símbolo Utilizado para comparação entre expressões 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 23 
 
 
 
 
5.3 Operadores Lógicos 
Hierarquia das Operações Aritméticas1 º ( ) Parênteses 
2 º ** Exponenciação 
3 º * ou / Multiplicação, divisão (o que aparecer primeiro) 
4 º + ou – (o que aparecer primeiro) 
 
5.4 Operadores Relacionais 
Os operadores lógicos servem para combinar resultados de expressões, retornando 
se o resultado final é verdadeiro ou falso. Os operadores lógicos são: 
 
E AND 
OU OR 
NÃO NOT 
 
E / AND Uma expressão AND (E) é verdadeira se todas as condições forem 
Verdadeiras 
 
OR/OU Uma expressão OR (OU) é verdadeira se pelo menos uma condição for 
Verdadeira. 
 
NOT Um expressão NOT (NÃO) inverte o valor da expressão ou condição, se 
verdadeira inverte para falsa e vice-versa. 
 
A tabela abaixo mostra todos os valores possíveis criados pelos três operadores 
lógicos (AND, OR e NOT) 
 
 
 
 
 
 
 24 
 
 
 
Exemplos: 
Suponha que temos três variáveis A = 5, B = 8 e C =1 
Os resultados das expressões seriam: 
 
 
5.4 EXERCÍCIOS 
 
1) Tendo as variáveis SALARIO, IR e SALLIQ, e considerando os valores abaixo. 
Informe se as expressões são verdadeiras ou falsas. 
 
 
 
2) Sabendo que A=3, B=7 e C=4, informe se as expressões abaixo são verdadeiras 
ou falsas. 
 
a) (A+C) > B ( ) 
b) B >= (A + 2) ( ) 
c) C = (B –A) ( ) 
d) (B + A) <= C ( ) 
e) (C+A) > B ( ) 
 
3) Sabendo que A=5, B=4 e C=3 e D=6, informe se as expressões abaixo são 
verdadeiras ou falsas. 
 
a) (A > C) AND (C <= D) ( ) 
b) (A+B) > 10 OR (A+B) = (C+D) ( ) 
c) (A>=C) AND (D >= C) ( ) 
 
 
6 Operações Lógicas 
 
Operações Lógicas são utilizadas quando se torna necessário tomar decisões em 
um diagrama de bloco. 
 
 
 
 
 
 25 
 
 
 
Num diagrama de bloco, toda decisão terá sempre como resposta o resultado 
VERDADEIRO ou FALSO. 
 
Como no exemplo do algoritmo “CHUPAR UMA BALA”. Imaginemos que algumas 
pessoas não gostem de chupar bala de Morango, neste caso teremos que modificar 
o algoritmo para: 
 
“Chupar uma bala”. 
 
· Pegar a bala 
· A bala é de morango? 
· Se sim, não chupe a bala 
· Se não, continue com o algoritmo 
· Retirar o papel 
· Chupar a bala 
· Jogar o papel no lixo 
 
Exemplo: Algoritmo “Chupar Bala” utilizando diagrama de Blocos 
 
 
 
 
 
 
 26 
 
 
 
6.1 EXERCÍCIOS 
 
1) Elabore um diagrama de blocos que leia um número. Se positivo armazene-o em 
A, se for negativo, em B. No final mostrar o resultado. 
 
2) Ler um número e verificar se ele é par ou ímpar. Quando for par armazenar esse 
valor em P e quando for ímpar armazená-lo em I. Exibir P e I no final do 
processamento. 
 
3) Construa um diagrama de blocos para ler uma variável numérica N e imprimi-la 
somente se a mesma for maior que 100, caso contrário imprimi-la com o valor zero. 
 
4)Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um 
algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas: 
 
Para homens: (72.7*h) - 58 
Para mulheres: (62.1*h) - 44.7 (h = altura) 
 
5) Faça um teste de mesa do diagrama apresentado abaixo, de acordo com os 
dados fornecidos: 
 
: 
 
 
 
 
 
 
 27 
 
 
 
Teste o diagrama com os dados abaixo 
 
 
 
Memória 
 
 
 
Dados e saída 
 
 
 
Elabore um algoritmo levando-se em conta o diagrama apresentado: 
 
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________ 
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________
___________________________________________________________________ 
 
7 Estrutura de Decisão e Repetição 
 
Como vimos no capítulo anterior em “Operações Lógicas”, verificamos que na 
maioria das vezes necessitamos tomar decisões no andamento do algoritmo. Essas 
decisões interferem diretamente no andamento do programa. Trabalharemos com 
dois tipos de estrutura. A estrutura de Decisão e a estrutura de Repetição 
 
7.1 Comandos de Decisão 
 
Os comandos de decisão ou desvio fazem parte das técnicas de programação que 
conduzem a estruturas de programas que não são totalmente seqüenciais. Com as 
instruções de SALTO ou DESVIO pode-se fazer com que o programa proceda de 
uma ou outra maneira, de acordo com as decisões lógicas tomadas em função dos 
 
 
 
 28 
 
 
 
dados ou resultados anteriores. As principais estruturas de decisão são: “Se Então”, 
“Se então Senão” e “Caso Selecione” 
 
7.1.1 SE ENTÃO / IF ... THEN 
 
A estrutura de decisão “SE/IF” normalmente vem acompanhada de um comando, 
ou seja, se determinada condição for satisfeita pelo comando SE/IF então execute 
determinado comando. Imagine um algoritmo que determinado aluno somente estará 
aprovado se sua média for maior ou igual a 5.0, veja no exemplo de algoritmo como 
ficaria. 
 
SE MEDIA >= 5.0 ENTÃO ALUNO APROVADO 
 
Em diagrama de blocos ficaria assim: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Em visual basic 
 
IF MEDIA >= 5 Then 
Text1 = “APROVADO” 
ENDIF 
 
7.1.2 SE ENTÃO SENÃO / IF ... THEN ... ELSE 
 
A estrutura de decisão “SE/ENTÃO/SENÃO”, funciona exatamente como a 
estrutura “SE”, com apenas uma diferença, em “SE” somente podemos executar 
comandos caso a condição seja verdadeira, diferente de “SE/SENÃO” pois sempre 
um comando será executado independente da condição, ou seja, caso a condição 
seja “verdadeira” o comando da condição será executado, caso contrário o comando 
da condição “falsa” será executado. Em algoritmo ficaria assim: 
 
SE MÉDIA >= 5.0 ENTÃO 
 ALUNO APROVADO 
SENÃO 
 ALUNO REPROVADO 
 
 
 
 29 
 
 
 
Em diagrama 
 
 
 
Em Visual Basic 
 
IF MEDIA >= 5 Then 
 Text1 = “APROVADO” 
ELSE 
 Text1 = “REPROVADO” 
ENDIF 
 
No exemplo acima está sendo executada uma condição que, se for verdadeira, 
executa o comando “APROVADO”, caso contrário executa o segundo comando 
“REPROVADO”. Podemos também dentro de uma mesma condição testar outras 
condições. Como no exemplo abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 30 
 
 
 
Em Visual Basic 
 
IF MEDIA >= 5 Then 
IF MEDIA >= 7.0 then 
 Text1 = “Aluno APROVADO” 
ELSE 
 Text1 = “Aluno Necessita fazer outra Avaliação” 
ENDIF 
ELSE 
 Text1 = “Aluno REPROVADO” 
ENDIF 
 
7.1.3 CASO SELECIONE / SELECT ... CASE 
 
A estrutura de decisão CASO/SELECIONE é utilizada para testar, na condição, uma 
única expressão, que produz um resultado, ou, então, o valor de uma variável, em 
que está armazenado um determinado conteúdo. Compara-se, então, o resultado 
obtido no teste com os valores fornecidos em cada cláusula “Caso”. No exemplo do 
diagrama de blocos abaixo, é recebido uma variável “Op” e testado seu conteúdo, 
caso uma das condições seja satisfeita, é atribuído para a variável Titulo a String 
“Opção X”, caso contrário é atribuído a string “Opção Errada”. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 31 
 
 
 
Em Visual Basic utilizamos a seguinte seqüência de comandos para representar o 
diagrama anterior. 
 
TITULO = “” 
OP = INPUTBOX(“DIGITE A OPÇÃO”) 
SELECT CASE OP 
 CASE 1 
TITULO = “OPÇÃO 1” 
 CASE 2 
TITULO = “OPÇÃO 2” 
 CASE 3 
TITULO = “OPÇÃO 3” 
 CASE 4 
TITULO = “OPÇÃO 4” 
 CASE 5 
TITULO = “OPÇÃO 5” 
 CASE ELSE 
TITULO = “OPÇÃO ERRADA” 
 END SELECT 
LABEL1.CAPTION = TITULO 
 
7.1.4 EXERCÍCIOS 
 
1) João Papo-de-Pescador, homem de bem, comprou um microcomputador para 
controlar o rendimento diário de seu trabalho. Toda vez que ele traz um peso de 
peixes maior que o estabelecido pelo regulamento de pesca do estado de São Paulo 
(50 quilos) deve pagar um multa de R$ 4,00 por quilo excedente. João precisa que 
você faça um diagrama de blocosque leia a variável P (peso de peixes) e verifique 
se há excesso. Se houver, gravar na variável E (Excesso) e na variável M o valor da 
multa que João deverá pagar. Caso contrário mostrar tais variáveis com o conteúdo 
ZERO. 
 
2) Elabore um diagrama de bloco que leia as variáveis C e N, respectivamente 
código e número de horas trabalhadas de um operário. E calcule o salário sabendo-
se que ele ganha R$ 10,00 por hora. Quando o número de horas exceder a 50 
calcule o excesso de pagamento armazenando-o na variável E, caso contrário zerar 
tal variável. A hora excedente de trabalho vale R$ 20,00. No final do processamento 
imprimir o salário total e o salário excedente. 
 
3) Desenvolva um diagrama que: 
· Leia 4 (quatro) números; 
· Calcule o quadrado de cada um; 
· Se o valor resultante do quadrado do terceiro for >= 1000, imprima-o e finalize; 
· Caso contrário, imprima os valores lidos e seus respectivos quadrados. 
 
4) Faça um diagrama de bloco que leia um número inteiro e mostre uma mensagem 
indicando se este número é par ou ímpar, e se é positivo ou negativo. 
 
 
 
 32 
 
 
 
5) A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3 
grupos de indústrias que são altamente poluentes do meio ambiente. O índice de 
poluição aceitável varia de 0,05 até 0,25. Se o índice sobe para 0,3 as indústrias do 
1º grupo são intimadas a suspenderem suas atividades, se o índice crescer para 0,4 
as industrias do 1º e 2º grupo são intimadas a suspenderem suas atividades, se o 
índice atingir 0,5 todos os grupos devem ser notificados a paralisarem suas 
atividades. Faça um diagrama de bloco que leia o índice de poluição medido e emita 
a notificação adequada aos diferentes grupos de empresas. 
 
6) Elabore um algoritmo que dada a idade de um nadador classifique-o em uma das 
seguintes categorias: 
Infantil A = 5 a 7 anos 
Infantil B = 8 a 11 anos 
Juvenil A = 12 a 13 anos 
Juvenil B = 14 a 17 anos 
Adultos = Maiores de 18 anos 
 
7) Elabore um algoritmo que gera e escreve os números ímpares dos números lidos 
entre 100 e 200. 
 
8) Construa um algoritmo que leia 500 valores inteiros e positivos e: 
· Encontre o maior valor 
· Encontre o menor valor 
· Calcule a média dos números lidos 
 
8.Introdução Linguagem de Programação Java 
8.1 O que é Java? 
Chegou a hora de responder as perguntas mais básicas sobre Java. Ao término 
dessa etapa você será capaz de: 
 
• responder o que é Java; 
• mostrar as vantagens e desvantagens de Java; 
• compilar e executar um programa simples. 
 
Muitos associam Java com uma maneira de deixar suas páginas da web mais 
bonitas, com efeitos especiais, ou para fazer pequenos formulários na web. 
 
O que associa as empresas ao Java? 
Já iremos chegar neste ponto, mas antes vamos ver o motivo pelo qual as empresas 
fogem das outras linguagens: 
 
Quais são os seus maiores problemas quando esta programando? 
• ponteiros? 
• liberar memória? 
• organização? 
 
 
 
 33 
 
 
 
• falta de bibliotecas boas? 
• ter de reescrever parte do código ao mudar de sistema operacional? 
• custo de usar a tecnologia? 
 
Java tenta amenizar esses problemas. Alguns desses objetivos foram atingidos a 
muito tempo atrás, porque, antes do Java 1.0 sair, a idéia e que a linguagem fosse 
usada em pequenos dispositivos, como tvs, aspiradores, liquidificadores e outros. 
Apesar disso a linguagem teve seu lançamento mirando o uso dela nos clientes web 
(browsers) para rodar pequenas aplicações (applets). Hoje em dia esse não é mais o 
foco da linguagem. 
 
O Java e desenvolvido e mantido pela Sun (http://www.sun.com) e seu site principal 
é o http://java.sun.com. (java.com e um site mais institucional, voltado ao consumidor 
de produtos e usuários leigos, não desenvolvedores). 
 
8.2 A história do Java 
A Sun criou um time (conhecido como Green Team) para desenvolver inovações 
tecnológicas em 1992. Esse time foi liderado por James Gosling, considerado o pai 
do Java. O time voltou com a idéia de criar um interpretador (já era uma máquina 
virtual, veremos o que e isso mais a frente) para pequenos dispositivos, facilitando a 
reescrita de software para aparelhos eletrônicos, como vídeo cassete, televisão e 
aparelhos de tv a cabo. 
 
A idéia não deu certo, tentaram fechar diversos contratos com grandes fabricantes 
de eletrônicos, como a Panasonic, mas não houve êxito devido ao conflito de 
interesses. Hoje sabemos que o Java domina o mercado de aplicações para 
celulares, porém parece que em 1994 ainda era muito cedo. 
 
Com o advento da web, a Sun percebeu que poderia utilizar a idéia criada em 1992 
para poder rodar pequenas aplicações dentro do browser. A semelhança era que na 
internet havia uma grande quantidade de sistemas operacionais e browser, e com 
isso seria grande vantagem poder programar numa única linguagem, independente 
da plataforma. Foi aí que o Java 1.0 foi lançado: focado em deixar o browser não 
apenas um cliente burro, fazendo com que ele possa também realizar operações, 
não apenas renderizar html. Sabemos que hoje os applets realmente não são o foco 
da Sun. O mais engraçado é que a tecnologia Java nasceu com um objetivo em 
mente, foi lançado com outro mas no final decolou mesmo no desenvolvimento de 
aplicações do lado do servidor. Sorte? Você pode ler a historia da linguagem Java 
em:http://java.sun.com/java2/whatis/1996/storyofjava.html. 
 
No Brasil, diversos grupos de usuários se juntaram para tentar disseminar o 
conhecimento da linguagem. Um deles e o GUJ (www.guj.com.br), uma comunidade 
virtual com artigos, tutoriais e fórum para tirar dúvidas, o maior em língua 
portuguesa. 
 
 
 
 
 34 
 
 
 
Encorajamos todos os alunos a usar muito os fóruns do mesmo pois é uma das 
melhores maneiras para achar soluções para pequenos problemas que acontecem 
com grande frequência. 
 
8.3 A máquina virtual 
 
Em uma linguagem de programação como C e Pascal, temos o seguinte quadro 
quando vamos compilar um programa. O código fonte e compilado para uma 
plataforma e sistema operacional especificos. Muitas vezes, o próprio código fonte e 
desenvolvido visando uma única plataforma! 
 
 
 
Esse código executável (binário) resultante será executado pelo sistema operacional 
e, por esse motivo, ele deve saber conversar com o sistema operacional em 
questão. 
 
 
Isto é, temos um código executável para cada sistema operacional. É necessário 
compilar uma vez para Windows, outra para o Linux, etc...Como foi dito 
anteriormente, na maioria das vezes, a sua aplicação se utiliza das bibliotecas do 
sistema operacional, como, por exemplo, a de interface gráfica para desenhar as 
'telinhas'. 
 
 
 
 
 35 
 
 
 
A biblioteca de interface gráfica do Windows é bem diferente das do Linux; 
resultado? Você precisa reescrever o mesmo pedaço da aplicação para diferentes 
sistemas operacionais, já que eles não são compatíveis. 
Já o Java utilizasse do conceito de máquina virtual, onde existe uma camada extra 
entre o sistema operacional e a aplicação, responsável por “traduzir” (não é apenas 
isso) o que sua aplicação deseja fazer para as respectivas chamadas do sistema 
operacional no qual ela esta rodando no momento: 
 
 
Dessa forma, a maneira a qual você abre uma janela no Linux ou no Windows e a 
mesma: você ganha independência de sistema operacional. Ou, melhor ainda, 
independência de plataforma em geral: não é preciso se preocupar em qual sistema 
operacional sua aplicação está rodando, nem em que tipo de máquina, 
configurações etc. 
 
Repare que uma máquina virtual é um conceito bem mais amplo que o de um 
interpretador. Como o próprio nome diz, uma máquina virtual é como um computador 
de mentira: ela tem tudo que um computador tem. Em outras palavras, ela e 
responsável por gerenciar memória, gerenciar threads, a pilha de execução, etc. Sua 
aplicação roda sem nenhum envolvimento com o sistema operacional! Sempre 
conversando apenas com a Java Virtual Machine (JVM). Essa característica éinteressante: como tudo passar pela JVM, ela pode tirar métricas, decidir onde e 
melhor alocar a memória, entre outros. Uma JVM isola a aplicação totalmente do 
sistema operacional. Se uma JVM termina abruptamente, só as aplicações que 
estavam rodando nela irão terminar: isso não afetará outras JVMs que estejam 
rodando no mesmo computador, nem afetará o sistema operacional. Essa camada 
de isolamento também é interessante quando pensamos em um servidor que não 
pode se sujeitar a rodar código que possa a vir a interferir na boa execução de 
outras aplicações. 
 
Para tudo isso precisamos de um “bytecode”. Bytecode é o termo dado ao código 
binário gerado pelo compilador Java (pois existem menos de 256 códigos de 
operação dessa linguagem, e cada “opcode” gasta um byte, dando origem ao nome 
bytecode). O compilador Java gera esse bytecode que, diferente das linguagens 
 
 
 
 36 
 
 
 
sem maquina virtual, vai servir para diferentes sistemas operacionais, já que ele vai 
ser “traduzido” pela maquina virtual. 
 
O Hotspot é a tecnologia que a JVM utiliza para detectar pontos quentes da sua 
aplicação: código que e executado muito, provavelmente dentro de um ou mais 
loops. Quando a JVM julgar necessária, ela vai compilar aquele código para 
instruções nativas da plataforma, tendo em vista que isso vai provavelmente 
melhorar a performance da sua aplicação. 
 
Esse compilador é o JIT: Just inTime Compiler, o compilador que aparece “bem na 
hora” que você precisa. Você pode pensar então: porque a JVM não compila tudo 
antes de executar a aplicação?É que teoricamente compilar dinamicamente, a 
medida do necessário, pode gerar uma performance melhor. O motivo e simples: 
imagine um .exe gerado pelo VisualBasic, pelo gcc ou pelo Delphi, ele é estático. Ele 
já foi otimizado baseado em heurísticas, o compilador pode ter tomado uma decisão 
não tão boa. 
 
Já a JVM, por estar compilando dinamicamente durante a execução, pode perceber 
que um determinado código não está com performance adequada, e otimizar mais 
um pouco aquele trecho, ou ainda mudar a estratégia de otimização. E por esse 
motivo que as JVMs mais recentes (como a do Mustang, Java 6), em alguns casos, 
chega a ganhar em muitos casos de códigos C compilados com o GCC 3.x, se 
rodados durante um certo tempo. 
 
8.4 Versões do Java 
 
Java 1.0 e 1.1 são as versões muito antigas do Java. Com o Java 1.2 houve um 
aumento grande no tamanho da API, e foi nesse momento em que trocaram a 
nomenclatura de Java para Java2, com o objetivo de diminuir a confusão entre Java 
e Javascript. Mas lembre-se, não há versão do Java 2.0, o 2 foi incorporado ao 
nome: Java2 1.2. 
 
Depois vieram o Java2 1.3 e 1.4, e o Java 1.5 passou a se chamar Java 5, tanto por 
uma questão de marketing e porque mudanças significativas na linguagem foram 
incluídas. E nesse momento que o “2” do nome Java desaparece. Repare que para 
fins de desenvolvimento, o Java 5 ainda e referido como Java 1.5. Até a versão 1.4 
existia a terceira numeração (1.3.1, 1.4.1, 1.4.2, etc), indicando bug fixes e 
melhorias. A partir do Java 5 existem apenas updates: Java 5 update 7, por 
exemplo. 
 
O Java 6 foi lançado em 2006, mas sem mudanças na especificação da linguagem. 
Existe compatibilidade para trás em todas as versões do Java. Um class gerado pelo 
javac da versão 1.2 precisa necessariamente rodar da JVM 5.0. 
 
8.5 JVM? JRE? JDK? 
O que você vai baixar no site do java? 
 
 
 
 37 
 
 
 
 
JVM = apenas a virtual machine, esse download não existe. 
JRE = Java Runtime Environment, ambiente de execução Java, formado pela JVM e 
bibliotecas, tudo que você precisa para executar uma aplicação Java. 
JDK = Nós, desenvolvedores, faremos o download do JDK do Java SE (Standard 
Edition). 
 
8.6 Objetivos do java 
 
Queremos deixar claro de que a premissa do Java não é a de criar sistemas 
pequenos, onde temos um ou dois desenvolvedores, mais rapidamente que 
linguagens como php, perl, entre outras. 
 
O foco da plataforma e outro: aplicações de médio a grande porte, onde o time de 
desenvolvedores tem várias pessoas e pode sempre vir a mudar e crescer. Não 
tenha dúvidas que criar a primeira versão uma aplicação usando Java, mesmo 
utilizando IDEs e ferramentas poderosas, será mais trabalhoso que usar uma 
linguagem script ou de alta produtividade. Porém, com uma linguagem orientada a 
objetos e madura como o Java, será extremamente mais fácil e rápido fazer 
alterações no sistema, desde que você siga as boas práticas, recomendações e 
design patterns. 
 
Além disso, a quantidade enorme de bibliotecas gratuitas, para realizar os mais 
diversos trabalhos (tais como relatórios, gráficos, sistemas de busca, geração de 
código de barra, manipulação de XML, tocadores de vídeo, manipuladores de texto, 
persistência transparente, impressão, etc) e um ponto fortíssimo para adoção do 
java: você pode criar uma aplicação sofisticada, usando diversos recursos, sem 
precisar comprar um componente especifico, que costuma ser caro de acordo com 
sua especialização. 
 
Cada linguagem tem seu espaço e seu melhor uso. O uso do java é interessante em 
aplicações que virão a crescer, em que a legibilidade do código é importante, onde 
temos muita conectividade e se temos plataformas (ambientes e sistemas 
operacionais) heterogêneos (linux, unix, OSX e windows misturados). 
 
Você pode ver isso pela quantidade enorme de ofertas de emprego procurando 
desenvolvedores Java para trabalhar com sistemas web e aplicações de integração 
no servidor. Apesar disto, a Sun empenha-se em tentar popularizar o uso do Java 
em aplicações desktop, mesmo com o fraco marketshare do Swing/AWT/SWT em 
relação às tecnologias concorrentes (em especial Microsoft .NET). 
 
8.7 Instalando o java 
Antes de instalar, baixe o JDK 5.0 ou superior, do site do Java da Sun, em 
http://java.sun.com . Pegue a versão internacional e cuidado para não baixar o que 
tem mais de 90 megas, que é a primeira opção na página de download: esta versão 
vem com o Netbeans, que e uma ferramenta da Sun, e não nos interessa no 
 
 
 
 38 
 
 
 
momento. Mais para baixo da página existe uma versão menor, algo em torno de 60 
megas, sem essa ferramenta. Esse software disponível na Sun é gratuito, assim 
como as principais bibliotecas Java e ferramentas. 
 
E interessante você também baixar a documentação do JDK 5.0, o link se encontra 
na mesma pagina e possui outros 40 megas. O procedimento de instalação no 
Windows é muito simples: basta você executar o arquivo e seguir os passos. Instale 
no diretório desejado. 
 
Em seguida baixe a versão mais recente do Eclipse. Não precisa instalar é só clicar 
no arquivo executável (www.eclipse.org), esta é um a IDE líder do mercado, e é 
gratuita. 
 
Se você possui duvidas sobre a instalação e configuração geral do ambiente, 
consulte o tutorial no site do guj: http://www.guj.com.br . 
 
8.8 Compilando o primeiro programa em Java 
Vamos para o nosso primeiro código. O programa que imprime uma linha simples: 
minha primeira aplicação Java! 
 
 
 
Resultado da console: 
 
 
 
Atenção: O java é case sensitive: tome cuidado com maiúsculas e minúsculas. 
Após digitar o código acima no Eclipse, grave-o como PrimeiroPrograma.java em 
algum diretório. 
 
O miolo do programa e o que será executado quando chamamos a maquina virtual. 
Por enquanto, todas as linhas anteriores, onde há a declaração de uma classe e a 
de um método, não importa para nós. Mas devemos saber que toda aplicação Java 
começa por um ponto de entrada, e este ponto de entrada é um método main. 
 
 
 
 39 
 
 
 
Ainda não sabemos o que é método. Você aprenderá esses conceitos em outra 
disciplina “programação orientada a objetos”. Até lá, não se preocupe com essas 
declarações. Sempre que um exercício for feito, o código sempre estará nesse 
miolo. No caso do nosso código, a linha do System.out.println faz com que o 
conteúdo entre aspas seja colocado na tela. 
 
8.9 Variáveisprimitivas e controle de fluxo 
Iremos aprender a trabalhar com os seguintes recursos da linguagem Java: 
 
• declarando, atribuindo valores, casting e comparando variáveis; 
• controle de fluxo através de if e else; 
• instruções de laço for e while, controle de fluxo com break e continue. 
 
Dentro de um bloco, podemos declarar variáveis e usá-las. Em Java, toda variável 
tem um tipo que não pode ser mudado uma vez que declarado: 
 
tipoDaVariável nomeDaVariável; 
 
Por exemplo, é possível ter uma idade que vale um número inteiro: 
 
int idade; 
 
Com isso, você declara a variável idade, que passa a existir a partir deste momento. 
Ela e do tipo int, que guarda um numero inteiro. A partir de agora você pode usá-la, 
Primeiro atribuindo valores. 
 
A linha a seguir é a tradução de “idade deve valer agora quinze“. 
idade = 15; 
 
8.10 Comentários em Java 
 
Para fazer um comentário em java, você pode usar o // para comentar ate o final da 
linha, ou então usar o /* */ para comentar o que estiver entre eles. 
 
/* comentário daqui, 
 ate aqui */ 
 
//uma linha de comentário sobre a idade 
int idade; 
 
Além de atribuir, você pode utilizar esse valor. O código a seguir declara novamente 
a variável idade com valor 15 e imprime seu valor na saída padrão através da 
chamada a System.out.println. 
 
 
 
 
 
 
 40 
 
 
 
//declara a idade 
int idade; 
idade = 15; 
 
// imprime a idade 
System.out.println(idade); 
Por fim, podemos utilizar o valor de uma variável para algum outro propósito, como 
alterar ou definir uma segunda variável. O código a seguir cria uma variável 
chamada idadeNoAnoQueVem com valor de idade mais um. 
 
//gera uma idade no ano seguinte 
int idadeNoAnoQueVem; 
idadeNoAnoQueVem = idade + 1; 
 
No momento que você declara uma variável, também é possível inicializá-la 
Por praticidade: int idade = 15. Você pode usar os operadores +, -, * , / para 
operar com números, sendo eles responsáveis pela adição, subtração, divisão e 
multiplicação, respectivamente. Além desses operadores básicos, há o operador % 
(módulo) que é o resto de uma divisão inteira. Veja alguns exemplos: 
 
int quatro = 2 + 2; 
int três = 5 – 2; 
int oito = 4 * 2; 
int dezesseis = 64 / 4; 
int um = 5 % 2; // 5 dividido por 2 dá 2 e tem resto 1; 
// o operador % pega o resto da divisão inteira 
 
9.Testando código em Java 
 
Você deve colocar esses trechos de código dentro do metodo main. Isto é, isso deve 
ficar no miolo do programa. Use bastante System.out.println, dessa forma você pode 
ver algum resultado, caso contrario, ao executar a aplicação, nada aparecerá. Por 
exemplo, para imprimir a idade e a idadeNoAnoQueVem podemos escrever o 
seguinte programa de exemplo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 41 
 
 
 
 
Representar números inteiros é fácil, mas como guardar valores reais, como frações 
de números inteiros e outros? Outro tipo de variável muito utilizado é o double, que 
armazena um numero com ponto flutuante. 
 
double d = 3.14; 
 
O tipo boolean armazena um valor verdadeiro ou falso, e só. 
 
boolean verdade = true; 
 
O tipo char guarda um e apenas um caractere. Esse caractere deve estar entre 
aspas simples. Não se esqueça dessas duas características de uma variável do tipo 
char. 
 
char letra = 'a'; 
System.out.println(letra); 
 
 
10.Tipos primitivos em Java 
 
Esses tipos de variáveis são tipos primitivos do Java: o valor que elas guardam são 
o real conteúdo da variável. Quando você utilizar o operador de atribuição = o valor 
será copiado. 
 
int i = 5; // i recebe uma cópia do valor 5 
int j = i; // j recebe uma cópia do valor de i 
i = i + 1; // i vira 6, j continua 5 
 
Aqui, i fica com o valor de 6. Mas e j? Na segunda linha, j esta valendo 5. Quando i 
passa a valer 6, será que j também fica valendo? Não, pois o valor de um tipo 
primitivo sempre é copiado. Apesar da linha 2 fazer j = i, a partir desse momento 
essas variáveis não tem relação nenhuma: o que acontecer com uma não reflete em 
nada com a outra. 
 
Vimos aqui os tipos primitivos que mais aparecem. O Java tem outros, que são o 
byte, short, long e float. Cada tipo possui características especiais que, para um 
programador avançado, podem fazer muita diferença. 
 
 
 
 
 
 
 
 
 
 
 
 
 42 
 
 
 
 
 
10.1. Exercício de fixação 
 
1) Na empresa onde trabalhamos, há tabelas com o quanto foi gasto em cada mês. 
para fechar o balanço do primeiro trimestre, precisamos somar o gasto total. 
Sabendo que, em Janeiro foi gasto 15000 reais, em Fevereiro, 23000 reais e em 
Março, 17000 reais, faça um programa que calcule e imprima o gasto total no 
trimestre. Siga esses passos: 
 
a) Crie uma classe chamada BalancoTrimestral com um bloco main, como nos 
exemplos anteriores; 
 
b) Dentro do main (o miolo do programa), declare uma variável inteira chamada 
gastosJaneiro e inicialize-a com 15000; 
 
c) Crie também as variáveis gastosFevereiro e gastosMarco, inicializando-as 
com 23000 e 17000, respectivamente, utilize uma linha para cada declaração; 
 
d)Crie uma variável chamada gastosTrimestre e inicialize-a com a soma das outras 3 
variaveis: int gastosTrimestre = gastosJaneiro + gastosFevereiro + gastosMarco 
 
e) Imprima a variavel gastosTrimestre. 
 
2) (opcional) Adicione código (sem alterar as linhas que já existem) no programa a 
seguir para imprimir o resultado: Resultado: 15, 15.1, y, false 
 
3) (opcional) Procure por code conventions no campo de busca do site java.sun.com. 
 
 
 
 
 
 
 
 43 
 
 
 
 
 
11. Casting e Promoção 
 
Alguns valores são incompatíveis se você tentar fazer uma atribuição direta. 
Enquanto um número real costuma ser representado em uma variável do tipo 
double, tentar atribuir ele a uma variável int não funciona pois e um código que 
diz: “i deve valer d”, mas não se sabe se realmente é um número inteiro ou não. 
 
double d = 3.1415; 
int i = d; // não compila 
 
O mesmo ocorre no seguinte trecho: 
int i = 3.14; 
 
O mais interessante, e que nem mesmo o seguinte código compila: 
 
double d = 5; // ok, o double pode conter um número inteiro 
int i = d; // não compila 
 
Apesar de 5 ser um bom valor para um int, o compilador não tem como saber que 
valor estará dentro desse double no momento da execução. Esse valor pode ter sido 
digitado pelo usuário, e ninguém vai garantir que essa conversão ocorra sem perda 
de valores. Já no caso a seguir e o contrário: 
 
int i = 5; 
double d2 = i; 
 
O código acima compila sem problemas, já que um double pode guardar um número 
com ou sem ponto flutuante. Todos os inteiros representados por uma variável do 
tipo int podem ser guardados em uma variável double, então não existem problemas 
no código acima. 
 
Ás vezes, precisamos que um número quebrado seja arredondado e armazenado 
num numero inteiro. Para fazer isso sem que haja o erro de compilação, é preciso 
ordenar que o número quebrado seja moldado (casted) como um número inteiro. 
Esse processo recebe o nome de casting. 
 
double d3 = 3.14; 
int i = (int) d3; 
 
O casting foi feito para moldar a variavel d3 como um int. O valor dela agora e 3. 
O mesmo ocorre entre valores int e long. 
 
long x = 10000; 
int i = x; // nao compila, pois pode estar perdendo informação 
E, se quisermos realmente fazer isso, fazemos o casting: 
 
 
 
 44 
 
 
 
long x = 10000; 
int i = (int) x; 
 
Abaixo estão relacionados todos os casts possíveis na linguagem Java, mostrando 
quando você quer converter de um valor para outro. A indicação Impl. quer dizer que 
aquele cast é implicito e automático, ou seja, você não precisa indicar o cast 
explicitamente. (lembrando que o tipo boolean não pode ser convertido para nenhum 
outro tipo). 
 
 
 
Na tabela abaixo, estão os tamanhos de cada tipo primitivo do Java. 
 
 
 
 
 
 
 45 
 
 
 
 
 
12. Instruções de desvio 
 
Linguagens de alto nível implementam várias estruturas de controle do fluxo do 
programa para facilitar odesenvolvimento de programas e promover um melhor 
estilo de programação. Os comandos de seleção e repetição são mais empíricos do 
que os comandos tradicionais em linguagem de máquina. Java possui duas 
instruções de desvio condicionais mais uma palavra reservada que não deve ser 
usada. Todas elas existem em várias outras linguagens e plataformas. 
13. Comando: if 
 
O comando if executa um trecho de código apenas uma vez, dependendo de sua 
condição. A sintaxe segue a sintaxe abaixo. 
 
if ( <condição> ) { 
 <comandos> 
 } else { 
 <comandos> 
 } 
 
A condição é uma expressão da linguagem java e pode ser qualquer conjunto de 
operações que retornem um valor booleano. 
Ex: (i > = 0) ou (a = = 5 & & b! = 5 | | c = = a) O " comandos 1 " e " comandos 2 " são 
um conjunto de um ou mais comandos da linguagem Java. 
No caso de ser apenas um comando o uso de {} não é necessário. 
 
Se a condição for verdadeira o interpretador executará o " comandos 1 " caso 
contrário o bloco " comandos 2 " será executado. 
Exemplo: 
 
public class ExemploIf { 
 public static void main(String[ ] args) { 
 int i = 8; 
 // If que dirá se o valor do i é igual a 1 ou igual a dois. 
 
 
 
 46 
 
 
 
 if (i \% 2) 
 System.out.println("Oito é divisível por dois"); 
 else 
 System.out.println("Oito não é divisível por dois"); 
 // Verifica se o nome é Vitor. 
 String nome = "Vitor"; 
 if (nome.equals("Vitor")) { 
 System.out.println("Nome é Vitor"); 
 } else { 
 System.out.println("Nome não é Vitor"); 
 } 
 } 
} 
No primeiro if do exemplo é testado se o valor de i é divisível por 2, ou seja, se 
valor de i é par. Se for divisível, é impresso o texto Oito é divisível por dois, caso 
contrário é impresso o texto Oito não é divisível por dois na linha de comando. 
 
No segundo exemplo é feito um teste para saber se a variável String nome é 
igual a Vitor. Em comparação de objetos sempre usa-se o método equals. Se o 
valor de nome for Vitor é impresso Nome é Vitor, caso contrário é impresso 
Nome não é Vitor. 
14. Comando: switch 
 
O comando switch é o mesmo do C e é semelhante ao case do Delphi. Permite 
selecionar o bloco de código a ser executado baseado no teste lógico de uma 
expressão. 
 O switch é a forma evoluída para o if, podendo tratar mais de dois blocos de 
execução. 
 
Sintaxe: 
 
switch ( <expressão> ) { 
 
 
 
 47 
 
 
 
 case <valor1>:<comandos 1> 
 [break;] 
 case <valor2>:<comandos 2> 
 [break;] 
 case <valor3>:<comandos 3> 
 [break;] 
 case <valor4>:<comandos 4> 
 [break;] 
 ... 
 default: <comandos default> 
} 
O comando switch executa a expressão e compara o valor encontrado com os 
valores: , , , etc. Quando encontra a igualdade ele executa o bloco de comandos 
daquele valor. A execução continuará até o final do switch ou até que ele 
encontre um break;. Exemplos: 
public class ExemploSwitch { 
 public static void main(String[] args) { 
 int i = 2; 
 // Switch que irá imprimir na tela o valor 2 
 switch (i) { 
 case 1 : System.out.println("Valor de i é 1"); 
 break; 
 case 2 : System.out.println("Valor de i é 2"); 
 break; 
 case 3 : System.out.println("Valor de i é 3"); 
 break; 
 
 
 
 48 
 
 
 
 default: System.out.println("Default"); 
 } 
 // Switch que irá imprimir na tela o valor "Vitor" 
 String nome = "Vitor"; 
 switch (nome.hashcode()) { 
 case "Vitor".hashCode() : System.out.println("Valor de nome é Vitor"); 
 break; 
 case "Paulo".hashCode() : System.out.println("Valor de nome é Paulo"); 
 break; 
 default: System.out.println("Default"); 
 } 
 } 
} 
Não é necessário utilizar as chaves ({}) para delimitar um bloco de comandos, 
pois o interpretador executará todos eles até encontrar um break ou o switch 
finalizar. 
 
A única limitação do switch é que a deve retornar um valor numérico inteiro, 
qualquer um de seus quatro tipos primitivos. O switch não funciona com String, 
float, char e boolean por exemplo. E é por este motivo que no segundo switch do 
exemplo é utilizado o método hashcode (), que retorna um código inteiro único 
para cada String diferente. 
 
15. Comando: goto 
Há um consenso entre os desenvolvedores de software de que instruções goto 
devem ser usadas somente para criar estruturas de controle, de seleção ou 
repetição, caso elas não existam na linguagem trabalhada. E é exatamente por 
isso que, embora a palavra goto seja uma palavra reservada do Java, ela não 
pode ser utilizada, o compilador Java acusará erro se encontrá-la no código. 
 
Os especialistas afirmam que o goto polui o código fonte e se não for utilizado 
adequadamente pode se tornar um problema maior do que o próprio software. 
 
 
 
 49 
 
 
 
 
17. Laços de repetição 
Laços controlam uma repetição de execução de acordo com uma condição 
imposta. Em Java, assim como tantas outras linguagens, existem três tipos de 
laço: for, while e do.. while. 
Comando: for 
 
O comando for cria um laço de repetição no fluxo do programa baseado em três 
parâmetros: 
• expressão inicial: Onde é executado apenas uma vez, na entrada do laço. 
• condição: É executado a cada iteração do laço e determina quando o 
programa deve sair do mesmo. Caso a condição seja verdadeira, repete-se os 
do laço uma vez, caso seja falsa, o programa pula para a próxima instrução 
seguinte ao laço. 
• incremento: É uma operação normal, executada a cada iteração. Geralmente 
é usada para incrementar contadores ou configurar variáveis. 
Sintaxe: 
 
for (<expressão inicial>; <condição>; <incremento>) { 
 <comandos> 
} 
Exemplos: 
 
public class ExemploFor { 
 public static void main(String[] args) { 
 for (int i=0; i<10; i++) { 
 System.out.println("Contador é " + i); 
 } 
 for (;;) { 
 System.out.println("Laço infinito."); 
 } 
 } } 
 
 
 
 50 
 
 
 
O primeiro for do exemplo acima irá apresentar 10 mensagens indicando o 
contador de 0 até 9. Quando o valor do inteiro i ser igual a 10 o interpretador java 
alternará o fluxo para o início do outro for. No segundo for do exemplo o código 
entra num laço infinito, ou seja o programa não termina, sequer sairá do laço, já 
que não existe condição para que tal evento ocorra. 
 
Comando: while 
 
O comando while é utilizada quando não se quer que o corpo do laço seja 
necessariamente executado. A expressão de comparação é avaliada antes que o 
laço seja executado, enquanto ela for verdadeira os são repetidos. 
 
Sintaxe: 
 
while (<condição>) { 
 <comandos> 
} 
Exemplos: 
 
public class ExemploWhile { 
 public static void main(String[] args) { 
 int i=0; 
 while(i++<10) { 
 System.out.println("Contador é " + i); 
 } 
 while(true) { 
 System.out.println("Laço infinito."); 
 } 
 } 
} 
Assim como nos exemplos com o comando for, o primeiro exemplo imprime 
contadores de 0 até 9 e o segundo é um laço infinito, pois o resultado da 
condição sempre será verdadeiro. 
 
 
 
 51 
 
 
 
Comando: do.. while 
O comando do.. while é utilizada quando se quer que o corpo do laço seja 
executado pelo menos uma vez. A expressão de comparação é avaliada depois 
que o laço foi executado, enquanto ela for verdadeira os são repetidos. 
 
Sintaxe: 
 
do { 
 <comandos> 
} while (<condição>); 
Exemplos: 
 
public class ExemploDoWhile { 
 public static void main(String[] args) { 
 int i=0; 
 do { 
 System.out.println("Contador é " + i); 
 } while(++i<10) 
 do { 
 System.out.println("Laço infinito."); 
 } while(true); 
 }} 
 
Assim como nos exemplos anteriores, o primeiro exemplo do comando do.. while 
imprime contadores de 0 até 9 e o segundo é um laço infinito, pois o resultado da 
condição sempre será verdadeiro. Embora a diferença entre os dois comandos while 
sejam mínimas, cada uma é utilizada em uma determinada ocasião. 
 
Comandos: break e continue 
 
É a declaração de desvio usada para sair de um laço antes do normal. O tipo 
 
 
 
 52 
 
 
 
determina para onde é transferido o controle. O break é transfere o controle para o 
final de uma construção de laço (for, do, while ou switch). O laço vai encerrar 
independentemente de seu valor de comparação e a declaração após o laço será 
executada. 
 
Exemplo: 
int i = 0; 
while (true) { 
System.out.println(i); 
if ( i++ >= 10 ) 
break; 
} 
Este exemplo imprime os valores da variável i de 0 até 9. 
 
A declaração continue faz com que a execução do programa volte imediatamente 
para o início do laço, porém para a próxima interação. O continue faz o interpretador 
pular para a próxima iteração e obriga-o a testar a condição. Exemplo: 
 
for (int i = -10; i<10; i++) { 
 if ( i == 0 ) 
 continue; 
 System.out.println(i); 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 53 
 
 
 
18. Vetores e matrizes em Java 
 
Semelhante às liguagens C, C++ e Pascal, a linguagem Java também dá suporte a 
vetores e matrizes (arrays) de diversas formas. Os vetores constituem uma forma 
muito conveniente de organizar informações em fileira. Por exemplo, podemos 
formar um vetor com as notas de cinco alunos de uma sala de aula do seguinte 
modo: 
 
float nota[ ] = { 7.8, 8.4, 4.2, 1.8, 6.4 }; 
 
Neste caso nota[0] é a nota do primeiro aluno, isto é, 7.8, nota[1] é a nota do 
segundo, ou seja, 8.4, e assim por diante. 
 
A utilização de vetores e matrizes em Java envolve três etapas: 
 
1-Declarar o vetor ou matriz. Para isto, basta acrescentar um par de colchetes antes 
ou depois do nome da variável. Por exemplo: 
 
int ind[ ]; 
double A[ ][ ],T[ ] [ ] [ ]; 
int [ ]nota; 
 
2- Reservar espaço de memória e definir o tamanho. É preciso definir o tamanho do 
vetor, isto é, a quantidade total de elementos que terá de armazenar. Em seguida é 
necessário reservar espaço de memória para armazenar os elementos. Isto é feito 
de maneira simples pelo operador new: 
 
ind = new int[10]; 
nota = new int[70]; 
A = new double[10][20]; 
 
3- Armazenar elementos no vetor ou matriz. Para armazenar uma informação em um 
dos elementos de um vetor ou matriz, é necessário fornecer um índice que indique a 
posição desse elemento. Por exemplo, para armazenar um valor na quarta posição 
do vetor nota, fazemos o seguinte: 
 
nota[3] = 5.2; 
 
Como podemos observar, os índices começam em zero e vão até o número de 
posições reservadas, menos um. No vetor nota criado acima, os índices válidos vão 
de 0 até 69. Caso haja a tentativa de atribuir um valor a um elemento cujo índice 
esteja fora desse intervalo, ocorrerá um erro que impedirá a execução do programa. 
Por isso, é necessário um certo cuidado ao manejar com esses índices, garantindo o 
perfeito funcionamento do programa. 
 
Existe, porém, um atalho para esses três passos quando desejamos criar um vetor 
com valores atribuídos de modo estático. Foi o que fizemos no primeiro exemplo 
 
 
 
 54 
 
 
 
acima, declarando o vetor nota com as notas de cinco alunos. Nesse caso, espaço 
suficiente para as notas de cinco alunos foi reservado e as notas foram guardadas 
em respectivas posições do vetor. 
 
Entretanto, nem sempre é tão fácil assim. Em geral, estaremos interessados em 
trabalhar com vetores muito muito maiores, e cujos elementos sejam provenientes 
de outras fontes, que variam com o tempo. Assim, seremos obrigados a seguir os 
passos acima. 
 
exemplos de vetores e matrizes: 
 
// 12 primeiros termos da seqüência de Fibonacci: 
long Fibonacci[] = {1,1,2,3,5,8,13,34,55,89,144}; 
 
// Tabela de sen(n*pi/6), n=0,1,2,...5 
float seno[] = {0.0000,0.5000,0.8660,1.0000,0.8660,0.5000}; 
 
// Tabela de log(1+n), n=0,2...99: 
double tlog[] = new double[100]; 
for(int n=0; n<100; n++) tlog[i] = Math.log(1+n); 
 
// Matriz dos coeficientes 
double A[][] = { {1,2,3}, {0,1,3}, {0,0,-1} }; 
 
19. Estruturando o código: procedimentos e funções 
 
Um aspecto muito comum nos programas é que frequentemente escrevemos 
trechos de código (várias instruções) que se repetem ao longo da lógica que 
estabelecemos. 
 
Por exemplo, se quisermos calcular a média aritmética das provas de um aluno, 
temos que somar a nota da primeira prova com a nota da segunda prova e dividir por 
2. Se tivermos mais de um aluno, temos que repetir esse cálculo para cada aluno. 
Logicamente, a forma mais simples de fazer isso é fazendo o famoso "copy and 
paste": para cada aluno, colocamos a regra para fazer o cálculo e impressão da 
média das notas. 
 
Com o "copy and paste" conseguimos resolver o problema da repetição, mas será 
que foi a melhor escolha? E se tivermos 100 alunos? E se após termos escrito o 
programa todo, alguém nos disser que eram 3 provas? Em ambos os casos teremos 
um bom trabalho para ajustar o código do programa. 
 
Diante disso, podemos afirmar que a repetição de trechos de código dentro de um 
programa é considerada uma prática muito ruim. Mas será que é possível fazer 
diferente? A resposta é a criação de procedimentos e funções. 
 
As instruções que precisam ser repetidas em vários locais do código devem ser 
 
 
 
 55 
 
 
 
isoladas em um bloco de código do programa que recebe um nome (cada linguagem 
estabelece a forma para delimitar esse bloco). Quando precisarmos executar 
aquelas instruções repetidas vezes, basta invocar o nome do bloco de código que as 
contém. A esse bloco de código é que chamamos de procedimentos ou funções 
(diferenciaremos os dois termos mais adiante). 
 
Um programa pode ser constituído de vários procedimentos e funções e um bloco de 
código principal, chamado geralmente de programa principal ou bloco principal. 
 
Ao isolarmos a regra que será repetida, escrevemos-a uma única vez dentro do 
procedimento ou função. E podemos chamá-la quantas vezes for necessário, tanto 
dentro do programa principal, quanto dentro de outros procedimentos e funções. Se 
errarmos na regra, ou se ela mudar com o tempo, basta fazer o ajuste no único local 
do código onde ela existe: dentro do procedimento ou função. 
 
Veja o exemplo a seguir para visualizar como seria um procedimento em algoritmo 
estruturado. 
 
 
Passagem de parâmetros 
 
Um procedimento ou função pode receber parâmetros que carregam os dados que 
devem ser manipulados pelas suas instruções internas. Um parâmetro é uma 
variável definida no corpo do procedimento ou função que recebe um valor apenas 
quando o bloco é chamado.Para tornar o exemplo da figura anterior mais 
interessante, podemos declarar variáveis no corpo do programa principal e passar o 
valor dessas variáveis para dentro do procedimento por meio de parâmetros. Veja a 
figura a seguir. 
 
 
 
 
 
 
 
 
 
 
 
 
 56 
 
 
 
 
Repare que agora, o procedimento define 2 parâmetros: n1 e n2. Tais parâmetros 
recebem valores quando são chamados no programa principal. As variáveis nota1 e 
nota2 são usadas nas duas primeiras chamadas ao procedimento: o valor de nota1 
é copiado para n1 e o valor de nota2 é copiado para n2. A regra programada dentro 
do procedimento é então executada com base nos valores dos parâmetros n1 e n2. 
A terceira chamada ao procedimento ilustra que também podemos passar valores 
para os parâmetros diretamente. 
 
Procedimentos x funções 
 
A diferença entre procedimentos e funções é unicamente no retorno do bloco de 
código: funções retornam valores após a execução da sua lista de instruções, 
procedimentos não.Para facilitar o entendimento, vamos ver o exemplo a seguir. 
 
 
Agora criamos uma função que calcula a média das notas com base nos parâmetrosrecebidos, e devolve o valor da média ao invés de fazer a impressão. A função deve 
ser definida usando o tipo de retorno que ela irá fornecer (no caso do exemplo, valor 
de tipo real) além dos parâmetros que são opcionais. Dentro do bloco da função, 
devemos usar uma instrução que indique o valor que será retornado (nas linguagens 
geralmente a palavra é return para retornar um valor). No algoritmo, a representação 
usada é de que o nome da função recebe um valor... isso quer dizer que quando 
chamarmos essa função podemos atribuí-la a uma variável de tipo real, pois ela irá 
conter um valor de resposta. 
 
Linguagens orientadas a objetos 
 
Nas linguagens que seguem o paradigma da orientação a objetos, não há 
diferenciação entre procedimentos e funções. Todos os blocos de código são 
 
 
 
 57 
 
 
 
chamados de métodos, inclusive o programa principal, que é o método principal 
(geralmente nomeado com a palavra main). 
 
Conclusões 
 
o pré-requisito fundamental para uma pessoa ingressar no desenvolvimento com 
uma linguagem de programação orientada a objetos, como é o caso de Java, é ter 
todos os conceitos sobre programação muito bem fundamentados. 
 
É necessário entender perfeitamente como funcionam os programas: código-fonte, 
linguagem de programação, compilação e execução. É preciso saber usar os vários 
tipos de instruções que um programa pode conter, incluindo principalmente 
instruções de uso de variáveis, condições e laços. E para organizar e facilitar a 
escrita de código, é preciso entender como funcionam os procedimentos, funções, 
passagens de parâmetros e retornos de função. Obviamente que isso não é tudo, 
mas para quem pensa em começar a estudar Java, por exemplo, é necessário 
começar por essa parte mais básica de lógica de programação. 
 
20. Algoritmos de ordenação 
 
Algoritmo de ordenação em ciência da computação é um algoritmo que coloca os 
elementos de uma dada sequência em uma certa ordem -- em outras palavras, 
efetua sua ordenação completa ou parcial. As ordens mais usadas são a numérica e 
a lexicográfica. 
Existem várias razões para se ordenar uma sequência. Uma delas é a possibilidade 
se acessar seus dados de modo mais eficiente. 
 ➔ Ordenar crescentemente (decrescentemente) significa alterar a ordem pela 
qual surgem os elementos de uma sequência, tal que o primeiro seja menor (maior) 
do que o segundo, o segundo menor (maior) do que o terceiro, e assim 
sucessivamente. 
➔ A utilidade destes algoritmos está na resolução de problemas como: 
✔ pesquisa (lista telefónica); 
✔ agrupar elementos repetidos: 
(7, 1, 2, 7, 2, 5) → (1, 2, 2, 5, 7, 7) ou (7, 7, 5, 2, 2, 1). 
➔ Dado um vector V de N inteiros (caso mais simples), pretende-se 
construir um algoritmo que, após a sua execução, deixe o vector V 
ordenado por ordem crescente: V[0] ≤ V[1] ≤ V[2] ≤ ... ≤ V[N-1]. 
 
 
 
 58 
 
 
 
Ordenação por seleção 
➔ 1ª posição (V[0]) o menor elemento, 
➔ 2ª posição (V[1]) o 2º menor elemento, 
➔ ... 
➔ k-ésima posição (V[k-1]) o k-ésimo menor elemento, 
➔ ... 
➔ N-ésima (última) posição (V[N-1]) o maior elemento. 
Ordenação por seleção (Algoritmo – versão 1) 
➔ Para a 1ª posição (V[0]) 
✔ Det. a posição do menor elemento (pos_menor) de V[0] a V[N-1] 
✔ Trocar o elemento da pos_menor com o elemento da 1ª posição 
➔ Para a 2ª posição (V[1]) 
✔ Det. a posição do menor elemento (pos_menor) de V[1] a V[N-1] 
✔ Trocar o elemento da pos_menor com o elemento da 2ª posição 
➔ . . . 
➔ Para a k-ésima posição (V[k]) 
✔ Det. a posição do menor elemento (pos_menor) de V[k] a V[N-1] 
✔ Trocar o elemento da pos_menor com o elemento da k-ésima posição 
Ordenação por seleção (Algoritmo – versão 1) 
➔ Para a (N-1)-ésima posição (V[N-2]) 
✔ Det. a posição do menor elemento (pos_menor) de V[N-2] a V[N-1] 
✔ Trocar o elemento da pos_menor com o elemento da (N-1)-ésima 
posição 
 
 
 
 59 
 
 
 
➔ Para a N-ésima posição (V[N-1]) 
✔ Det. a posição do menor elemento (pos_menor) de V[N-1] a V[N-1]. 
Como só falta um elemento para ordenar, V[N-1], este encontra-se 
automaticamente ordenado (é o maior elemento de todos). 
Ordenação por selecção (Algoritmo – versão 2) 
Para k desde 0 até N-2 fazer: 
pos_menor ← k 
Para kk desde k+1 até N-1 fazer: 
Se (V[kk] < V[pos_menor]) então 
pos_menor ← kk 
Trocar V[pos_menor] com V[k], se necessário, da seguinte forma: 
aux ← V[pos_menor] 
V[pos_menor] ← V[k] 
V[k] ← aux 
Ordenação por borbulagem (“bubble sort”) 
➔ Consiste em comparar 2 elementos consecutivos e, se estiverem 
desordenados, trocá-los entre si. 
➔ Desta forma, os maiores elementos tendem a deslocar-se para a 
direita e os menores para a esquerda do vector. 
➔ O vector fica ordenado quando após várias passagem pelo vector 
com pelo menos uma troca, não há qualquer troca na actual 
passagem. 
Ordenação por borbulagem (Exemplo) 
 
 
 
 60 
 
 
 
➔ (7, 5, 2, 6) 
➔ Primeira passagem: 
✔ Troca do 1º elemento com o 2º (7 ↔ 5) V = (5, 7, 2, 6) 
✔ Troca do 2º elemento com o 3º (7 ↔ 2) V = (5, 2, 7, 6) 
✔ Troca do 3º elemento com o 4º (7 ↔ 6) V = (5, 2, 6, 7) 
➔ Segunda passagem: 
✔ Troca do 1º elemento com o 2º (5 ↔ 2) V = (2, 5, 6, 7) 
➔ Terceira passagem: 
✔ Sem qualquer troca ⇒ V = (2, 5, 6, 7) está ordenado. 
Ordenação por borbulagem (Algoritmo) 
Fazer: 
Num_trocas ← 0; 
Para k desde 0 até N-2 fazer: { k = N-2 ⇒ k+1 = N-1 } 
Se (V[k] > V[k+1]) então 
Trocar V[k] com V[k+1] 
Num_trocas ← Num_trocas + 1 
Enquanto (Num_trocas ≠ 0) 
A seguir um exemplo de um algoritmo de ordenação: 
public class Ordenacao 
{ 
 
 public static void bublesort(int[] v) 
 { 
 int i,ultimatroca,lsup,aux; 
 lsup=v.length-1; 
 do 
 { 
 ultimatroca=0; 
 
 
 
 61 
 
 
 
 for(i=0;i<lsup-1;i++) 
 { 
 if(v[i]>v[i+1]) 
 { 
 aux=v[i]; 
 v[i]=v[i+1]; 
 v[i+1]=aux; 
 ultimatroca=i; 
 } 
 
 } 
 lsup=ultimatroca; 
 } 
 while(lsup>0); 
 } 
 public static void quicksort(int[] v) 
 { 
 ordena(0,v.length-1,v); 
 } 
 public static void ordena (int e,int d, int[] v) 
 { 
 int i,j,aux,x; 
 x=v[(e+d)/2]; 
 i=e; 
 j=d; 
 do 
 { 
 while(v[i]<x)i++; 
 while(v[j]>x)j--; 
 if(i<=j) 
 { 
 aux=v[i]; 
 v[i]=v[j]; 
 v[j]=aux; 
 i++; 
 j--; 
 } 
 } 
 while(i<=j); 
 if(e<j) 
 ordena(e,j,v); 
 if(d>i) 
 ordena(i,d,v); 
 } 
 public static void selecao(int[] v) 
 { 
 int i,k,posmenor,aux; 
 for(i=0;i<v.length-1;i++) 
 
 
 
 62 
 
 
 
 { 
 posmenor=i; 
 for(k=i+1;k<v.length;k++) 
 if (v[k]<v[posmenor]) 
 posmenor=k; 
 aux=v[i]; 
 v[i]=v[posmenor]; 
 v[posmenor]=aux; 
 } 
 } 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 63 
 
 
 
REFERÊNCIAS BIBLIOGRÁFICAS 
 
[1] Paulo Sergio Moraes. “lógica de Programação”. Unicamp - Centro de 
Computação – DSC. 2000.SP SP 
 
[2] Kathy Sierra & Bert Bates .”Use a Cabeça!: Java” 
Autor:.Editora: ALTA BOOKS. 2007 - Edição 2