APROG – Algoritmia e Programação

Emanuel Cunha Silva

[email protected]
 Apresentação

• É uma linguagem de programação

• O Java foi projetado para permitir o desenvolvimento de aplicações

portáveis de alto desempenho para a mais ampla variedade possível de
plataformas de computação

• Lançada em 1995 por Sun Microsystems

• É uma linguagem orientada a objetos

• Objetos “são designados” por Classes

• Todas as instruções que podem ser executadas têm de estar dentro de

uma Classe

APROG - Java 2
 Apresentação

APROG - Java 3
 Apresentação
Desenvolver programas em Java

• Instalar o JDK (JDK JavaSE)

• Download
https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

• Java API (Classes já programadas do Java que podemos usar)

https://docs.oracle.com/javase/8/docs/api/

• Ferramentas
• javac compilador de código
• java interpretador de código

• Instalar um IDE (Integrated Developed Environment)

• Intellij IDEA (https://www.jetbrains.com/edu-products/download/)

• Netbeans (https://netbeans.org/downloads/)

APROG - Java 4
 Apresentação

Fases de desenvolvimento de um programa

Edição Editor de texto

(IDE)
escrever o programa fonte

javac <programa>
Compilação (IDE)

criar o programa executável

java <executavel>
Execução (IDE)

executar o programa

APROG - Java 5
 Apresentação

Ex: Criar um programa em Java com o nome “Ola”

• Criar o ficheiro fonte “Ola.java”

• Primeira letra maiúscula
• Extensão “.java”

• Compilar o ficheiro fonte e criar o ficheiro executável

• “javac Ola.java”
• É criado o ficheiro executável “Ola.class”

• Executar o ficheiro executável

• “java Ola”

APROG - Java 6
 Apresentação

APROG - Java 7
 Java - Terminologia
• Classe
Definição de um tipo de dados que especifica os atributos (ou propriedades) e
os comportamentos (ou métodos) disponíveis para os objetos dessa classe.
• Ex: projeto de uma casa, onde são definidos atributos como as cores, materiais, etc.
• Objeto
Instância de uma classe
• Ex: construir uma casa referente a um projeto, dando significado às propriedades
desse projeto (cores, materiais)
• Instanciar um objeto
Criar e inicializar um objeto referente a um tipo de classe
• Pode-se criar vários objetos distintos com base na mesma classe, usando diferentes
valores para as propriedades
• Ex: construir várias casas com base no mesmo projeto, aplicando diferentes
cores e materiais

APROG - Java 8
 Java
• Composto por uma ou mais classes
• Uma classe possui:
• dados (atributos)
• métodos (funções) – módulos de código que contêm instruções para
realizar uma tarefa e quando terminam voltam ou local onde foram
invocados, podendo retornar um valor.
• Uma aplicação executável em java tem de possuir numa das suas
classes o método main que é o local por onde é iniciada a
execução
public class Ola {
public static void main (String[] args) {
…
}
…
}
APROG - Java 9
 Java
package nome; NomePrograma é nome da classe
principal com inicial maiúscula
import nomeCompletoClasse;
public class NomePrograma {
public static void main(String[] args) {
…
} cabeçalho do método main é imutável
}

• Java distingue letras maiúsculas das minúsculas

• Declaração package
• Especifica nome da package a que pertencerá nova classe
• Packages permitem organizar classes
• Semelhante às pastas dos sistemas de ficheiros que facilitam a gestão de
ficheiros
• Concretamente, são pastas dos sistemas de ficheiros

APROG - Java 10
 Java
package nome;
import nomeCompletoClasse;
public class NomePrograma {
public static void main(String[] args) {
…
}
}

• Declaração import
• Permite à nova classe usar classes pertencentes a outras packages
• Nome completo de uma classe
• nome da package seguido do nome da classe
• Exemplo: import java.util.Scanner; // java.util é package da classe Scanner
• Modificador de acesso public
• Especifica se classe/método pode ou não ser usada por outras classes
• Classes/métodos públicos podem ser usados por outras classes

APROG - Java 11
 Java
package nome;
…
public class NomePrograma {
public static void main(String[] args) {
…
}
}

• NOTA:
Nesta fase inicial, e para manter os programas o mais simples
possível, os mesmos não devem estar associados a qualquer
package. Por isso, a referência a “package” não deve existir.

APROG - Java 12
 Java
• Os programas incluem normalmente três tipos componentes
• Declarações – reservar memória para o armazenamento das estruturas
de dados

• Instruções – indicar ao computador o que deve efetuar

• As instruções são separadas por ponto e vírgula ( ; )

• Comentários – registar anotações sobre o significado do código ou das

estruturas de dados. Permitem também auxiliar na documentação do
programa. São ignorados pelo computador
• // - ignora até ao fim da linha em que se encontra
• /* … */ - ignora tudo o que está no interior
• /** … */ - ignora tudo o que está no interior. Usado para criar
documentação automaticamente

APROG - Java 13
 Java - Estruturas de dados

• Categorias
• Variáveis - Valor pode variar durante a execução do programa
• Constantes - Valor é constante durante a execução do programa

• Identificadores
• Palavras usadas para identificar variáveis, constantes, classes, métodos,
etc.
• Pode conter letras, dígitos e os caracteres “_” e “$”
• Não podem começar por um dígito
• Java é case sensitive – maiúsculas e minúsculas são diferentes
• pessoa ≠ Pessoa ≠ PESSOA

APROG - Java 14
 Java - Identificadores
Os identificadores, em Java, normalmente, seguem a seguinte convenção

• Variáveis e métodos
• Iniciam por letra minúscula
• Podem ter várias palavras agregadas sem espaços e capitalizadas
• Ex: nomeAluno, alturaDoAtleta, numeroDoAtletaDeRemo
• Constantes
• Apenas maiúsculas
• Ex: MAXIMO, TAXA_IVA
• Classes
• Iniciam por letra maiúscula
• Podem ter várias palavras agregadas sem espaços e capitalizadas
• Ex: Aluno, CarroDeF1

APROG - Java 15
 Java - Identificadores
Palavras reservadas pelo java que não podem ser usadas como identificadores

abstract continue for new switch

assert*** default goto* package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum**** instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp** volatile
const* float native super while

* not used
** added in 1.2
*** added in 1.4
**** added in 5.0

APROG - Java 16
 Java - Estruturas de dados
Tipos de dados primitivos

▪ Categorias
▪ Inteiros: byte 1 byte (-128, 127)
short 2 bytes (-32 768, 32 767)
int 4 bytes (-2 147 483 648, 2 147 483 647)
long 8 bytes (-9x1018, 9x1018)
▪ Reais: float 4 bytes (-/+ 3.4 x 1038)
double 8 bytes (-/+ 1.7 x 10308 )
▪ Outros: char
boolean

▪ Exemplos
char c = 'R', opcao= 'a'; // carateres são delimitados por plicas
boolean flag = false; // valores lógicos: false e true
double nota = 18.5; // separador decimal é o . (ponto)
float altura = 1.83f; // os valores float devem ser seguidos pela letra f
APROG - Java 17
 Java - Estruturas de dados
Tipos de dados não primitivos (referências)

▪ Definidos por Classes

▪ Exemplos
String // guarda texto
Scanner // leitura de dados (ex: teclado)
Formatter // escrita formatada (ex: ecrã)

▪ Variável de Tipo Referência

▪ Exemplos
String cidade;
String nome = "Nico";
String ave = "águia";

APROG - Java 18
 Java - Estruturas de dados
Declaração de variáveis
▪ Sintaxe // para N variáveis do mesmo tipo
Tipo_de_Dado identificador_1[=valor inicial] [ , …, identificador_N[=valor inicial] ] ; [...] = opcional

▪ Exemplos
int numero; // guarda inteiros; por omissão, variáveis numéricas são inicializadas a 0
int preco=5; // variável declarada e inicializada; = é operador de atribuição
int x=5, y, z=1; // múltiplas variáveis, do mesmo tipo, declaradas na mesma linha

▪ Local
▪ Em qualquer parte do corpo do método
public class NomePrograma {
public static void main(String[] args){
int numero;
...
int preco = 5;
...
int x = 5, y, z = 1;
}
}

APROG - Java 19
 Java - Estruturas de dados
Declaração de constantes
▪ Sintaxe // para N constantes do mesmo tipo
final Tipo_de_Dado identificador_1=valor1] [ , …, identificador_N=valorN] ; [...] = opcional

▪ Exemplos
final int NUMERO=10; // por convensão, nomes em maiúsculas
final int X=5, PRECO=5; // múltiplas constantes, do mesmo tipo, declaradas na mesma linha

▪ Local
▪ Em qualquer parte do corpo do método

public class NomePrograma {

public static void main(String[] args){
final int NUMERO=10;
...
final int X=5, PRECO = 5;
...
}
}

APROG - Java 20
 Java - Operadores
▪ Aritméticos
+ // Soma
- // Subtracção
* // Produto
/ // Divisão real ou inteira; Divisão inteira se ambos os operandos forem inteiros.
% // Resto da divisão inteira
▪ Relacionais
> // Maior
>= // Maior ou igual
< // Menor
<= // Menor ou igual
!= // Diferente
== // Igual
▪ Atribuição
= // Ex: x = 5;
+= // Ex: x += 5 ou x = x + 5;
-=
*=
/=

APROG - Java 21
 Java - Operadores
▪ Lógicos
&& // AND
|| // OR
! // NOT ; Ex: !(x<0 && y>10)

▪ Outros
++ // Incrementa variável de 1 unidade; Ex: contador++ ou ++contador
-- // Decrementa variável de 1 unidade; Ex: contador-- ou --contador

APROG - Java 22
 Java - Instrução atribuição
▪ Sintaxe
variável = expressão; // expressão tem de resultar num tipo compatível com a variável

▪ Exemplos
public class NomePrograma {

public static void main(String[] args){

int x, y;
double z;
int d, idade;
…
x = 5;
…
d = idade – 12; // idade e d têm de ser do mesmo tipo
…
z = x * 10 – Math.pow(2,5); // Math.pow(2,5) = 25

}
}

APROG - Java 23
 Java - Instrução decisão
▪ Sintaxe

if (condição) { // SE ... ENTÃO … FSE

// acção
} // { ... } ; obrigatório para acção com mais de 1 instrução

if (condição) { // SE ... ENTÃO ... SENÃO … FSE

// acção 1
} else {
// acção 2
}

// CASO ... SEJA

switch(expressão) { // expressão tem de ser do tipo inteiro, carácter ou string
case valor_1[: case valor_2: ...: case valor_m] : // acção_1; break;
case valor_n[: case valor_o: ...: case valor_v] : // acção_2; break;
...
default : // acção_por_omissão; //opcional
}

APROG - Java 24
 Java - Instrução decisão
▪ Exemplos
public class NomePrograma {
public static void main(String[] args){
int x, y, z;
…
if (x>5)
y=4; // {...} não é obrigatório para apenas uma instrução
…
if(x>5 && x<10){ // {…} é obrigatório por haver mais de uma instrução
y=10;
z=100;
}
…
if (x>0) {
System.out.println(x + "é um nº positivo");
} else {
System.out.println(x + "não é um nº positivo");
}
}
} para imprimir no ecrã

APROG - Java 25
 Java - Instrução decisão
▪ Exemplos
Problema: a partir da idade de uma pessoa indicar se é maior de idade ou, caso a idade seja
negativa escrever inválido

public class NomePrograma { public class NomePrograma {

public static void main(String[] args){ public static void main(String[] args){
int idade; int idade;
… …
if (idade > 0) if (idade > 0) {
if (idade >= 18)
if (idade >= 18)
System.out.println(“maior de idade");
System.out.println(“maior de idade");
else
System.out.println(“inválido"); } else
} System.out.println(“inválido");
}

Errado
Exemplo:
Idade = 10
APROG - Java 26
 Java - Instrução decisão
▪ Exemplos (com valores numéricos)
public class NomePrograma {
public static void main(String[] args){
int x, y, z;
…
switch(x){
case 1: case 3:
z = y * 2;
break;
case 6: break termina execução do switch;
z = 12; senão, são executadas as instruções
break; do caso seguinte
case 2: case 4: case 7:
y = 45;
z = 23;
break;
default:
z=50;
}
…

APROG - Java 27
 Java - Instrução decisão
▪ Exemplos (com Strings)
public class NomePrograma {
public static void main(String[] args){
String mes;
…
switch(mes){
case ”janeiro”: case ”fevereiro”:
…
break;
case ”marco”: break termina execução do switch;
… senão,break;
são executadas as instruções
break; do caso seguinte
default:
…
}
…

APROG - Java 28
 Java - Instrução repetição
▪ Sintaxe

while (condição) { // ENQUANTO … REPETIR

// corpo do ciclo
}

do { // REPETIR ... ENQUANTO

// corpo do ciclo
} while (condição); // termina com ponto e vírgula ( ; )

for(inicialização; condição de funcionamento; passo){ // REPETIR PARA

// corpo do ciclo
}

APROG - Java 29
 Java - Instrução repetição

APROG - Java 30
 Java - Instrução repetição
▪ Exemplos

public class NomePrograma {

public static void main(String[] args){
int hora, numero;
Scanner ler = new Scanner(System.in);
hora = 0;
while (hora<=23) {
System.out.println(hora);
hora++;
}
do {
numero = ler.nextInt();
} while (numero>0);
for (hora=0; hora<=23; hora++) { // REPETIR PARA hora0 ATÉ 23 PASSO 1
System.out.println(hora);
}
for (hora=23; hora>=0; hora--) // for(…); não terminar com ponto-e-vírgula
System.out.println(hora); se existirem instruções associadas à repetição
…

APROG - Java 31
 Java – Blocos de Instruções
Um bloco de instruções refere-se a um conjunto de instruções que pertencem a um
contexto comum. Um bloco é delimitado por chavetas { … }

▪ Uma variável declarada dentro de um bloco é local ao bloco.

▪ Quando o bloco termina, a variável desaparece.

▪ Quando é necessário usar uma variável dentro e fora de um bloco então, ela deve ser
declarada fora do bloco.

int x

for (int x =1; x<10; x++) { for (x =1; x<10; x++) {

… …
} }
System.out.println( x ); System.out.println( x );

Errado
APROG - Java 32
 Java – Blocos de Instruções
int a;
{ Zonas de validade das variáveis
…
{
int b;
…
{
int c;
…
}
}
{
int d;
…
}
}

APROG - Java 33
APROG - Java 34
 Java – Conversão de tipos numéricos
▪ Conversão implícita (sem perda de informação)
▪ Conversão para tipos compatíveis com igual ou maior capacidade

byte → short → int → long → double

▪ Ex: int a = 10;
double b = a;

▪ Conversão explícita (com possível perda de informação)

▪ Declarada explicitamente através de um cast porque pode originar perda de informação
▪ Sintaxe de um cast
▪ (tipo destino) nomeVariavel
▪ Ex: double pi = 3.1415;
int a = (int) pi; //parte decimal é descartada (a=3)

APROG - Java 35
 Java – tipos de dados
Um tipo de dados é um conjunto de valores relacionados por um conjunto de operações

▪ Tipos primitivo (simples) char, byte, short, int, long, float, double, boolean
▪ Guardam valores atómicos, isto é, valores que não se podem decompor
▪ Ex: int a = 10; 0x0034abcd
double b = 3.1415;
a 10
boolean c = true;
int

▪ Tipos referência arrays, classes (String, …)

▪ Guardam o endereço de memória onde estão representados objetos
▪ Ex: String nome = “Rui”; 0x0056abf0
0x0034abcd 0x0056abf1 R
nome 0x0056abf1 0x0056abf2 u
0x0056abf3 i
String
0x0056abf4

APROG - Java 36
 </Repetições>

APROG - Java 37
APROG - Java 38
 Java - Entrada de dados
Suportada por objeto da classe Scanner // java.util.Scanner

▪ Classe Scanner
▪ Serve para ler informação de uma entrada específica
▪ Ficheiros de texto
▪ Consola (teclado) é tratada como ficheiro de texto

▪ Declaração de objeto Scanner para leitura da entrada padrão (teclado)

Scanner ler = new Scanner(System.in);

▪ Cria objeto (instância) da classe Scanner (objeto ler)

▪ System.in representa dispositivo de entrada standard (teclado)
▪ System é classe que representa sistema de computação
▪ in é objeto da classe System que representa dispositivo de entrada padrão
▪ Por omissão, é o teclado
APROG - Java 39
 Java - Entrada de dados
▪ Leitura
▪ Preciso invocar método do objeto Scanner adequado ao tipo de dado a ler
▪ Sintaxe: nomeObjetoScanner.nomeMétodo()
▪ Exemplo: ler.nextInt() // para ler int

▪ Métodos de instância da classe Scanner que podem ser aplicados ao objeto (ler)
▪ next() Lê próxima string simples do teclado (i.e., cadeia de carateres terminada
pelo caráter espaço ou newline ('\n'))
▪ nextLine() Lê próxima linha do teclado (i.e., cadeia de carateres terminada em \n)
▪ nextInt() Lê próximo int do teclado
▪ nextLong() Lê próximo long do teclado

▪ nextFloat() Lê próximo float do teclado

▪ nextDouble() Lê próximo double do teclado

APROG - Java 40
 Java - Entrada de dados
▪Exemplos de instruções para ler informação e guardá-la numa variável
▪Leitura de inteiro:
int num = ler.nextInt();

▪Leitura de float:
float num = ler.nextFloat();

▪Leitura de strings:
String s = ler.next(); // palavra simples (apenas 1 palavra)
//ex: “Ana”, “maria”, “domingo”

String s = ler.nextLine(); // frase (todas as palavras até ao fim da linha)

//ex: “ana Maria”, “Ola eu sou o Rui”

APROG - Java 41
 Java - Entrada de dados
import java.util.Scanner; // importa classe Scanner para usar em main
public class NomePrograma {
public static void main(String[] args){
int numero;
long altura;
double peso;
String nome, nomeComposto;
…
Scanner ler = new Scanner(System.in); // declara um objeto Scanner para ler do teclado
…
numero = ler.nextInt(); // lê um int do teclado e guarda em numero
altura = ler.nextLong(); // lê um long do teclado e guarda em altura
peso = ler.nextDouble(); // lê um double do teclado e guarda em peso
…
nome = ler.next(); // lê uma string do teclado e guarda em nome
nomeComposto= ler.nextLine(); // lê uma linha e guarda em nomeComposto
…
}
}

APROG - Java 42
 Java - Entrada de dados
▪Problemas quando se combina a leitura de números, strings e linhas de texto
▪Os métodos para leitura de números (nextInt(), nextDouble(), nextFloat()) apenas
capturam os valores numéricos.

▪O método para leitura de uma palavra (next()) apenas captura a sequência de carateres
até encontrar um espaço, tab ou fim de linha, mas não os inclui.

▪ Qualquer um dos métodos anteriores não captura o caráter de mudança de linha ´\n´.

▪Apenas o método nextLine() captura na íntegra uma linha de texto, incluíndo o ´\n´.

▪Os carateres não capturados pelos métodos podem ser capturados pelo método
seguinte, originando problemas.

APROG - Java 43
 Java - Entrada de dados
▪Problemas quando se combina a leitura de números, strings e linhas de texto
▪Exemplo
Pretende-se ler a idade e o nome de uma pessoa. Considere os valores 5 e “Rui Sá”.

Scanner ler = new Scanner(System.in);

int idade = ler.nextInt();
String nome = ler.nextLine();

Na leitura da idade foram pressionadas 2 teclas: [5]+[ENTER].

O método nextInt() capturou o valor 5 para a variável idade e deixou ficar o [ENTER].
De seguida o método nextLine() deteta que já existe conteúdo terminado por [ENTER] e
captura-o para a variável nome.
Ou seja, nome fica vazio!!!!!!

APROG - Java 44
 Java - Entrada de dados
▪Problemas quando se combina a leitura de números, strings e linhas de texto
▪Sugestões
1. Quando se pretende usar o método nextLine() conjuntamente com outros métodos de
leitura deve-se “limpar”, imediatamente antes do nextLine(), qualquer conteúdo lido
que possa existir, através da invocação do método nextLine() .

Scanner ler = new Scanner(System.in);

int idade = ler.nextInt();
ler.nextLine(); limpa o [ENTER] deixado
String nome = ler.nextLine(); pelo nextInt() anterior

2. Usar nextLine() para todas as leituras e converter os valores numéricos lidos através de
métodos de classe apropriados, por exemplo:
int idade = Integer.parseInt( ler.nextLine() );
float peso = Float.parseFloat( ler.nextLine() );
double altura = Double.parseDouble( ler.nextLine() );
APROG - Java 45
 Java - Saída de dados
Suportada pelos métodos print, println e printf do objeto System.out

▪ System é classe que representa sistema de computação

▪ out é objeto da classe System que representa dispositivo de saída padrão

▪ Por omissão, ecrã

▪ Métodos de escrita

▪ System.out.print("mensagem"); //mantém-se na mesma linha

▪ System.out.println("mensagem"); //muda de linha
▪ System.out.printf(string_formatação, lista_parâmetros);

APROG - Java 46
 Java - Saída de dados
public class NomePrograma {
public static void main(String[] args){

...
// Escreve mensagem e coloca cursor no fim

System.out.print("Operação impossível!");

...
// Escreve mensagem e coloca cursor no início da linha seguinte

System.out.println("Divisão por zero!!");

...
// Saída formatada; Escreve a media (double) com uma casa decimal. Exemplo: “Média=15.3”

double media = 15.3456;

System.out.printf("Média=%.1f",media);
}
} Operação impossível!Divisão por zero!!
output
Média=15.3

APROG - Java 47
 Java - Saída de dados (formatados)
printf / format (são idênticos)

▪ Especificadores de formato para o printf

▪ %d número decimal (inteiro) (base 10)

▪ %f número de ponto flutuante

▪ %s String

▪ %% imprime um sinal de percentagem

▪ %n muda de linha
…

APROG - Java 48
 Java - Saída de dados (formatados)
public class NomePrograma { <----10--->|<--6->|<-5->|
public static void main(String[] args){ Nome Idade Média
|----------|------|-----|
|Ana |18 | 3.5|
String nome="Ana"; |Berta |15 | 10.1|
int idade=18; |Carolina |9 | 0.3|
double media=3.45612;
System.out.println("Nome Idade Média");
System.out.println("|----------|------|-----|");

System.out.printf(“|%s |%d |%f|%n",nome,idade,media);

Nome Idade Média
|----------|------|-----|
|Ana |18 |3.456120|

System.out.printf("|%10s|%6d|%5f| %n",nome,idade,media); Nome Idade Média

|----------|------|-----|
| Ana| 18|3.456120|

System.out.printf("|%-10s|%6d|%5.1f| %n",nome,idade,media); Nome Idade Média

|----------|------|-----|
} |Ana | 18| 3.5|

APROG - Java 49
 Java - Strings
String
▪ Cadeia de carateres = texto
▪ SÃO IMUTÁVEIS – uma vez criadas não são modificáveis
▪ Exemplos
▪ "ISEP"
▪ "Algoritmia e Programação"
▪ “JUPITER"

▪ Declaração
String v = ""; // String vazia
String s = "ISEP";
String nome = “Ana Berta Carla Dionísio”;

APROG - Java 50
 Java - Strings
Carateres especiais

• Strings podem conter carateres especiais com funções específicas (sequência de escape)

• Cada sequência de escape é um único carácter embora seja escrito com dois símbolos.

\t Insere um tab no texto

\b Insere um backspace no texto
\n Insere uma mudança de linha no texto
\r Insere um carriage return no texto
\’ Insere uma plica no texto.
\“ Insere uma aspa no texto.
\\ Insere uma barra para trás (backslash) no texto

▪ Exemplos

String s = "Aprog\t, é \”fixe\” e fácil"; //s=“Aprog , é “fixe” e fácil”

APROG - Java 51
 Java - Strings
String

String s = “Bom dia, Rui"; conteúdo

B o m d i a , R u i
0 1 2 3 4 5 6 7 8 9 10 11
posições

a posição inicial é zero (0) e não um (1)

System.out.println( s.charAt(0) );
System.out.println( s.charAt(7) );
System.out.println( s.charAt(9) );

APROG - Java 52
 Java - Strings
Métodos

▪ int length()
▪ String toLowerCase()
▪ String toUpperCase()
▪ int compareTo(String outraString)
▪ boolean equals(String outraString)
▪ boolean equalsIgnoreCase(String outraString)
▪ String trim()
▪ char charAt( int índice )
▪ …

APROG - Java 53
 Java - Strings
▪ Exemplos // considerando: String s = "Aprog";
▪ int length()
▪ Retorna comprimento da string (quantidade de carateres)
int comprimento = s.length(); // comprimento = 5

▪ String toLowerCase()
▪ Retorna a string com todas as letras minúsculas
String s2 = s.toLowerCase(); // s2 = “aprog”

▪ String toUpperCase()
▪ Retorna a string com todas as letras maiúsculas
String s2 = s.toUpperCase(); // s2 = “APROG”

APROG - Java 54
 Java - Strings
▪ Comparação de Strings

Não se pode usar os operadores relacionais para comparar Strings

É necessário verificar se o conjunto de carateres é o mesmo e pela mesma ordem

▪ Exemplos // considerando: String s = "Aprog";

▪ int compareTo(String outraString)

▪ Compara duas strings alfabeticamente e retorna um número inteiro
▪ Negativo Ex: s.compareTo("PPROG") s é anterior a "PPROG"
▪ Positivo Ex: s.compareTo("ALIN") s é posterior a "ALIN"
▪ Zero Ex: s.compareTo("Aprog") s e "Aprog" são iguais
if ( s.compareTo("APROG")==0 )
System.out.println(" s=APROG ");
else
System.out.println(" s≠APROG ");
APROG - Java 55
 Java - Strings
▪ Exemplos // considerando: String s = "Aprog";

▪ boolean equals(String outraString) if ( s.equals("APROG") )

▪ Distingue maiúsculas de minúsculas System.out.println(" s=APROG ");
else
s ≠ “APROG” System.out.println(" s≠APROG ");

▪ boolean equalsIgnoreCase(String outraString)

▪ Compara duas strings alfabeticamente sem distinguir maiúsculas de minúsculas e
retorna:
▪ true caso sejam iguais
if ( s.equalsIgnoreCase("APROG"))
▪ false caso sejam diferentes System.out.println(" s=APROG ");
else
System.out.println(" s≠APROG ");
s = “APROG”

APROG - Java 56
 Java - Strings
▪ Exemplos // considerando: String s = "Aprog";

▪ char charAt( int índice )

▪ Retorna o caráter que se encontra na posição índice
char c = s.charAt(0); // c = 'A'
char c = s.charAt(1); // c = 'p’

▪ String trim()
▪ Retorna cópia da string sem espaços brancos iniciais e finais
String s1 = " APROG ";
String s2 = s1.trim(); // s2 = "APROG"

APROG - Java 57
 Java - Strings
▪ Concatenar Strings - Usa-se o operador +
Permite criar uma nova string a partir da junção dos valores de várias strings ou números.
O primeiro elemento da junção tem de ser uma string.

▪ Exemplos
String s = “Hoje é” + “ domingo, dia ” + 15;

s = “Hoje é domingo, dia 15”

String s1 = “ D ”;
String s2 = “ia”;
int dia = 15;
String s = s1.trim() + s2 + dia;

s = “Dia15”

APROG - Java 58
 Java - StringBuilder
StringBuilder
▪ Cadeia de carateres = texto
▪ SÃO MUTÁVEIS – podem ser modificáveis

▪ Preferível usar em vez de String quando se efetuam múltiplas operações de alteração

(ex: várias concatenações)

▪ Declaração
StringBuilder sb = new StringBuilder();

APROG - Java 59
 Java - StringBuilder
Métodos
▪ StringBuilder append(…)
▪ StringBuilder delete(…)
▪ StringBuilder insert(…)
▪ String toString()
▪ Int length()
▪ …

StringBuilder sb = new StringBuilder(); sb=“”

sb.append(“ISEP”); sb=“ISEP”
sb.append(“_dei_”); sb=“ISEP_dei_”
sb.append(19); sb=“ISEP_dei_19”
sb.delete(0, 4); sb=“_dei_19”
sb.insert(sb.length(), ”xxx”); sb=“ISEP_dei_19xxx”
APROG - Java 60
 Java - Math
Biblioteca que disponibiliza constantes matemáticas (atributos da classe) e operações
numéricas básicas e funções trigonométricas (métodos da classe)
▪Atributos
▪final double PI // 3.14... Exemplo: Math.PI
▪final double E // 2.71... Exemplo: Math.E
▪Métodos de Classe
▪double sqrt(double a) // Retorna raíz quadrada de a; Ex: Math.sqrt(3);
▪tipo abs(tipo a) // tipo = double, float, int ou long
// Retorna valor absoluto de a. Ex: Math.abs(-5)
▪double pow(double a, double b) // Retorna ab ; Exemplo: 25  Math.pow(2,5)
▪double exp(double a) // Retorna ea ; Exemplo: e5  Math.exp(5)
▪double random() // Retorna nº real aleatório do intervalo [0,1[
▪double cos(double angulo) // Retorna coseno do angulo em radianos
▪double sin(double angulo) // Retorna seno do angulo em radianos
▪double acos(double a) // Retorna arco coseno de a em radianos

APROG - Java 61
 </API>

APROG - Java 62