 |
|
Você está aqui: Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como exibir um JFileChooser e escolher um arquivo a partir de um JFrameQuantidade de visualizações: 38 vezes |
// Este exemplo mostra como exibir um JFileChooser
// e escolher um arquivo a partir de uma JFrame
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
public class Estudos extends JFrame{
public Estudos(){
super("Abrir um arquivo usando JFileChooser");
Container c = getContentPane();
FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
c.setLayout(layout);
JButton btn = new JButton("Abrir Arquivo");
btn.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
JFileChooser fc = new JFileChooser();
int res = fc.showOpenDialog(null);
if(res == JFileChooser.APPROVE_OPTION){
File arquivo = fc.getSelectedFile();
JOptionPane.showMessageDialog(null, "Voce escolheu o arquivo: " + arquivo.getName());
}
else
JOptionPane.showMessageDialog(null, "Voce nao selecionou nenhum arquivo.");
}
}
);
c.add(btn);
setSize(400, 200);
setVisible(true);
}
public static void main(String[] args) {
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
|
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Métodos, Procedimentos e Funções |
Exercício Resolvido de Java - Escreva um método chamado inverter() que recebe um número inteiro e retorna este mesmo número invertidoQuantidade de visualizações: 7146 vezes |
|
Pergunta/Tarefa: Escreva um método Java chamado inverter() que recebe um número inteiro e retorna este mesmo número invertido. Este método deverá ter a seguinte assinatura:
public static int inverter(int numero){
// sua implementação aqui
}
ATENÇÃO: Para a resolução deste exercício é permitido usar apenas os operadores aritméticos. Sua saída deverá ser parecida com: Informe um número inteiro: 487 O valor invertido é: 784 Veja a resolução comentada deste exercício usando Java: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
package estudos;
import java.util.Scanner;
public class Estudos{
public static void main(String[] args) {
// vamos fazer a leitura usando a classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos pedir ao usuário que informe um número inteiro
System.out.print("Informe um número inteiro: ");
int numero = Integer.parseInt(entrada.nextLine());
// fazer efetuar uma chamada ao método inverter() e obter o valor invertido
int invertido = inverter(numero);
// e exibir o resultado
System.out.println("O valor invertido é: " + invertido);
}
// método estático que recebe um número inteiro e o devolve invertido
public static int inverter(int numero){
int resultado = 0; // guarda o resultado da inversão
// enquanto número for diferente de 0
while(numero != 0){
// obtém resto da divisão de número por 10
int resto = numero % 10;
// resultado recebe ele mesmo multiplicado por 10 mais o resto
resultado = resultado * 10 + resto;
// finalmente número recebe ele mesmo dividido por 10
numero = numero / 10;
}
return resultado; // retorna o resultado
}
}
|
Java ::: Tratamento de Erros ::: Passos Iniciais |
Quais as diferenças entre checked exceptions, runtime exceptions e errors na linguagem Java?Quantidade de visualizações: 15431 vezes |
|
Checked exceptions (exceções verificadas), runtime exceptions (exceções de tempo de execução) e errors (erros) possuem diferenças importantes e devem ser entendidas perfeitamente para tirarmos maior proveito da plataforma Java. Entre as checked exceptions podemos citar FileNotFoundException, ClassNotFoundException e IOException. Agora veja: problemas tais como um arquivo não encontrado, uma classe não encontrada ou problemas com entrada e saída (talvez a impressora parou de responder ou a rede caiu) fogem completamente do domínio da aplicação. Tais exceções não são provocadas por código mal escrito ou mal testado. Desta forma, o Java força que todas as checked exceptions estejam em um bloco try...catch. Vamos ver se isso é verdade? Observe o trecho de código abaixo: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.io.*;
public class Estudos{
public static void main(String[] args){
DataInputStream in = new DataInputStream(
new BufferedInputStream(
new FileInputStream("conteudo.txt")));
while(in.available() != 0)
System.out.print((char) in.readByte());
System.exit(0);
}
}
Se tentarmos compilar este código teremos o seguinte resultado:
Estudos.java:7: unreported exception
java.io.FileNotFoundException; must be caught
or declared to be thrown
new FileInputStream("conteudo.txt")));
^
Estudos.java:9: unreported exception
java.io.IOException; must be caught or
declared to be thrown
while(in.available() != 0)
^
Estudos.java:10: unreported exception
java.io.IOException; must be caught or
declared to be thrown
System.out.print((char) in.readByte());
^
3 errors
Aqui nós temos uma exceção FileNotFoundException e duas exceções IOException. Vamos nos concentrar na exceção gerada pelo construtor da classe FileInputStream. Folheando a documentação do Java nós encontramos: public FileInputStream(String name) throws FileNotFoundException É aqui que as coisas começam a ficar interessantes. Todos os métodos Java que podem atirar exceções verificadas são marcados com throws e o tipo de exceção lançada. A palavra throws é usada para transferir a responsabilidade do tratamento do erro para o chamador de tais métodos. Outro exemplo é o método readByte() da classe DataInputStream: public final byte readByte() throws IOException Para corrigir as exceções acima, só precisamos usar um bloco try...catch. Veja: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.io.*;
public class Estudos{
public static void main(String[] args){
try{
DataInputStream in = new DataInputStream(
new BufferedInputStream(
new FileInputStream("conteudo.txt")));
while(in.available() != 0)
System.out.print((char) in.readByte());
}
catch(IOException e){
System.out.print(e.getMessage());
}
System.exit(0);
}
}
Exceções verificadas são todas aquelas que descendem de Exception mas não descendem de RuntimeException. As exceções de tempo de execução (runtime exceptions) são provocadas por código mal escrito ou mal testado, ou seja, são causadas por nós programadores. Entre estas exceções podemos citar ArithmeticException, IndexOutOfBoundsException e NoSuchElementException. De fato, um erro aritmético é responsabilidade do programador, pois cabe a este verificar se os valores estão dentro da faixa permitida por cada tipo de dados. Ao contrário das exceções verificadas, o compilador não força o uso do bloco try...catch para as runtime exceptions. De fato, isso é fácil de compreender, uma vez que tais exceções não deveriam jamais aparecer. Contudo, pode ser desejável usar o bloco try...catch em casos em que os valores de uma operação são definidos pelo usuário. Veja um exemplo: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.util.*;
public class Estudos{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("Informe um inteiro: ");
int valor = in.nextInt();
System.out.print("Informe outro inteiro: ");
int valor2 = in.nextInt();
System.out.println("O resultado é " +
valor / valor2);
}
}
Se executarmos este código e informarmos o valor 0 para o segundo inteiro, teremos a seguinte exceção: Informe um inteiro: 4 Informe outro inteiro: 0 Exception in thread "main" java.lang.ArithmeticException: / by zero at Estudos.main(Estudos.java:13) Uma forma de corrigir isso é testando os valores informados para verificar suas faixas ou lançar uma exceção. Veja como usamos esta última alternativa: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.util.*;
public class Estudos{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("Informe um inteiro: ");
int valor = in.nextInt();
System.out.print("Informe outro inteiro: ");
int valor2 = in.nextInt();
try{
System.out.println("O resultado é " +
valor / valor2);
}
catch(ArithmeticException e){
System.out.println("Uma exceção " +
"ArithmeticException ocorreu, " +
"possivelmente uma tentativa de " +
"divisão por zero.");
}
}
}
Agora se informarmos zero para o segundo inteiro, teremos: Informe um inteiro: 5 Informe outro inteiro: 0 Uma exceção ArithmeticException ocorreu, possivelmente uma tentativa de divisão por zero. As runtime exceptions (causadas por falha nossa, os programadores) descedem de java.lang.RuntimeException. Além das runtime exceptions e das checked exceptions, temos também os errors, que descedem de java.lang.Error e não devem jamais ser atirados ou tratados em blocos try...catch. Este tipo de erro é reservado para indicar problema na JVM. Entre tais erros temos OutOfMemoryError, que é lançado quando a Java Virtual Machine não consegue alocar um objeto porque sua fatia de memória esgotou e o Garbage Collector ainda não liberou mais memória. Não há razão para tratarmos isso em um bloco try...catch uma vez que, ao contrário de C++, a liberação de memória só é feita pelo GC. O melhor a fazer é deixar mesmo o programa ser encerrado e encontrar alternativas para a correção do problema. |
Java ::: Dicas & Truques ::: Expressões Regulares |
Como usar expressões regulares em Java - Expressões regulares para iniciantesQuantidade de visualizações: 48521 vezes |
|
O suporte a expressões regulares ou regex tem sido parte da plataforma Java desde a versão 1.4. Contidas no pacote java.util.regex, as classes regex suportam a comparação de padrões de forma similar à linguagem Perl, mas, usando classes e a sintáxe da linguagem Java. Todo o pacote se limita a três classes: Pattern, Matcher e PatternSyntaxException. A versão 1.5 introduziu a interface MatchResult. Use as duas classes Pattern e Matcher juntas. Defina e expressão regular com a classe Pattern. Então use a classe Matcher para verificar o padrão em relação à fonte de entrada. Uma exceção é lançada quando o padrão tem um erro de sintáxe na expressão. Estas classes não possuem construtores. Em vez disso, compilamos uma expressão regular para obter um padrão, e então usamos o Pattern retornado para obter seu Matcher baseado na fonte de entrada: Pattern pattern = Pattern.compile(<regular expression>); Matcher matcher = pattern.matcher(<input source>); Uma vez que tenhamos um Matcher, tipicamente processamos a fonte de entrada a fim de encontrarmos as similaridades contidas. Usa-se o método find() para localizar similaridades do padrão na fonte de entrada. Cada chamada a find() continua a partir do ponto onde a última chamada parou, ou na posição 0 para a primeira chamada. As similaridades encontradas são retornadas pelo método group(): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
while(matcher.find()){
System.out.printf"Found: \"%s\" from %d to %d.%n",
matcher.group(), matcher.start(), matcher.end());
}
O código a seguir mostra um programa básico de expressões regulares, que pede ao usuário que informe tanto a expressão regular quanto a string que será comparada: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.util.regex.*;
import java.io.*;
public class Regex{
public static void main(String args[]){
Console console = System.console();
// Obtém a expressão regular
String regex = console.readLine("%nInforme a expressão: ");
Pattern pattern = Pattern.compile(regex);
// Obtém a entrada
String source = console.readLine("Informe a entrada: ");
Matcher matcher = pattern.matcher(source);
// Mostra as similaridades
while(matcher.find()){
System.out.printf("Encontrado: \"%s\" de %d à %d.%n",
matcher.group(), matcher.start(), matcher.end());
}
}
}
Mas, o que realmente é uma expressão regular? A classe Pattern fornece detalhes mais profundos, mas, basicamente uma expressão regular é uma sequência de caracteres que tenta encontrar semelhanças em outra sequencia de caracteres. Por exemplo, podemos procurar o padrão literal de "eles" duplos "ll" na string "Hello, World". O programa anterior encontraria o padrão "ll" começando na posição 2 e terminando na posição 4. A posição final é a posição do próximo caractere depois do fim do padrão de semelhança. Strings de padrão como "ll" não são muito interessantes, relatando somente onde elas estão literalmente na fonte de entrada. Padrões de expressões regulares podem incluir meta-caracteres especiais. Meta-caracteres fornecem habilidades poderosas de comparação. É possível usar os 15 caracteres "([{\^-$|]})?*+." como meta-caracteres em expressões regulares. Alguns meta-caracteres indicam o agrupamento de caracteres. Por exemplo, os caracteres de colchetes [ e ] permitem especificar um grupo de caracteres nos quais uma similaridade ocorre se qualquer um dos caracteres entre colchetes for encontrado no texto. Por exemplo, o padrão "co[cl]a" retornará similaridade com "coca" e "cola". Ele não se igualará a "cocla", uma vez que [] é usado para igualar apenas um caractere. Veremos mais sobre quantificadores mais adiante, quando quisermos encontrar alguma coisa múltiplas vezes. Além de tentar encontrar caracteres individuais, podemos usar os colchetes [ e ] para igualar uma faixa de caracteres, tais como as letras de j-z, definidas como [j-z]. Isso pode também ser combinado com um literal string, como em "foo[j-z]" que encontraria "fool", mas não encontraria "food", uma vez que l está na faixa de j à z e d não está. Podemos também usar o caractere ^ para representar negação, com um literal string ou uma faixa. O padrão "foo[^j-z]" encontrará palavras que começam como foo mas que não terminem com uma letra de j à z. Assim a string food agora seria encontrada. Faixas múltiplas podem ser combinadas como em [a-zA-Z] para informar as letras de a à z maiúsculas ou minúsculas. Enquanto literais strings são ótimos como primeira lição sobre expressões regulares, as coisas mais típicas que a maioria das pessoas usam em expressões regulares são as classes de caracteres pré-definidos. É aqui que os meta-caracteres . e \ são importantes. O ponto . é usado para representar qualquer caractere. Assim, a expressão regular ".oney" encontraria money e honey, e qualquer outro conjunto de 5 caracteres que terminem em oney. O caractere \ por sua vez, é usado com outros caracteres para representar um conjunto completo de letras. Por exemplo, enquanto podemos usar [0-9] para representar um conjunto de dígitos, podemos também usar \d. Podemos ainda usar [^0-9] para representar um conjunto de caracteres que não sejam dígitos. Ou podemos usar o caractere \D. Todas estas strings de classes de caracteres são definidas na documentação da plataforma Java para a classe Pattern, uma vez que elas não são fáceis de serem lembradas. Eis aqui um sub-conjunto de algumas classes de caracteres pré-definidos especiais:
* \s -- whitespace (espaço em branco)
* \S -- non-whitespace (não seja espaço em branco)
* \w -- word character [a-zA-Z0-9] (caractere de palavra)
* \W -- non-word character (não caractere de palavra)
* \p{Punct} -- punctuation (pontuação)
* \p{Lower} -- lowercase [a-z] (minúsculas)
* \p{Upper} -- uppercase [A-Z] (maiúsculas)
Se você quiser usar uma destas strings no programa Regex mostrado acima, você as define como mostrado. \s se iguala ao espaço em branco. Se, contudo, você quiser definir a expressão regular via código, você precisa se lembrar que o caractere \ tem tratamento especial. Devemos escapar a string no código fonte: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- String regexString = "\\s"; Aqui, os caracteres \\ representam uma única barra invertida na string. Há outras strings especiais para representar literais strings: * \t -- tab (tabulação) * \n -- newline (nova linha) * \r -- carriage return (retorno de carro) * \xhh -- hex character 0xhh (caractere hexadecimal) * \uhhhh -- hex character 0xhhhh (caractere hexadecimal) Os quantificadores tornam as expressões regulares mais interessantes, pelo menos quando combinados com outras expresssões tais como classes de caracteres. Por exemplo, se quisermos encontrar uma string de três caracteres de a-z, poderíamos usar o padrão "[a-z][a-z][a-z]". Mas não precisamos fazer isso. Em vez de repetir a string, adicionamos um quantificador após o padrão. Para este exemplo específico, "[a-z][a-z][a-z]" pode ser representado como "[a-z]{3}". Para uma quantidade específica, o número vai dentro das chaves {}. Podemos também usar ?, * ou + para representar zero ou uma vez, zero ou mais vezes, ou uma ou mais vezes, respectivamente. O padrão [a-z]? encontra um caractere de a-z zero ou uma vez. O padrão [a-z]* encontra um caractere de a-z zero ou mais vezes. O padrão [a-z]+ encontra um caractere de a-z uma ou mais vezes. Use quantificador com cuidado, prestando muita atenção aos quantificadores que permitem zero similaridades. Quando usamos as chaves {} como quantificadores, devemos definir uma faixa. {3} significa exatamente 3 vezes, mas poderíamos dizer {3,}, que define no mínimo três vezes. O quantificador {3,5} encontra um padrão de 3 a 5 vezes. Há mais sobre expressões regulares que o que mostramos aqui. A arte de usá-las envolve descobrir a expressão regular correta para a situação atual. Tente diferente expressões com o programa Regex e veja se ele encontra o que você está esperando. Certifique-se de tentar diferentes quantificadores para entender realmente suas diferenças. Observe que quantificadores geralmente tentam incluir o maior número de caracteres para uma similaridade possível. |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
 Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesTenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
|
1º lugar: Java |
