O while é uma das estruturas de repetição mais importantes no Java. No Java, também é similar ao PHP e outras linguagens.
public class While {
public static void main(String[] args) {
int num = 15;
int i = 0;
while (i < num) {
System.out.println("O valor de i é "+i);
i++;
}
}
}
O For serve para executar uma instrução em um intervalo pré-definido. No Java, é bem similar ao PHP e outras linguagens.
Exemplo:
public class ExFor {
public static void main(String[] args) {
int num = 20; // Numero de loops que o for vai dar
for (int i = 0;i<num;i++) {
System.out.println("O valor de i é "+i);
}
}
}
As pilhas são estruturas baseadas no princípio LIFO (last in, first out), na qual os dados que foram inseridos por último na pilha serão os primeiros a serem removidos. Existem duas funções que se aplicam a todas as pilhas: PUSH, que insere um dado no topo da pilha, e PULL, que remove o item no topo da pilha.
Neste artigo coloco um exemplo de aplicação de pilha. Trata-se de uma sacola de correspondências, onde deve se colocar um número limite para poder inserir, remover, retornar o ítem que está no topo etc. No exemplo utilizaremos o método POP, ao invés de PULL para remover um ítem do topo da pilha. Usaremos a biblioteca JOptionPane para ilustrar melhor o exemplo.
Você deve compilar o arquivo CartaApp para poder visualizar o exemplo funcionando.
Aqui vai a descrição do problema:
Faça um programa, em Java, que implemente as tarefas de um entregador de correspondências postais. Leve em consideração que as correspondências são empilhadas na sacola e devem ser entregues levando-se sempre em consideração a que encontra-se no topo. O programa deve permitir:
– Inserir correspondência na sacola (empilhar);
– Remover correspondência da sacola (desempilhar);
– Verificar se a sacola está cheia ou vazia;
– Verificar a próxima correspondência a ser entregue;
– Informar quantas correspondências existem na sacola.
A pilha deverá armazenar objetos com os dados de cada correspondência
Se preferir, baixe os arquivos aqui.
StackX.java
//StackX.java
/**
* Essa é a classe principal, onde temos todos os métodos para inserir,
* remover, retornar os dados etc.
*/
class StackX {
private int maxSize; // tamanho do array (vetor)
private Carta[] stackArray;
private int top; // topo da pilha
//--------------------------------------------------------------
public StackX(int s) // construtor
{
maxSize = s; // define tamanho do array
stackArray = new Carta[maxSize]; // cria array
top = -1; // sem itens
}
//--------------------------------------------------------------
public void push(Carta stackAux) // coloca no topo da pilha
{
stackArray[++top] = stackAux; // incrementa topo, insere item
}
//--------------------------------------------------------------
public Carta pop() // tira item do topo da pilha
{
return stackArray[top--]; // acessa o item, decrementa o topo
}
//--------------------------------------------------------------
public Carta peek() // retorna o item do topo da pilha
{
return stackArray[top];
}
//--------------------------------------------------------------
public boolean isEmpty() // retorna true se a pilha estiver vazia
{
return (top == -1);
}
//--------------------------------------------------------------
public boolean isFull() // retorna true se a pilha estiver cheia
{
return (top == maxSize-1);
}
public int getTop() {
return top;
}
}
Carta.java
//Carta.java
/**
* Nessa classe estão todos os atributos do objeto
*/
public class Carta {
private String nome; // nome do remetente
private String logra; // nome do logradouro
private int num; // numero do lugradourou
public Carta(String nome,String logra,int num) {
this.nome = nome;
this.logra = logra;
this.num = num;
}
public String displayCarta() {
return ("Remetente: "+nome+
"\nLogradouro: "+logra+", "+num);
}
public String getNome() {
return nome;
}
}
CartaApp.java
//CartaApp.java
//Aplicação que deve ser compilada
import javax.swing.JOptionPane;
/**
* Faça um programa, em Java, que implemente as tarefas de
* um entregador de correspondências postais. Leve em
* consideração que as correspondências são empilhadas na
* sacola e devem ser entregues levando-se sempre em
* consideração a que encontra-se no topo. O programa
* deve permitir:
*
* - Inserir correspondência na sacola (empilhar);
* - Remover correspondência da sacola (desempilhar);
* - Verificar se a sacola está cheia ou vazia;
* - Verificar a próxima correspondência a ser entregue;
* - Informar quantas correspondências existem na sacola.
*
* A pilha deverá armazenar objetos com os dados de cada correspondência
*
* @author Tiago Passos - http://tiagopassos.com)
*
*/
public class CartaApp {
public static void main(String[] args) {
StackX Pilha = new StackX(Integer.parseInt(JOptionPane
.showInputDialog("Quantas cartas deseja colocar na sacola:")));
Carta temp; // Declara variavel temporaria
int op = Integer.parseInt(JOptionPane.showInputDialog("MENU"
+ "\n1 - Inserir correspondência na sacola"
+ "\n2 - Remover correspondência da sacola"
+ "\n3 - Verificar se a sacola está cheia ou vazia"
+ "\n4 - Verificar a próxima correspondência a ser entregue"
+ "\n5 - Informar quantas correspondências existem na sacola"
+ "\n6 - Sair" + "\n\nDigite a opção desejada:"));
while (op != 6){
if (op == 1) {
// INSERE
String nome = JOptionPane
.showInputDialog("Digite o nome do remetente:");
String logra = JOptionPane
.showInputDialog("Digite o nome do logradouro:");
int num = Integer.parseInt(JOptionPane
.showInputDialog("Digite o numero:"));
Carta cartaAux = new Carta(nome, logra, num);
if (!Pilha.isFull()) {
Pilha.push(cartaAux);
JOptionPane.showMessageDialog(null,
"Carta colocada na sacola");
} else {
JOptionPane.showMessageDialog(null,
"Desculpe. A sacola está cheia");
}
}
else if (op == 2) {
// REMOVE CORRESPONDECIA DA SACOLA
if (!Pilha.isEmpty()) {
temp = Pilha.pop();
JOptionPane.showMessageDialog(null, "Carta removida:\n"
+ temp.displayCarta());
temp.displayCarta();
} else {
JOptionPane.showMessageDialog(null, "A sacola está vazia");
}
}
else if (op == 3) {
// REMOVE CORRESPONDECIA DA SACOLA
if (Pilha.isEmpty()) {
JOptionPane.showMessageDialog(null, "A sacola está vazia");
} else if (Pilha.isFull()) {
JOptionPane.showMessageDialog(null, "A sacola está cheia");
} else {
int qtd_cartas = Pilha.getTop();
qtd_cartas++;
JOptionPane.showMessageDialog(null,
"A sacola não está cheia nem vazia. " + "Possui "
+ qtd_cartas + " carta(s)");
}
}
else if (op == 4) {
// VERIFICA A PROXIMA CARTA A SER ENTREGUE
if (!Pilha.isEmpty()) { // VERIFICA SE A PILHA ESTA VAZIA
temp = Pilha.peek();
JOptionPane.showMessageDialog(null,
"Próxima carta a ser entregue:\n"
+ temp.displayCarta());
} else {
JOptionPane.showMessageDialog(null,
"Não foi cadastrada nenhuma carta");
}
}
else if (op == 5) {
// INFORMA QUANTAS CARTAS EXISTEM NA SACOLA
// getTop informa o ultimo indice inserido
// A contagem começa de 0, por isso soma 1
int qtd_cartas = Pilha.getTop();
qtd_cartas++;
JOptionPane.showMessageDialog(null,
"Quantidade de cartas na sacola: " + qtd_cartas);
}
op = Integer
.parseInt(JOptionPane
.showInputDialog("MENU"
+ "\n1 - Inserir correspondência na sacola"
+ "\n2 - Remover correspondência da sacola"
+ "\n3 - Verificar se a sacola está cheia ou vazia"
+ "\n4 - Verificar a próxima correspondência a ser entregue"
+ "\n5 - Informar quantas correspondências existem na sacola"
+ "\n6 - Sair"
+ "\n\nDigite a opção desejada:"));
}
JOptionPane.showMessageDialog(null, "Você saiu do programa");
}
}
Vou demonstrar três maneiras para fazer arredondamento de números reais em Java, através de três métodos diferentes:
Exemplo:
package Exemplos;
public class round {
public static void main(String[] args) {
// VALOR A SER ARREDONDADO
double valor = 1.5248;
// GRAVA NA VARIAVEL O ARREDONDADO EM UMA VARIAVEL
double valor_arred = Math.round(valor);
// GRAVA NA VARIAVEL O VALOR ARREDONDADO PRA CIMA
double valor_arred_cima = Math.ceil(valor);
// GRAVA NA VARIAVEL O VALOR ARREDONDADO PRA CIMA
double valor_arred_baixo = Math.floor(valor);
// IMPRIME O VALOR ARREDONDADO
System.out.println("Valor Inicial: "+valor);
System.out.println("Valor Arredondado: "+valor_arred);
System.out.println("Valor Arredondado p/ cima: "+valor_arred_cima);
System.out.println("Valor Arredondado p/ baixo: "+valor_arred_baixo);
}
}
Neste artigo mostrarei como instalar o JDK 6 Update 16 (1.6.0_16) no Ubuntu 9.04.
Para fazer o download do JDK, você pode ir diretamente no site: http://java.sun.com/javase/downloads/index.jsp.
Primeiro vamos criar uma pasta com o nome “java”, dentro do diretório “/usr”. Para isso entre no terminal (Aplicativos/Acessórios/Terminal) e digite o seguinte:
sudo mkdir /usr/java
Depois mova o arquivo que você acabou de baixar para a pasta “/usr/java”. No nosso caso é o “jdk-6u16-linux-x64.bin”. Preste atenção no nome do arquivo, pois pra você pode ser uma versão diferente. No meu caso temos um processador de 64 bits, que pode não ser o seu.
Entre na pasta onde está o arquivo. Por exemplo: se ela estiver em /home/voxtiago/ você vai digitar “cd /home/voxtiago” (sem as aspas). Se quizer ver os arquivos que estão dentro da pasta, digite “ls” (sem as aspas).
Depois mova o arquivo com o seguinte comando:
A partir de agora, onde tiver NOME_DO_ARQUIVO_QUE_VOCÊ_BAIXOU, você deve substituir, obviamente, pelo nome do arquivo que você baixou 😛
mv NOME_DO_ARQUIVO_QUE_VOCÊ_BAIXOU /usr/java Ex.: mv jdk-6u16-linux-x64.bin /usr/java
Acesse o diretorio e dê permissão de execução para o arquivo.
cd /usr/java chmod a+x NOME_DO_ARQUIVO_QUE_VOCÊ_BAIXOU
Por último executamos o arquivo para começar a instalação:
./NOME_DO_ARQUIVO_QUE_VOCÊ_BAIXOU
Digite “yes” quando receber os termos da licença, e espere o final da instalação.
Após o término da instalação, você poderá deletar o arquivo .bin, deixando apenas a pasta que foi criada no diretorio /java. No nosso caso a pasta é jdk1.6.0_16, mas a sua versão pode ser diferente. A partir de agora, onde aparecer NOME_DA_PASTA_QUE_FOI_CRIADA você deverá substituir pelo nome certo, referente a sua versão (no nosso caso jdk1.6.0_16).
Agora iremos setar as variáveis de ambiente para que nosso JDK funcione corretamente.
Abra o arquivo /etc/bashrc, para isso digite no terminal:
gedit /etc/bash.bashrc
Acrescente as seguintes linhas ao final do arquivo:
export JAVA_HOME=/usr/java/NOME_DA_PASTA_QUE_FOI_CRIADA export PATH=:/usr/java/NOME_DA_PASTA_QUE_FOI_CRIADA/bin:$PATH export JAVA_HOME=/usr/java/NOME_DA_PASTA_QUE_FOI_CRIADA export PATH=:/usr/java/NOME_DA_PASTA_QUE_FOI_CRIADA/bin:$PATH
Para confirmar o sucesso da configuração, abra uma outra seção de console e digite os seguintes comandos no terminal:
java -version
Você deve receber uma resposta semelhante a esta:
java version “1.6.0_16″ Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_09-b03) Java HotSpot(TM) Client VM (build 1.5.0_09-b03, mixed mode, sharing) java version “1.6.0_16″ Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_09-b03) Java HotSpot(TM) Client VM (build 1.5.0_09-b03, mixed mode, sharing) javac -version
E você irá ver a versão do Java Compiler e suas opções.
A partir de agora, toda vez que você quizer compilar um arquivo, basta digitar:
javac nome_do_arquivo.java
E toda vez que for executar:
java nome_do_arquivo (sem .class no final)
Fonte: http://javafree.uol.com.br/artigo/872027/Instalando-e-configurando-o-Java-no-Linux-Ubuntu.html
Últimos comentários