Tipos de Dados e Estruturas em Java

Tecnologia em Sistemas para Internet - IFMS

Aula 02 – Estruturas de Dados Básicas

Estruturas de Dados
Prof.º Msc. Sidney Roberto de Sousa

Sumário

● Tipos numéricos
● Strings
● Matrizes unidimensionais
● Matrizes multidimensionais

Tec. em Sistemas para Internet - IFMS 2

Tipos Numéricos

● São tipos de dados utilizados para se armazenar
valores numéricos
● São tipos numéricos na linguagem Java:
– byte
– short
– int
– long
– float
– double


Tipo byte
// O tipo byte pode armazenar inteiros entre [-128..127]
byte umByte = 0b00000011; // Associa o valor decimal 3 à variável umByte
System.out.println(umByte);
int umInteiro = umByte << 1; // Aplica a operação shift left na
// variável umByte, fazendo com o que o
// valor da variável seja multiplicado
// por 2 (Por quê?)
System.out.println(umInteiro);
byte outroByte = 0b00000001;
umInteiro = umByte + outroByte;
byte byteResultante = (byte) (umByte + outroByte);
umInteiro = byteResultante >> 1; // Que valor a variável umInteiro irá
// receber?


Tipo byte
byte umByte = 0b00000010;
byte outroByte = 0b00000100;
int inteiroResultante = umByte | outroByte; // Realiza uma operação OR
// bit a bit
System.out.println(inteiroResultante);
inteiroResultante = umByte & outroByte; // Realiza uma operação AND
// bit a bit
System.out.println(inteiroResultante);


Tipo short
// O tipo short pode armazenar inteiros entre [-32768..32767],
//sendo que uma variável deste tipo ocupa 2 bytes de memória.
short numeroPequeno = 127;
short outroNumeroPequeno = 73;
// Por questões de segurança, operações sobre dois valores
inteiros short sempre resultam em um valor do tipo int. Assim, a
linha abaixo gera um erro.
short resultado = numeroPequeno + outroNumeroPequeno;
System.out.println(resultado);


Tipo short
short numeroPequeno = 127;
short outroNumeroPequeno = 73;
int resultado = numeroPequeno + outroNumeroPequeno;
short resultadoShort = (short) (numeroPequeno + outroNumeroPequeno);
System.out.println(resultadoShort);


Tipo int
// O tipo int pode armazenar inteiros entre
// [-2.147.483.648..2.147.483.647], sendo que uma variável do
// tipo int utiliza 4 bytes de memória.
int numeroA = 1000567;
int numeroB = 29461201;
int resultado = numeroA * numeroB;
// resulta em 1544948519, valor este suportado pelo tipo int


Tipo long
// O tipo long pode armazenar inteiros entre
// [-9.223.372.036.854.775.808..9.223.372.036.854.775.807],
// sendo que uma variável do tipo long utiliza 8 bytes de memória.
long numero = System.currentTimeMillis();
long outroNumero = numero * 1000;
System.out.println(outroNumero);


Tipo float
// O tipo float pode armazenar inteiros entre
//[1.4e-45..340.282.346.638.528.860.000.000.000.000.000.000.000,000000],
// sendo que uma variável do tipo float utiliza 4 bytes de memória.
float numeroPontoFlutuante = 223.23; // Esta associação resultará em erro!
float outroNumeroDePontoFlutuante = 223.23f; // Ok!
// Variáveis do tipo float podem receber valores inteiros, uma vez que
// na matemática o conjunto dos números inteiros está sub-contido no
// conjunto dos números reais.
float maisUmNumeroDePontoFlutuante = 557;


Tipo double
// O tipo double pode armazenar inteiros entre
// [4.9e-324..1.7976931348623157e308], sendo que uma variável do
// tipo double utiliza 8 bytes de memória.

// Pode receber um valor inteiro
double numeroPontoFlutuante = System.currentTimeMillis();
double valorPotencia = Math.pow(numeroPontoFlutuante, 2);
System.out.println(valorPotencia);
numeroPontoFlutuante = 223.23; // Não resulta em erro.


Strings
// Uma string é uma cadeia (matriz unidimensional) de caracteres.
// Em Java, devemos utilizar a classe String para realizar operações com
// strings.

// Esta é a menor string possível, uma string de tamanho zero ou string
// vazia.
String umaString = "";
// O método isEmpty da classe String retorna true caso a string esteja
// vazia ou false c.c.
boolean stringVazia = umaString.isEmpty();
System.out.println(stringVazia); // Imprime true


Strings
String umaString = "Olá, mundo! Eu sou uma string!";
// O método length da classe String retorna o número de
caracteres imprimíveis e não imprimíveis que uma string possui.
int tamanhoString = umaString.length();
System.out.println("A string '" + umaString + "' possui " +
tamanhoString + " caracteres.");


Strings
String umaString = "Olá, mundo! Eu sou uma string!";
char caractere = umaString.charAt(0); // 'O'
caractere = umaString.charAt(umaString.length() - 1); // '!'
String parteDaString = umaString.substring(11); // " Eu sou uma
string!"
parteDaString = umaString.substring(0, 11); // "Olá, mundo!"


Strings
String primeiraParte = "Agora me sinto ";
String segundaParte = " como uma string completa!";
// "Agora me sinto como uma string completa!"
String stringCompleta = primeiraParte + segundaParte;

stringCompleta = "A linguagem Java surgiu nos anos ";
int anos = 90;
// O resultado da concatenação de uma string com um número
// resulta em uma string
stringCompleta += anos;
// "A linguagem Java surgiu nos anos 90"
System.out.println(stringCompleta);


Strings
String umaString = "Eu sou uma string";
String outraString = umaString;
// Strings podem ser comparadas com os operadores comuns
boolean saoIguais = umaString == outraString; // true

// O método toLowerCase da classe String converte todos os caracteres da
// string em minúsculos
String stringMinusculos = umaString.toLowerCase();
// O método toUpperCase da classe String converte todos os caracteres da
// string em maiúsculos
String stringMaiusculos = umaString.toUpperCase();
saoIguais = stringMinusculos == stringMaiusculos; // false
// O método equalsIgnoreCase da classe String compara uma string com
// outra desconsiderando se os caracteres estão em caixa alta ou baixa.
saoIguais = stringMinusculos.equalsIgnoreCase(stringMaiusculos); // true


Strings
String umaString = "Eu sou uma string";
// O método replace da classe String substitui todas as ocorrências
// de uma substring por outra desejada.
String outraString = umaString.replace("string", "abóbora");
// "Eu sou uma abóbora"
System.out.println(outraString);

umaString = "Nove queijos, oito queijos, sete queijos";
outraString = umaString.replace("queijos", "pratos");
// "Nove pratos, oito pratos, sete pratos"
System.out.println(outraString);


Strings
String umaString = "mato capim arbusto árvore bicho palha folhas";
// O método contains da classe String verifica a existência de uma
// substring na string pesquisada.
boolean temBichoNesteMato = umaString.contains("bicho");
System.out.println(temBichoNesteMato); // true


Strings
String umaString = " você pode remover estes caracteres em branco,
por gentileza? ";
// O método trim da classe String remove os caracteres em branco no
// início e no fim da string.
umaString = umaString.trim();


Matrizes Unidimensionais
// Matrizes unidimensionais (ou vetores) são estruturas de dados
// que representam uma coleção de elementos, onde cada elemento
// é representado por uma única chave
int[] matrizUnidimensional = { 11, 28, 53, 4 };
// Percorre a matriz unidimensional
for (int i = 0; i < matrizUnidimensional.length; i++) {
// matrizUnidimensional[i] é um elemento do vetor
// matrizUnidimensional, sendo que i é a sua chave única
System.out.println(matrizUnidimensional[i]);
}


int[] matrizUnidimensional = { 1, 2, 3, 4 };
// É possível utilizar o laço for each para percorrer matrizes.
// Porém, quando se utiliza um laço for each para percorrer uma
// matriz, os elementos da matriz não podem ser alterados.
for (int elemento : matrizUnidimensional) {
System.out.println(elemento);
elemento = 0; // Não surtirá efeito!
}


String umaString = "Primeiro elemento, segundo elemento, terceiro
elemento, quarto elemento, quinto elemento";
/*
* O método split da classe String quebra uma string exatamente nos
* pontos de ocorrência de uma determinada substring, retornando assim
* uma matriz unidimensional de strings (partes da string original)
*/
String[] matrizDeStrings = umaString.split(", ");
for (String elemento : matrizDeStrings) {
System.out.println(elemento);
}


// Declara de uma matriz unidimensional de tamanho 10 de forma
// explícita.
int[] matrizUnidimensional = new int[10];

// Declara uma matriz unidimensional de tamanho 8 de forma
implícita
int[] outraMatrizUnidimensional = { 1, 2, 3, 4, 5, 6, 7, 8 };


Matrizes Multidimensionais
/**
* Declara uma matriz bidimensional de dimensões implícitas 3 x 3.
*/
int[][] matrizBidimensional = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
/**
* Os laços abaixo imprimirão no console:
* 1 2 3
* 4 5 6
* 7 8 9
*/
for (int i = 0; i < matrizBidimensional.length; i++) {
for (int j = 0; j < matrizBidimensional[i].length; j++) {
System.out.print(matrizBidimensional[i][j] + "t");
}
System.out.println("");
}


/**
* Declara uma matriz bidimensional de dimensões variáveis.
*/
int[][] matrizBidimensional = { { 1, 2, 3, 4 }, { 5, 6 }, { 7, 8, 9 } };
}
}


/**
* Declara uma matriz bidimensional com dimensões explícitas de 4 x 3.
*/
int[][] matrizBidimensional = new int[4][3];
matrizBidimensional[i][j] = i + j;
}
}

/**
* Exibe os valores:
* 012
* 123
* 234
* 345
*/
}
}


// Declara uma matriz de strings com dimensões implícitas de 3 x 3
String[][] matrizStrings = {
{ "linha 1 coluna 1", "linha 1 coluna 2", "linha 1 coluna 3" },
};


int[][] matriz = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

// Também é possível utilizar laços for each para percorrer
// matrizes multidimensionais.
for (int[] linha : matriz) {
for (int elemento : linha) {
System.out.print(elemento + "t");
}
}


// Que tal uma matriz tridimensional de dimensões 2 x 2 x 3? :D
int[][][] matriz = {
{
{ 1, 2, 3 },
{ 4, 5, 6 }
},
{
{ 7, 8, 9 },
{ 10, 11, 12 }
}
};


// Percorrendo a matriz tridimensional
for (int[][] subMatriz : matriz) {
for (int[] linha : subMatriz) {
for (int elemento : linha) {
System.out.print(elemento + "t");
}
}
}


Tipos de Dados e Estruturas em Java

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (17)

Semelhante a Tipos de Dados e Estruturas em Java

Semelhante a Tipos de Dados e Estruturas em Java (20)

Mais de Sidney Roberto

Mais de Sidney Roberto (20)

Tipos de Dados e Estruturas em Java