 |
|
||||
Você está aqui: Java ::: Dicas & Truques ::: Threads |
Aprenda a usar o método sleep() da classe ThreadQuantidade de visualizações: 18517 vezes |
A classe Thread possui um método estático sleep() que nos permite pausar a execução da thread atual durante um determinado número de milisegundos. Veja a assinatura deste método: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- public static void sleep(long millis) throws InterruptedException Quando chamamos sleep(), a thread atual abandonará a CPA e irá para o estado "dormindo". Quando a quantidade de milisegundos transcorrer, a thread será movida para o estado "pronta" e será executada novamente tão logo o gerenciador de threads o permita. Veja um exemplo no qual temos duas threads. Note a chamada ao método sleep() da primeira thread(): ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// criamos uma classe que servirá como thread
class MinhaThread implements Runnable{
private String nome;
public MinhaThread(String nome){
this.nome = nome;
}
public void run(){
for(int i = 1; i <= 20; i++){
System.out.println(nome + ": " + i);
if((i == 6) && (nome.equals("Thread 1"))){
try{
System.out.println(nome + " foi dormir um pouco");
Thread.sleep(5000); // 5 segundos
}
catch(InterruptedException e){
System.out.println(e.getMessage());
}
}
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread mt1 = new MinhaThread("Thread 1");
Thread t1 = new Thread(mt1);
t1.start();
MinhaThread mt2 = new MinhaThread("Thread 2");
Thread t2 = new Thread(mt2);
t2.start();
}
}
Execute este código e perceberá que a primeira thread conta até 6 e vai "dormir". Quando este tempo é decorrido ela volta e finaliza seu trabalho. Uma detalhe importante é que a thread principal (aquela do método main()) fica aguardando a thread acordar. Este comportamento é alterado se colocarmos: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- System.exit(0); como última instrução no método main(). Note que não temos controle sobre quando tempo a CPU reserva para cada thread. Assim, é possível que as instruções: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- System.out.println(nome + " foi dormir um pouco"); Thread.sleep(5000); // 5 segundos não sejam executadas consecutivamente. Por ser que a thread 1 escreva que vai dormir, a thread 2 ganhe a CPU, seja executada e então somente quando a thread 1 retornar ela irá de fato dormir. |
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Escreva um programa em Java que usa a função log10() para informar a quantidade de dígitos em um número inteiroQuantidade de visualizações: 702 vezes |
|
Pergunta/Tarefa: Escreva um algorítmo em Java que peça para o usuário informar um número inteiro de qualquer tamanho, ou seja, qualquer quantidade de dígitos. Em seguida seu código deverá informar a quantidade de dígitos contida no número inteiro digitado pelo usuário. Seu programa deverá, obrigatoriamente, usar a função log10() da classe Math. Sua saída deverá ser parecida com: Informe um número inteiro de qualquer tamanho: 847 O número informado possui 3 dígitos Veja a resolução comentada deste exercício usando Java console: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package exercicio;
import java.util.Scanner;
public class Exercicio {
public static void main(String[] args) {
// vamos fazer a leitura usando a classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos pedir para o usuário informar um número inteiro
System.out.print("Informe um número inteiro de qualquer tamanho: ");
int numero = Integer.parseInt(entrada.nextLine());
// agora vamos obter a quantidade de dígitos no
// número informado
int tamanho = ((int) Math.log10(numero)) + 1;
// mostramos o resultado
System.out.println("O número informado possui " + tamanho +
" dígitos");
}
}
|
Java ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como calcular o cateto adjascente dadas as medidas da hipotenusa e do cateto oposto em JavaQuantidade de visualizações: 1385 vezes |
|
Nesta dica mostrarei como podemos tirar proveito do Teorema de Pitágoras para obter a medida do cateto adjascente quando temos as medidas da hipotenusa e do cateto oposto. Este teorema diz que "o quadrado da hipotenusa é igual à soma dos quadrados dos catetos", o que torna a nossa tarefa, na linguagem Java, muito fácil. Comece observando a imagem a seguir:  Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados. A medida da hipotenusa é, sem arredondamentos, 36.056 metros. Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras): \[c^2 = a^2 + b^2\] Tudo que temos que fazer é mudar a fórmula para: \[b^2 = c^2 - a^2\] Veja que agora o quadrado do cateto adjascente é igual ao quadrado da hipotenusa menos o quadrado do cateto oposto. Não se esqueça de que a hipotenusa é o maior lado do triângulo retângulo. Veja agora como esse cálculo é feito em linguagem Java: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package arquivodecodigos;
public class Estudos{
public static void main(String args[]){
double c = 36.056; // medida da hipotenusa
double a = 20; // medida do cateto oposto
// agora vamos calcular a medida da cateto adjascente
double b = Math.sqrt(Math.pow(c, 2) - Math.pow(a, 2));
// e mostramos o resultado
System.out.println("A medida do cateto adjascente é: " +
b);
}
}
Ao executar este código Java nós teremos o seguinte resultado: A medida do cateto adjascente é: 30.00058559428465 Como podemos ver, o resultado retornado com o código Java confere com os valores da imagem apresentada. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes) |
Exercício Resolvido de Java - Como rotacionar os elementos de um vetor de inteiros n vezes para a direita - Solução usando força-brutaQuantidade de visualizações: 566 vezes |
|
Pergunta/Tarefa: Dado o vetor:
// vamos criar um vetor de inteiros
int valores[] = {1, 6, 9, 3, 7, 8, 5, 2};
Sua saída deverá ser parecida com: Array na ordem original: 1 6 9 3 7 8 5 2 Rotação do vetor depois do passo 1: 2 1 6 9 3 7 8 5 Rotação do vetor depois do passo 2: 5 2 1 6 9 3 7 8 Rotação do vetor depois do passo 3: 8 5 2 1 6 9 3 7 Array depois de rotacionar 3 vezes: 8 5 2 1 6 9 3 7 Veja a resolução comentada deste exercício em Java: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package estudos;
public class Estudos {
public static void main(String[] args) {
// vamos criar um vetor de inteiros
int valores[] = {1, 6, 9, 3, 7, 8, 5, 2};
// mostramos o array na ordem original
System.out.println("Array na ordem original:");
exibirVetor(valores);
// vamos rotacionar o array 3 casas para a direita
valores = rotacionarArray(valores, 3);
// e mostramos o resultado
System.out.println("Array depois de rotacionar 3 vezes:");
exibirVetor(valores);
}
// método usado para exibir o array
public static void exibirVetor(int []vetor){
// percorremos cada elemento do vetor
for (int i = 0; i < vetor.length; i++) {
System.out.print(vetor[i] + " ");
}
System.out.println("\n");
}
// método que recebe um vetor de inteiros e o rotaciona um
// determinado número de vezes
public static int[] rotacionarArray(int[] vetor, int n) {
// um laço externo que repete a mesma quantidade de n
for (int i = 0; i < n; i++) {
// começamos no último elemento e regredimos até
// o segundo elemento do vetor
for (int j = vetor.length - 1; j > 0; j--) {
// avançamos um elemento de cada vez para
// a direita
int temp = vetor[j];
vetor[j] = vetor[j - 1];
vetor[j - 1] = temp;
}
// mostramos o progresso
System.out.println("Rotação do vetor depois do passo " + (i + 1) + ":");
exibirVetor(vetor);
}
return vetor;
}
}
A solução que apresentamos aqui usa a força-bruta, isto é, uma solução não otimizada e pouco recomendada para arrays com um número exagerado de elementos. Por ser força-bruta, o laço interno percorre todos os elementos do vetor, trocando-os de lugares. Em outras dicas do site nós colocamos versões melhoradas deste código. |
Java ::: Fundamentos da Linguagem ::: Estruturas de Controle |
Tutorial Java para iniciantes - Como usar o laço for em JavaQuantidade de visualizações: 21257 vezes |
O laço for (loop for, ou laço para) é de longe uma das estruturas de controle mais usadas, não só em Java como em várias linguagens de programação). A razão de seu sucesso é a facilidade com que podemos efetuar iterações controladas por um contador ou uma variável similar, que é atualizada a cada iteração. Veja sua sintáxe:
for(passo 1; passo 2; passo 3){
// bloco de instruções
}
passo 1: É aqui que definimos a variável de controle. Esta variável pode também ser declarada antes do laço, mas nunca em seu corpo. passo 2: Aqui testamos a condição de continuidade do laço. Se a condição retornar verdadeira, a execução do laço continua. Do contrário esta é interrompida. passo 2: Nesta parte nós incrementamos ou decrementamos a variável de controle. É importante perceber que podemos ter mais de uma instruções nos passos 1 e 3 de uma laço for, basta separá-las por vírgulas. Veja um exemplo no qual usamos um laço for para imprimir os números de 0 a 10: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public class Estudos{
public static void main(String[] args){
for(int i = 0; i <= 10; i++){
System.out.println(i);
}
}
}
Veja agora como efetuar a operação inversa, ou seja, imprimir os números em ordem decrescente: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public class Estudos{
public static void main(String[] args) {
for(int i = 10; i >= 0; i--){
System.out.println(i);
}
}
}
Para finalizar veja como podemos imprimir os números pares de 0 a 10: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public class Estudos{
public static void main(String[] args) {
for(int i = 0; i <= 10; i += 2){
System.out.println(i);
}
}
}
|
Java ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como usar o modificador de acesso private em Java - Apostila Java para iniciantes - Programação Orientada a Objetos em JavaQuantidade de visualizações: 10307 vezes |
Um método ou variável declarada com o modificador de acesso private (privado) pode ser acessado somente por uma instância da classe que declara o método ou variável. Veja um exemplo:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// Classe Cliente
class Cliente{
private String nome = "Osmar";
}
// Classe de teste
public class Estudos{
public static void main(String args[]){
Cliente cliente = new Cliente();
System.out.println(cliente.nome);
System.exit(0);
}
}
Ao tentarmos compilar este código teremos a seguinte mensagem de erro: Estudos.java:10: nome has private access in Cliente System.out.println(cliente.nome); O erro já era esperado, pois sabemos que a classe Estudos não tem acesso aos membros privados da classe Cliente. Experimente alterar o modificador private por public e veja o resultado: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- public String nome = "Osmar"; É importante observar que, se duas instâncias de uma classe forem criadas, uma terá acesso aos dados privados da outra, ou seja, o modificador private define quais classes (não instâncias) podem acessar determinado recurso. Além disso, saiba que classes de nível superior (Top-level) não podem ser declaradas como private. Elas podem ser no máximo de acesso de pacote (nenhum modificador). A mesma regra se aplica a interfaces. No entanto, classes e interfaces internas podem ser declaradas com o modificador private. Para finalizar, lembre-se de que sub-classes não possuem acesso à membros privados da superclasse. |
Java ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como criar e usar métodos estáticos em suas classes Java - Programação Orientada a Objetos em Java - Java OOPQuantidade de visualizações: 13483 vezes |
Como já vimos em outras dicas desta seção, uma classe Java possui propriedades (variáveis) e métodos (funções). Veja a seguinte declaração de uma classe Produto:----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package estudos;
// declaração da classe Produto
public class Produto {
private String nome;
private double preco;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public double getPreco() {
return preco;
}
public void setPreco(double preco) {
this.preco = preco;
}
}
Aqui cada instância da classe Produto terá suas próprias variáveis nome e preco e os métodos que permitem acesso e alteração destas variáveis também estão disponíveis a cada instância. Há, porém, situações nas quais gostaríamos que um determinado método estivesse atrelado à classe e não à cada instância individual. Desta forma, é possível chamar um método de uma classe sem a necessidade da criação de instâncias da mesma. O método main() presente em todas as aplicações Java é um bom exemplo deste tipo de método. Métodos estáticos em Java podem ser criados por meio do uso da palavra-chave static. É comum tais métodos serem declarados com o modificador public, o que os torna acessíveis fora da classe na qual estes foram declarados. Veja um exemplo: Código para Pessoa.java: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package estudos;
// classe Pessoa com duas variáveis privadas e
// um método estático
public class Pessoa {
private String nome;
private int idade;
// um método estático que permite verificar a validade
// de um número de CPF
public static boolean isCPFValido(String cpf){
// alguns cálculos aqui
return true;
}
}
Veja agora como podemos chamar o método isCPFValido() sem a necessidade da criação de uma nova instância da classe Pessoa: Código para Main.java: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package estudos;
public class Main {
public static void main(String[] args) {
// vamos efetuar uma chamada ao método isCPFValido() sem
// criar uma instância da classe Pessoa
if(Pessoa.isCPFValido("12345")){
System.out.println("CPF Válido");
}
else{
System.out.println("CPF Inválido");
}
}
}
Note que o método estático isCPFValido() da classe Pessoa foi declarado assim: public static boolean isCPFValido(String cpf); Desta forma, podemos chamá-lo a partir de código externo à classe sem a necessidade de criar uma nova instância da mesma. Veja: if(Pessoa.isCPFValido("12345")){} É importante notar que métodos estáticos não possuem acesso a variáveis e métodos não estáticos da classe, tampouco ao ponteiro this (que só existe quando criamos instâncias da classe). Assim, o trecho de código abaixo: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// um método estático que permite verificar a validade
// de um número de CPF
public static boolean isCPFValido(String cpf){
// alguns cálculos aqui
// vamos acessar a variável não estática nome
nome = "Osmar J. Silva";
return true;
}
vai gerar o seguinte erro de compilação: Uncompilable source code - non-static variable nome cannot be referenced from a static context. Se usarmos this.nome a mensagem de erro de compilação será: Uncompilable source code - non-static variable this cannot be referenced from a static context. Métodos estáticos são úteis quando precisamos criar classes que atuarão como suporte, nas quais poderemos chamar funções (métodos) auxiliares sem a necessidade de criar novas instâncias a cada vez que estas funções forem necessárias. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes) |
Exercícios Resolvidos de Java - Escreva um programa Java para mover todos os zeros para o final do vetor, sem alterar a ordem dos elementos já presentes no arrayQuantidade de visualizações: 624 vezes |
|
Pergunta/Tarefa: Dado o seguinte vetor de inteiros:
// vamos declarar e construir um vetor de 8 inteiros
int valores[] = {0, 3, 0, 5, 7, 4, 0, 9};
Sua saída deverá ser parecida com: Vetor na ordem original: 0 3 0 5 7 4 0 9 Vetor com os zeros deslocados para o final: 3 5 7 4 9 0 0 0 Veja a resolução comentada deste exercício usando Java: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package exercicio;
public class Exercicio {
public static void main(String[] args) {
// vamos declarar e construir um vetor de 8 inteiros
int valores[] = {0, 3, 0, 5, 7, 4, 0, 9};
// vamos mostrar o vetor na ordem original
System.out.println("Vetor na ordem original:\n");
for(int i = 0; i < valores.length; i++){
System.out.print(valores[i] + " ");
}
// vamos inicializar j como 0 para que ele aponte para
// o primeiro elemento do vetor
int j = 0;
// agora o laço for percorre todos os elementos do vetor,
// incrementanto a variável i e deixando o j em 0
for(int i = 0; i < valores.length; i++){
// encontramos um valor que não é 0
if(valores[i] != 0){
// fazemos a troca entre os elementos nos índices
// i e j
int temp = valores[i];
valores[i] = valores[j];
valores[j] = temp;
// e avançamos o j para o elemento seguinte
j++;
}
}
// agora mostramos o resultado
System.out.println("\n\nVetor com os zeros deslocados para o final:\n");
for(int i = 0; i < valores.length; i++){
System.out.print(valores[i] + " ");
}
System.out.println();
}
}
Não se esqueça: A resolução do exercício deve ser feita sem a criação de um vetor, array ou lista adicional, e os elementos diferentes de zero devem permanecer na mesma ordem que eles estavam antes. |
Java ::: Dicas & Truques ::: Formatação de datas, strings e números |
Java para iniciantes - Como controlar a quantidade de casas decimais na exibição de um valor double ou floatQuantidade de visualizações: 26627 vezes |
|
Este trecho de código mostra como usar o método printf() do Java 5.0 para definir a quantidade de casas decimais na exibição de um valor double. Obs: Veja que há arredondamento durante a redução das casas decimais. Eis o código completo para o exemplo: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package arquivodecodigos;
public class Estudos{
public static void main(String[] args){
double valor = 54.235344213;
// exibe o valor original
System.out.println(valor);
// exibe o valor com duas casas decimais
System.out.printf("%.2f\n", valor);
// exibe o valor com quatro casas decimais
System.out.printf("%.4f\n", valor);
// exibe o valor com cinco casas decimais
System.out.printf("%.5f\n", valor);
// exibe o valor com uma casa decimal
System.out.printf("%.1f", valor);
}
}
Ao executar este código Java nós teremos o seguinte resultado: 54.235344213 54,24 54,2353 54,23534 54,2 |
Vamos testar seus conhecimentos em |
| Segurança e Estados Limites Ações nas Estruturas de Concreto Armado O dimensionamento de elementos estruturais requer a utilização de combinações de cargas. Para a composição das combinações, as cargas são agrupadas a partir da sua natureza e ponderadas com coeficientes que irão considerar eventos como simultaneidade de ocorrência e probabilidade de ocorrência, por exemplo. Com relação aos tipos de carregamentos, assinale a afirmação correta. A) Os carregamentos especiais têm duração pequena em relação ao período de vida da construção e provêm de ações variáveis com intensidade e natureza especiais. B) Os carregamentos normais são transitórios, devendo sua duração ser definida de acordo com cada caso. C) Os carregamentos excepcionais têm longa duração em relação ao período de vida da construção e provêm de ações excepcionais. D) Quando provêm de ações durante a fase construção da edificação, considerados somente nos casos em que exista risco de ocorrência de algum estado limite, são classificados como carregamentos especiais. E) Os carregamentos excepcionais são considerados apenas nos ELS. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em AutoCAD Civil 3D |
| Conjuntos de Description Key no AutoCAD Civil 3D Quando estamos usando conjuntos de Description Key, qual parâmetro nos permite controlar automaticamente os parâmetros de alguns pontos? A) Location description (Descrição de localização) B) Marker style (Estilo de marcador) C) Raw description (Descrição crua) D) Full description (Descrição completa) Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
| Introdução à Ética Na modernidade, o conceito de ethos passa a refletir as transformações sociais, culturais e filosóficas desse período, profundamente influenciado pela dissolução do absolutismo e pelas revoluções liberais. A compreensão do ethos como caráter moral é então recontextualizada, influenciada pelas rupturas que reorganizam as sociedades. Considerando as transformações sociais, políticas e produtivas desse período, como o ethos se manifesta no contexto? Selecione a resposta: A) Inalterado, mantendo características morais tradicionais. B) Ênfase na tradição e conservadorismo com resistência às mudanças e rupturas. C) Rejeição total das normas coletivas e valorização do individualismo. D) Teoria filosófica sem conexões com as aplicações morais práticas. E) Reflete as transformações sociais, políticas, econômicas, culturais e/ou filosóficas. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em |
| Resistência do concreto Em uma edificação, foi executada a concretagem de um pavimento há exatamente duas semanas. Deseja-se determinar a resistência atingida pelo concreto até o momento, de maneira a verificar a possibilidade de retirada do escoramento para utilização em outro ponto da mesma obra. Para a elaboração deste concreto, foi utilizado um cimento CP II e, como critério de projeto, foi considerado um valor de resistência do concreto aos 28 dias igual a fck = 35 MPa. Com base na NBR 6118/2014 - Projeto de Estruturas de Concreto - Procedimento, determine o valor da resistência de cálculo (fcd) atingida até o momento. A) fcd = 17,5 MPa. B) fcd = 22,5 MPa. C) fcd = 25 MPa. D) fcd = 26,3 MPa. E) fcd = 35 MPa. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Engenharia Civil - Estruturas de Aço e Madeira |
| O aço no edifício A estrutura de estabilização da moldura estrutural da edificação da figura abaixo, que se caracteriza pelo fato de as extremidades das amarrações diagonais serem recuadas de uma certa distância uma da outra, onde se conectam às vigas, pode ser chamada de:  A) Estrutura contraventada. B) Moldura amarrada excentricamente. C) Moldura resistente a momentos. D) Paredes de cisalhamento. E) Nenhuma das alternativas anteriores. Verificar Resposta Estudar Cards Todas as Questões |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
