AdrianoSiqueira

Tenta formatar ele.

Pois é, a exceção não é essa (foi mal). Veja na documentação oficial, quando o arquivo não for encontrado, ele lança IllegalArgumentException, então essa é a exceção que você precisa pegar.

Seu código tem uma série de erros, você tentou "traduzir" ele de alguma outra linguagem? Aplicada as correções de sintaxe, ele ficou assim:
 

Tentou assim?
textField.setText(String.valueOf(123)); Isso deve converter o 123 para "123" e setar no campo.
 
PS.: Troque textField pela sua variável de campo de texto e 123 pela sua variável numérica.
 
Se preferir, poste seu código fonte e a gente analisa para ver se tem algum problema.

Uma variante poderia ser feita assim:
tentativas = 3 aprovado = False while not aprovado and tentativas > 0: senha = input("Digite a senha: ") confirmacao = input("Confirme a senha: ") if senha == confirmacao: aprovado = True else: tentativas -= 1 if tentativas > 0: print("Bem vindo") else: print("Acesso negado")  

private void comparar(Cili c1, Cili c2) { if (c1.getVolume() > c2.getVolume()) { System.out.println("C1 é maior."); } else if (c2.getVolume() > c1.getVolume()) { System.out.println("C2 é maior."); } else { System.out.println("São do mesmo tamanho."); } }  

Não daria, pois a ROM não iria funcionar em outro celular que não aquele para o qual foi desenvolvido.

Segue um exemplo de como fazer:
package acharespaco; public class AcharEspaco { private static class Coordenada { public final int linha; public final int coluna; public Coordenada(int linha, int coluna) { this.linha = linha; this.coluna = coluna; } } public static void main(String[] args) { final char pt = '.'; char[][] matriz = new char[][]{ {pt, pt, pt}, {pt, pt, pt}, {pt, pt, pt} }; Coordenada coordenada; while ((coordenada = procurar(matriz, pt)) != null) { System.out.println("Encontrou [" + coordenada.linha + ", " + coordenada.coluna + "]"); } System.out.println("Acabaram os espaços livres."); } /** * Procura uma ocorrência de flag. * * @param matriz Onde deve ser procurado. * @param flag O que deve ser procurado. * * @return Instância de Coordenada contendo a posição de linha e coluna. Se não houver nenhuma ocorrência, é retornado null. */ private static Coordenada procurar(char[][] matriz, char flag) { Coordenada coordenada = null; boolean encontrou = false; for (int i = 0; i < matriz.length && !encontrou; i++) { for (int j = 0; j < matriz.length && !encontrou; j++) { if (matriz[i][j] == flag) { coordenada = new Coordenada(i, j); encontrou = true; matriz[i][j] = '-'; } } } return coordenada; } }  

Na questão do triângulo, pegue um número do usuário e rode um for dentro de outro for, imprimindo os caracteres. Use uma variável qualquer para servir de switch, e escolha o carácter baseado no valor dessa variável. Lembre-se, são apenas duas letras possíveis, logo a variável só pode alternar entre dois valores (0 e 1, por exemplo).
 
Na questão do Fibonacci, você implementa o algoritmo do Fibonacci, mas antes de iniciar os cálculos, pede dois números para o usuário, aí inicia os cálculos com esses valores.

Não entendi direito o que esse programa deve fazer, mas baseado no seu código, acho que você precisa de algo assim:
public static void main(String[] args) { Scanner scanner = new Scanner(System.in); final double aceleracao = 9.81; // Constante double velocidadeInicial; double angulo; // 2 * velocidadeInicial * cos(angulo) * sen(angulo) / aceleracao double alcanceHorizontal; // 2 * velocidadeInicial * sen(angulo) / aceleracao double tempoTrajeto; // velocidadeInicial * sen(angulo) / (2 * aceleracao) double alturaMaxima; // ----- Entrada de dados do { System.out.print("Velocidade inicial: "); velocidadeInicial = scanner.nextDouble(); scanner.nextLine(); } while (velocidadeInicial < 0); do { System.out.print("Ângulo [ 1 - 89 ]: "); angulo = scanner.nextDouble(); scanner.nextLine(); } while (angulo <= 0 || angulo >= 90); // ----- Entrada de dados // Converte graus para radianos angulo = Math.toRadians(angulo); // ----- Realiza os cálculos alcanceHorizontal = 2 * velocidadeInicial * Math.cos(angulo) * Math.sin(angulo) / aceleracao; tempoTrajeto = 2 * velocidadeInicial * Math.sin(angulo) / aceleracao; alturaMaxima = velocidadeInicial * Math.sin(angulo) / (2 * aceleracao); // ----- Realiza os cálculos // ----- Relatório System.out.println("alcanceHorizontal = " + alcanceHorizontal); System.out.println("tempoTrajeto = " + tempoTrajeto); System.out.println("alturaMaxima = " + alturaMaxima); // ----- Relatório }  
adicionado 5 minutos depois Dica: Procure sempre dar nomes mais significativos para suas variáveis, isso ajuda muito no entendimento do código. Além disso dê um pouquinho mais de atenção à indentação do código, um código bem organizado, além de bonito, ajuda a se localizar e a localizar erros que no meio da bagunça passam despercebidos 😉.

Comece disso e pense em como continuar:
double salarioClarisbela = 1500.0; double salarioFlorentina = salarioClarisbela / 3; double rendimentoClarisbela = 0.02; double rendimentoFlorentina = 0.05; double valorFinalClarisbela = salarioClarisbela; double valorFinalFlorentina = salarioFlorentina; int quantidadeMeses = 0;  

Parece que o Kali Linux não tem nenhum JDK nos repostórios, por isso você não consegue chamar o Javac.
Se você realmente quiser usar o Kali, vai ter que instalar o JDK da Oracle.

Dê uma olhada no exemplo desse link no Stack Overflow. Aparentemente é possível definir o tamanho da janela com as mesmas dimensões do painel e vice-versa.
Não mexo com swing faz tempo, por isso não tenho certeza de como fazer isso.

Segue um exemplo funcional feito com Swing:
import javax.swing.JFrame; import javax.swing.JLabel; import java.awt.Point; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseMotionAdapter; public class Janela extends JFrame { private Point initialClick; public Janela() { configurar(); } public static void main(String[] args) { new Janela(); } private void configurar() { this.addMouseListener(new MouseAdapter() { @Override public void mousePressed(MouseEvent e) { initialClick = e.getPoint(); getComponentAt(initialClick); } }); this.addMouseMotionListener(new MouseMotionAdapter() { @Override public void mouseDragged(MouseEvent e) { int thisX = getLocation().x; int thisY = getLocation().y; int xMoved = e.getX() - initialClick.x; int yMoved = e.getY() - initialClick.y; int X = thisX + xMoved; int Y = thisY + yMoved; setLocation(X, Y); } }); this.setTitle("Janela de Teste"); this.getContentPane().add(new JLabel("Conteúdo da sua janela")); this.setDefaultCloseOperation(EXIT_ON_CLOSE); this.pack(); this.setLocationRelativeTo(null); this.setVisible(true); } }  

Poderia ser assim:
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <limits.h> #include <time.h> bool presente(int vetor[], int tamanho, int valor) { for (int i = 0; i < tamanho; ++i) { if (vetor[i] == valor) { return true; } } return false; } void imprimeArray(char nome[], int vetor[], int tamanho) { printf("%s [ ", nome); for (int i = 0; i < tamanho; ++i) { printf("%i, ", vetor[i]); } printf("] \n"); } int main() { int maximo = 20; // Tamanho dos vetores int insercao = 0; // Posição de inserção no vetor único int vetor[maximo]; // Vetor com as informações int vetorUnico[maximo]; // Vetor com os valores únicos srand((unsigned) time(NULL)); // Inicializa o primeiro vetor for (int i = 0; i < maximo; ++i) { vetor[i] = rand() % 30 + 1; } // Inicializa o vetor único com valores que serão sobrescritos for (int i = 0; i < maximo; ++i) { vetorUnico[i] = INT_MIN; } // Preenche o vetor único com os valores do primeiro vetor for (int i = 0; i < maximo; ++i) { if (!presente(vetorUnico, maximo, vetor[i])) { vetorUnico[insercao] = vetor[i]; insercao += 1; } } // Imprime tudo imprimeArray("Vetor", vetor, maximo); imprimeArray("Unico", vetorUnico, insercao); return 0; } Obs.: Perceba que na segunda chamada da função imprimeArray, eu passei o valor de insercao ao invés do tamanho máximo, isso porque não sabemos se o vetorUnico foi totalmente preenchido e para evitar que seja impresso lixo de memória, passamos o valor da última posição que foi inserido algum valor.

Algo assim deve resolver:
#include <stdio.h> #include <stdlib.h> #include <time.h> void imprimirArray(char nome[], int array[], int maximo) { printf("%s [ ", nome); for (int i = 0; i < maximo; ++i) { printf("%i, ", array[i]); } printf("] \n"); } int main() { int maximo = 300; int vetor[maximo]; int vetorSoma[maximo - 1]; srand((unsigned) time(NULL)); // Inicializa o primeiro vetor for (int i = 0; i < maximo; ++i) { vetor[i] = rand() % 400 + 100; } // Preenche o segundo vetor for (int i = 0; i < maximo - 1; ++i) { vetorSoma[i] = vetor[i] + vetor[i + 1]; } // Imprime todos imprimirArray("Vetor", vetor, maximo); imprimirArray(" Soma", vetorSoma, maximo - 1); return 0; } Dica: Não crie um vetor de 300 posições logo de cara, faça algo menor, por exemplo com 10 posições. E ao invés de já preencher com valores aleatórios, preencha-o com valores fixos, assim fica mais fácil detectar problemas. Quando você ver que está tudo certo, aí você muda o tamanho e os valores que serão atribuídos.

Você só precisa criar um ponteiro para a sua variável aluno, depois você passa o ponteiro para as funções.
#include <stdio.h> #include <stdlib.h> struct tipoAluno { int mat; char nome[31]; float media; }; void escreveAluno(struct tipoAluno *aluno) { printf("Matricula: %i \n", aluno->mat); printf(" Nome: %s \n", aluno->nome); printf(" Media: %.2f \n", aluno->media); } void lerAluno(struct tipoAluno *aluno) { printf("Matricula do aluno: "); scanf(" %i", &aluno->mat ); printf("Nome do aluno: "); scanf(" %[^\n]", aluno->nome); printf("Media do aluno: "); scanf(" %f", &aluno->media); } int main(void) { struct tipoAluno aluno; struct tipoAluno *ponteiroAluno = &aluno; lerAluno(ponteiroAluno); escreveAluno(ponteiroAluno); return 0; }  

Tenta dessa forma:
#include <stdio.h> #include <stdlib.h> #include <time.h> int main() { const int tamanho = 10; int vetor[tamanho]; int vetorPares[tamanho]; int vetorImpares[tamanho]; int pares = 0; int impares = 0; srand(time(NULL)); for (int i = 0; i < tamanho; ++i) { vetor[i] = rand() % 100; if (vetor[i] % 2 == 0) { vetorPares[pares] = vetor[i]; pares += 1; } else { vetorImpares[impares] = vetor[i]; impares += 1; } } printf("Vetor {"); for (int i = 0; i < tamanho; ++i) { printf("%i ", vetor[i]); } printf("} \n"); printf("Vetor P {"); for (int i = 0; i < pares; ++i) { printf("%i ", vetorPares[i]); } printf("} \n"); printf("Vetor I {"); for (int i = 0; i < impares; ++i) { printf("%i ", vetorImpares[i]); } printf("} \n"); return 0; }  

@gramosiri Rapaz, que trabalho! Mas parece que deu certo. Testa aí com o máximo de valores ímpares possíveis e veja se está tudo certo:
#include <stdio.h> #include <stdlib.h> int main() { int nota_2 = 0; int nota_5 = 0; int nota_10 = 0; int nota_20 = 0; int nota_50 = 0; int nota_100 = 0; int valor = 21; // Pode receber do usuário int valorCalculado = valor; // É usado para determinar a quantidade de notas de 2 e 5 sem perder o valor original // Se o valor for ímpar, então começa a contar da nota de 5. if (valor % 2 != 0) { if (valor < 5) { printf("Não é possível calcular esse valor."); return 1; } else if (valor % 5 == 0) { // Se o valor for múltiplo de cinco, então apenas notas de 5 já resolvem. while (valorCalculado > 0) { ++nota_5; valorCalculado -= 5; } } else { /* * Se for ímpar, precisamos tirar notas de 5 até que ele se torne par, * depois as notas de 2 resolvem o resto. * * O -2 da primeira condição verifica se, reservando uma nota de 2, * ainda tem a possibilidade de remover alguma nota de 5. * * Já a segunda condição verifica se reservando uma nota de 2, o valor * resultante é ímpar. Porque se não for, as notas de 2 resolvem. */ while ((valorCalculado - 2) >= 5 && (valorCalculado - 2) % 2 != 0) { ++nota_5; valorCalculado -= 5; } } } /* * Se o valor for par, ele será totalmente calculado com notas de 2 e * posteriormente, se houver a possibilidade, essas notas serão trocadas * por notas mais altas. */ while (valorCalculado >= 2) { ++nota_2; valorCalculado -= 2; } /* * A partir daqui começa o processo de troca das notas por notas mais altas. * A cada cinco notas de 2 trocamos por uma nota de 10. */ while (nota_2 >= 5) { nota_2 -= 5; ++nota_10; } // A cada duas notas de 5 trocamos por uma de 10. while (nota_5 >= 2) { nota_5 -= 2; ++nota_10; } // A cada duas notas de 10 trocamos por uma de 20. while (nota_10 >= 2) { nota_10 -= 2; ++nota_20; } // A cada duas notas de 20 com uma nota de 10 trocamos por uma de 50. while (nota_20 >= 2 && nota_10 >= 1) { nota_20 -= 2; nota_10 -= 1; ++nota_50; } // A cada cinco notas de 20 trocamos por uma de 100. while (nota_20 >= 5) { nota_20 -= 5; ++nota_100; } // A cada duas notas de 50 trocamos por uma de 100. while (nota_50 >= 2) { nota_50 -= 2; ++nota_100; } printf("Valor: R$ %i \n", valor); printf("%i de R$ 2 (= R$ %i) \n", nota_2, (nota_2 * 2)); printf("%i de R$ 5 (= R$ %i) \n", nota_5, (nota_5 * 5)); printf("%i de R$ 10 (= R$ %i) \n", nota_10, (nota_10 * 10)); printf("%i de R$ 20 (= R$ %i) \n", nota_20, (nota_20 * 20)); printf("%i de R$ 50 (= R$ %i) \n", nota_50, (nota_50 * 50)); printf("%i de R$ 100 (= R$ %i) \n", nota_100, (nota_100 * 100)); return 0; }  

Seria algo assim?
System.out.print("Quantidade de pessoas: "); int quantidade = scanner.nextInt(); // Instancia o vetor com o tamanho que o usuário escolher Pessoa11 pessoas[] = new Pessoa11[quantidade]; // Instancia cada um dos elementos do vetor for(int i = 0; i < pessoas.length; ++i) { pessoas[i] = new Pessoa11(); } Nesse caso o vetor teria o tamanho que o usuário escolher, e com todos os elementos devidamente instanciados.

Explicando o try-catch-finally:
try { /* Tenta realizar alguma tarefa. */ } catch () { /* Se o bloco try falhar, esse será executado. */ } finally { /* Esse bloco executará independente de ter dado problema ou não. */ } Agora sobre sua lógica para determinar se é número ou não, poderia ser feito assim:
public static boolean validaInteiro(String numeroString) { try { Integer.parseInt(numeroString); /* A linha acima tenta converter a String para int. * Se der certo, significa que a sua String é um número inteiro válido * e a execução passa para a próxima linha. * Se a conversão falhar, significa que a String não é um número válido, * nesse caso a execução para aqui e o bloco catch é executado. */ return true; // Essa linha só é alcançada se a conversão der CERTO. } catch (NumberFormatException e) { return false; // Essa linha só é alcançada se a conversão FALHAR. } } Para validar double:
public static boolean validaDouble(String numeroString){ try { Double.parseDouble(numeroString); return true; } catch (NumberFormatException e) { return false; } }  

@giu_d Pois é, tudo funciona, menos a largura mínima e máxima 🙄. Estou quase para deixar isso pra lá 😑.