Estruturas de Dados Básicas

Tecnologia em Sistemas para Internet - IFMS

Aula 02 – Estruturas de Dados Básicas

Estruturas de DadosProf.º Msc. Sidney Roberto de Sousa

Tec. em Sistemas para Internet - IFMS 2

Sumário

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


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:

* 0 1 2

* 1 2 3

* 2 3 4

* 3 4 5

*/




}


}



// 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");

}


}


}

Technology

Estruturas de Dados Básicas