Java

Exceção : É uma condicional anormal que surge durante a execução do programa ( Run Time Error)

Throws :Se um método é capaz de gerar um erro que não é tratado ele deve especificar este comportamento através do Throws

Ex :

digamos que vc tenha um jtextfield, e que vc so quer que o cara digite numeros..... ai quando ele digita, vc tem um metodo que verifica se tem alguma letra.... 

1. public void verifica() {  2. //aqui vc achou uma letra, ai voce dispara uma excessao com o THROW  3.    throw new SuaExcessao();  4. }  

Você usa para lançar uma excessão, imagine que voc6e tenha uma classe Cliente com um método setCPF, a validação do cpf é feita na classe cliente, no caso do cpf ser inválido, você lança uma excessão obrigando o cara que for usar o método setCPF a tratá-la. Ex: 

1. public void setCPF(String cpf) throws Exception {  2.     // Verifica se o cpf é valido  3.     // Se não for lança a excessão  4.     throw new Exception("CPF invalido!");  5. } 

Considere a classe:

public class Calc {

public int div(int a, int b) {

return a/b;

}

O método div, se for chamado com b igual à zero, dará um erro. Esse erro pode sinalizado através de uma exceção

Vamos, então, modelar uma exceção que indica uma tentativa de divisão por zero:

public class DivByZero extends Exception {

public String toString() {

return "Division by zero.";

}

}

Agora vamos fazer com que o método div lance a exceção que criamos:

public class Calc {

public int div(int a, int b) throws DivByZero {

if (b == 0) throw new DivByZero();

return a/b;

}

Podemos, agora, utilizar o método div e tratar a exceção, caso esta ocorra:

...

Calc calc = new Calc();

try {

int div = calc.div(x, y);

System.out.println(div);

} catch (DivByZero e) {

System.out.println(e);

}

}

Multi-tasking

Dois Tipos :

Processo Thread

MULTI TASK baseada em processo permite que vários programas executem ao mesmo tempo.Ex.: processo de texto e editor gráfico.

MULTI TASK baseada em thread – um único programa executando várias tarefas simultâneas.Ex.: editor de texto executando corretor ortográfico.

Compartilham o mesmo espaço de memória. Compartilham o mesmo processo. Compartilham entre threads é de baixo custo. Mudança de contexto de baixo custo.

Razões para usar MULTI THREADING

Permite escrever programas eficientes para maximizar o uso do CPU. Permite uso do tempo vago da cpu.

o Network.o I/Oo Usuário.

Exe :

public class Thread_Demo {public static void main(String Args[]){

Thread t = Thread.currentThread();System.out.println("Thread"+t);t.setName("minha thread");System.out.println(t);

try{

for (int n=5; n>0; n--) {System.out.println(n);Thread.sleep(1000);

}}catch(InterruptedException e){

System.out.println("thread interrompido");}

}}

Collections, qual usar?

A interface Collection possui várias implementações, como ArrayList, LinkedList, TreeSet e outras. Com tantas variações, algumas vezes você não sabe qual usar, isto depende de seu objetivo. Tentarei explicar algumas diferenças entre ArrayList, LinkedList e TreeSet.

ArrayListA Collection ArrayList permite armazenar objetos e valores nulos, mas seu acesso é desordenado, o primeiro objeto inserido pode ser o último retornado.

LinkedListEsta implementação de Collection é parecida com o ArrayList, mas a diferença está no acesso aos objetos armazenados, onde cada objeto é retornado na ordem de inserção.

TreeSetSe você quer recuperar os objetos de sua Collection em uma ordem específica, esta Collection pode fazer o trabalho! Inserir objetos em um Treeset é igual às classes anteriores, mas seu retorno depende da interface Comparable implementada no valores. Ele ordena seus objetos usando o resultado do método compareTo, herdado da interface Comparable.

Como declarar e usar ArrayList em Java

Importe:import java.util.ArrayList;Por ser um tipo diferente, sua sintaxe é um pouco diferente do que você já viu até então:

ArrayList< Qualquer_Tipo > nomeDoArrayList = new ArrayList< Qualquer_Tipo >();

No exemplo a seguir, vamos usar um ArrayList de String para trabalhar com o nome de várias Bandas de música:ArrayList<String> bandas = new ArrayList<String> ();

Exemplo de uso do ArrayListApós declarar a ArrayList 'bandas' que armazenará Strings, vamos adicionar alguns nomes.Primeiro adicionamos a banda "Rush":bandas.add("Rush");

Existe um método do ArrayList chamado 'toArray()' que coloca todos os elementos de um ArrayList em um Array.Ou seja: bandas.toArray() é um Array!

Porém, já vimos que existe um método 'toString' da classe Arrays que retorna uma String com os elementos de um Array. Vamos usar esse método parar exibir todos os elementos do ArrayList, que transformamos em Array através do método 'toArray()':Arrays.toString( bandas.toArray() );

Vamos adicionar a segunda banda, "Beatles" e imprimir, usando o mesmo método.Note que quando usamos 'add', sempre adicionamos o elemento pro fim da ArrayList.Confirme isso agora, vendo que a banda "Iron Maiden" ficará depois de "Beatles".

Vamos pegar o primeiro elemento, o elemento '0', através do método 'get':bandas.get(0);

Note que é a banda "Rush", pois ela foi a primeira a ser adicionada.

Vamos adicionar o "Tiririca" na posição do "Rush", ou seja, na posição '0':bandas.add(0,"Tiririca");oubandas.add( bandas.indexOf("Rush"), "Tiririca");

Pois o método 'indexOf' retorna o índice em que ocorre "Rush".

Para saber o tamanho que tem seu ArrayList, basta usar o método 'size()':bandas.size();

Feito isso, rapidamente remova o "Tiririca", pois alguém pode ver.Para tal, use o método 'remove':bandas.remove("Tiririca");

Ok. Não quer mais brincar de ArrayList? Remova tudobandas.clear();

import java.util.ArrayList;import java.util.Arrays;

public class arrayLists{ public static void main(String[] args){ ArrayList<String> bandas = new ArrayList<String> (); bandas.add("Rush"); System.out.print( "Adicionando a banda Rush: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); bandas.add("Beatles"); System.out.print( "Adicionando a banda Beatles: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); bandas.add("Iron Maiden"); System.out.print( "Adicionando a banda Iron Maiden: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Quem está na índice 0: " ); System.out.println( bandas.get(0) ); System.out.print( "Adicionando Tiririca onde estava o Rush: " ); bandas.add( bandas.indexOf("Rush"), "Tiririca"); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Número de elementos na lista: " ); System.out.println( bandas.size() ); System.out.print( "Removendo o Tiririca: " ); bandas.remove("Tiririca"); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Removendo tudo: " ); bandas.clear(); System.out.println( Arrays.toString( bandas.toArray() ) ); }

}

Saída

Adicionando a banda Rush: [Rush]Adicionando a banda Beatles: [Rush, Beatles]Adicionando a banda Iron Maiden: [Rush, Beatles, Iron Maiden]Quem está na índice 0: RushAdicionando Tiririca onde estava o Rush: [Tiririca, Rush, Beatles, Iron Maiden]Número de elementos na lista: 4Removendo o Tiririca: [Rush, Beatles, Iron Maiden]Removendo tudo: []

StringStrings são utilizadas frequentemente em várias linguagens de programação, não apenas Java. Embora Strings sejam uma sequência de caracteres em Java, e não um array de caracteres.

Em Java, o importante é entender que string não é um tipo de dado, mas sim uma classe. E suas variáveis são, na verdade, objetos dessa classe.

Em síntese, tanto um array de caracteres como uma string se apresentam da mesma forma.

Então, qual a vantagem de se usar uma classe e não um array de tipo primitivo?

A resposta se baseia exatamente no uso da orientação a objetos e no fato de que existem muitos métodos que podemos utilizar em um objeto instanciado da classe String, mesmo sendo os objetos desta classe imutáveis, ou seja, uma vez instanciados não podemos mudar o que está guardado dentro do objeto String.

Dentre as possibilidades oferecidas pela classe String podemos destacar algumas como:

Concatenação ; Tamanho da String ; Converter para maiúsuculas ou minúsculas; Fazer comparações que incluem verificações no início e no fim; Extrair um caracter específico da string; Achar um índice da string, inclusive recursivamente (de trás para frente); Substituir  uma parte da string ou ela completamente; Verificar se uma string contém outra; Dividir uma string em array ou vetor; Obter uma porção da string inteira, o que chamamos de substring.

Objetos Strings podem ser instanciadas usando um array de caracteres ou bytes com o operador new. Ou por meio de uma string literal. String literal é qualquer sequência de caracteres que estiver entre aspas (").

01.public class ExemploCriarString {

02.public static void main(String[] args) {

03.char[] charArray = { 'T', 'I', ' ', 'E', 'x', 'p', 'e', 'r', 't'};

04./* construindo uma string a partir de um array de char */

05.String string1 = new String(charArray);

06./* construindo uma string a partir de uma string literal */

07.String string2 = "www.tiexpert.net";

08.

09.System.out.println(string1);

10.System.out.println(string2);

11.}

12.}

ConcatenaçãoConcatenação nada mais é do que juntar strings numa só. Isto pode ser feito de duas formas: uma usando o método concat() da classe String ou usando o sinal de adição (+) como operador de concatenação.

O método concat() retorna uma nova string formada da junção da string principal com a string indicada como parâmetro.

De uma forma mais simples, podemos usar o + para juntar várias strings ao mesmo tempo. Para mais detalhes, veja o artigo principal sobre concatenação.

Tamanho da string - length()A classe String possui um método acessor que retorna o tamanho da String. Esse método é length().

1.public class TamanhoString {

2.public static void main(String[] args) {

3.String str = "TI Expert";

4.System.out.println(str + " possui " + str.length() + " caracteres.");

5.}

6.}

Letras Maiúsculas e MinúsculasPodemos facilmente deixar todas as letras de uma sequência de caracteres maiúscula ou minúscula usando os métodos toUpperCase() e toLowerCase() respectivamente.

1.public class StringMaiusculoMinusculo {

2.public static void main(String[] args) {

3.String email = "MeuNoMe@MEUDominiO.coM.bR";

4.String hexadecimal = "#aa33ff";

5.System.out.println(email.toLowerCase());

6.System.out.println(hexadecimal.toUpperCase());

7.}

8.}

ComparaçãoHá várias formas de se fazer comparações com uma string, mas vale sempre lembrar que Java é case sensitive - diferencia letras maiúscula de minúsculas e vice-versa. Embora haja métodos próprios para comparações em que não há importância em diferenciar letras maiúsculas e minúsculas.

A comparação mais simples é usando o próprio operador de igualdade (==), mas por se tratar de um objeto é preferível que se use o método específico chamado equals().

O método equals() compara o objeto string com outro objeto, se ambos possuírem conteúdos iguais, então, é retornado verdadeiro (true), caso contrário falso (false). Isso quer dizer que se, por exemplo, tiver um objeto da classe Integer que vale 15 e uma string contendo os caracteres 1 e 5, a comparação de ambos resultará em verdadeiro.

A função equals() é case sensitive, para fazer uma comparação ignorando esta característica basta usar o métodoequalsIgnoreCase().

01.public class ComparacaoIgualdadeString {

02.public static void main(String[] args) {

03.String string1 = "TI Expert";

04.String string2 = "ti expert";

05.System.out.println("São iguais? (case sensitive)");

06.System.out.println(string1.equals(string2) ? "sim" : "não");

07.System.out.println("São iguais? (sem case sensitive)");

08.System.out.println(string1.equalsIgnoreCase(string2)

? "sim" : "não");

09.}

10.}

Há também uma forma de comparar strings lexicograficamente. Dessa forma, podemos verificar se uma string é identica (quando retorna-se 0), ou se ela tem um valor menor (quando retorna-se um número abaixo de 0) ou se ela tem um valor maior (quando retorna-se um número acima de 0).

O método para fazer tais comparações é o compareTo() (case sensitive) ou compareToIgnoreCase() (sem case sensitive).

01.public class ComparacaoString {

02.public static void main(String[] args) {

03.String string1 = "TI Expert";

04.String string2 = "ti expert";

05.int comparacao = string1.compareTo(string2);

06.System.out.println("Comparação entre string1 e string2 (sensitive case)");

07.if (comparacao > 0) {

08.System.out.println("string1 é lexicograficamente maior que string2");

09.} else if (comparacao < 0) {

10.System.out.println("string1 é lexicograficamente menor que string2");

11.} else {

12.System.out.println("string1 é lexicograficamente igual a string2");

13.}

14.}

15.}

Início e fimOutra forma de fazer comparações é fazer testes no início e no fim de uma string.

Podemos fazer tais comparações usando dois métodos: startsWith() e endsWith().

StartsWith() verifica se há uma string no começo de outra string. StartsWith() também possui um segundo parâmetro opcional que determina a compensação inicial, ou seja, caso necessite verificar a string não da posição 0, mas de uma posição mais adiante.

EndsWith() verifica se há uma string no final de outra string. Diferentemente de startsWith(), o métodoendsWith() não possui compensação.

01.public class InicioFim {

02.public static void main(String[] args) {

03.String string1 = "http://www.tiexpert.net";

04.System.out.println("A string " + string1 + " é:");

05.// verifica se há 'http:' no inicio da string

06.if (string1.startsWith("http:")) {

07.System.out.println("uma URL");

08.}

09./*

10.* verifica se há 'www' no início da string, mas apenas a partir do

11.* 8o. caracter, ou seja, após o prefixo 'http://', portanto deverá

12.* ser compensado 7 caracteres

13.*/

14.if (string1.startsWith("www", 7)) {

15.System.out.println("uma página da web");

16.}

17.if (string1.endsWith(".br")) {

18.System.out.println("um site registrado no Brasil");

19.} else {

20.System.out.println("não é um site registrado no Brasil");

21.}

22.}

23.}

Caracter na posiçãoPodemos também obter um caracter que se encontra em alguma posição dentro da string. Para isso, usaremos o método charAt().

CharAt() recebe um inteiro como argumento que indica a posição que queremos da string.

Importante: Strings seguem o mesmo conceito de vetores e arrays, portanto, seu primeiro caracter não está na posição 1, mas na posição 0.

1.public class ExtrairCaracter {

2.public static void main(String[] args) {

3.String string1 = "TI Expert";

4.char caracter = string1.charAt(3);

5.System.out.println("O 4o. caracter desta string é " + caracter);

6.}

7.}

Índice da StringA classe string possui uma forma de encontrar o índice da primeira ocorrência de uma string dentro de outra string.

O método indexOf() retorna um número inteiro que indica exatamente em que posição ocorre uma string de busca, ou retorna um valor menor que 0 caso não encontre o valor requisitado. Assim como startsWith(), indexOf() também possui um segundo argumento que determina a compensação a ser feita caso a busca não possa ser feita desde a posição 0, mas de uma posição posterior.

Além do método indexOf(), há também o método lastIndexOf() que faz a mesma coisa que indexOf(), porém de forma recursiva (de trás para frente ou do fim da string para o começo)

01.public class IndiceString {

02.public static void main(String[] args) {

03.String string1 = "www.tiexpert.net";

04.int posicao;

05.posicao = string1.indexOf("tiexpert");

06.if (posicao >= 0) {

07.System.out.println("A string tiexpert começa na posição " + posicao);

08.} else {

09.System.out.println("Não há tiexpert na string");

10.}

11.posicao = string1.lastIndexOf(".com");

12.if (posicao >= 0) {

13.System.out.println("A string .com começa na posição " + posicao);

14.} else {

15.System.out.println("Não há .com na string");

16.}

17.}

18.}

Substituir string ou parte delaPodemos substituir todas as ocorrências de uma string por uma nova string resultando em uma nova string de retorno.

Para executarmos esta operação usamos o método replace() que tem dois parâmetros: o primeiro será o que desejamos procurar dentro da string e o segundo a string que colocaremos no lugar da antiga.

Nota: replace também funciona com o tipo primitivo char.

1.public class SubstituirString {

2.public static void main(String[] args) {

3.String string1 = "http://tiexpert.net";

4.System.out.println(string1.replace("http://", "www."));

5.}

6.}

Verificar conteúdo da string

Um método muito útil para verificar o conteúdo de uma string é o contains().

Contains() retorna verdadeiro (true) se houver a sequência de caracteres especificada no parâmetro.

1.public class VerificarConteudo {

2.public static void main(String[] args) {

3.String string1 = "http://www.tiexpert.net";

4.System.out.println("É uma página da web?");

5.System.out.println(string1.contains("www.") ? "sim" : "não");

6.}

7.}

Dividir em vários vetores ou arraysTambém é possível dividir uma string em um vetor ou array de strings, o que possibilita trabalhar com pedaços menores e mais lógicos da string.

Para dividir a string podemos usar o método split(). O método split usa uma expressão regular para fazer a divisão. Para simplificar o entendimento, podemos usar como parâmetro uma outra string como base. Mas vale atentar no fato de que a expressão utilizada para ser feita a quebra desaparece no fim do processo. Ex.: Se minha string for 15:30:00, se utilizarmos os dois pontos (:) para a separação conseguiremos um array com 3 posições que seriam: [0]->15, [1]->30, [2]->00.

01.public class Exemplo {

02.public static void main(String[] args) {

03.String string1 = "15:30:00";

04.String[] stringDividida = string1.split(":");

05.for (int i = 0; i < stringDividida.length; i++) {

06.System.out.println("stringDividida[" + i + "]=" + stringDividida[i]);

07.}

08.}

09.}

SubstringSubstring é uma porção ou parte da string principal da qual pode formar outra string, ou seja, uma substring é uma string formada a partir de uma string principal.

Para obtermos uma substring usamos um método homônimo (de mesmo nome) com um ou dois parâmetros.

O primeiro parâmetro, obrigatório, é a posição que a substring deve iniciar (lembrando-se que strings sempre começam da posição 0). O segundo parâmetro, opcional, é a posição final da substring, caso este parâmetro não seja indicado, a substring sempre irá até o último caracter encontrado.

Nota: O caracter na posição inicial fará parte da substring, porém o caracter na posição final não faz parte da substring. Vejamos o exemplo: Se tivermos uma string de 9 caracteres, portanto, de 0 a 8 posições, se fizermos a substring da seguinte forma: stringOriginal.substring(3,8);

0 1 2 3 4 5 6 7 8

T I E X P E R T

O resultado será Exper. Então, se quisermos que a 8ª posição entre, devemos usar a posição seguinte 9, assim:stringOriginal.substring(3,9);

01.public class ExemploSubstring {

02.public static void main(String[] args) {

03.String url = "www.tiexpert.net";

04.String dominio = url.substring(4);

05.String site = url.substring(url.indexOf('.') + 1, url.lastIndexOf('.'));

06.System.out.println("Análise da string:");

07.System.out.println("Domínio: " + dominio);

08.System.out.println("Site: " + site);

09.}

10.}