Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Listas Ligadas |
Exercícios Resolvidos de Java - Como remover no início de uma lista ligada em Java - Escreva um programa Java que cria uma lista dinamicamente encadeadaQuantidade de visualizações: 869 vezes |
|
Pergunta/Tarefa: Escreva um programa Java que cria uma lista dinamicamente encadeada (lista singularmente encadeada) e peça para o usuário inserir 5 elementos do tipo inteiro. Em seguida faça a remoção do nó no início da lista ligada e retorne o seu valor. Sua saída deve ser parecida com: Inserindo 5 valores na lista Informe o 1.o valor: 3 Informe o 2.o valor: 8 Informe o 3.o valor: 4 Informe o 4.o valor: 7 Informe o 5.o valor: 6 Valores na lista: 3 -> 8 -> 4 -> 7 -> 6 -> null Removendo no início da lista O nó removido foi: 3 Valores na lista novamente: 8 -> 4 -> 7 -> 6 -> null Na saída podemos ver que a lista contém os valores 3, 8, 4, 7 e 6. Depois que o nó no início é removido, os elementos da lista ficam 8, 4, 7 e 6. Veja a resolução comentada deste exercício usando Java:
package estudos;
import java.util.Scanner;
// classe interna usada para representar um
// nó na lista ligada
class No {
int valor; // valor do nó
No proximo; // aponta para o novo nó
// construtor cheio da classe No
public No(int valor, No proximo) {
this.valor = valor;
this.proximo = proximo;
}
// construtor vazio da classe No
public No() {
this.valor = 0;
this.proximo = null;
}
}
public class Estudos {
// vamos criar uma referência para o início da lista
static No inicio = null;
public static void main(String args[]){
// para ler a entrada do usuário
Scanner entrada = new Scanner(System.in);
// vamos inserir 5 valores inteiros na lista ligada
int valor;
System.out.println("Inserindo 5 valores na lista\n");
for (int i = 0; i < 5; i++) {
System.out.print("Informe o " + (i + 1) + ".o valor: ");
valor = Integer.parseInt(entrada.nextLine());
// vamos inserir este valor no final da lista
inserirFinal(valor);
}
// vamos exibir os valores na lista ligada
System.out.print("\nValores na lista: ");
exibirLista();
// vamos remover o nó no início da lista ligada
System.out.println("\nRemovendo no início da lista");
No removido = removerInicio();
System.out.println("O nó removido foi: " +
removido.valor);
// vamos exibir os valores na lista ligada
System.out.print("\nValores na lista novamente: ");
exibirLista();
}
// função que permite remover o nó no início de uma lista
// dinamicamente ligada em Java
public static No removerInicio() {
// primeiro apontamos para o início da lista
No no = inicio;
// a lista está vazia?
if (no != null) {
// o início da lista aponta para o seu próximo
inicio = inicio.proximo;
}
// retorna o nó removido ou null no caso da lista vazia
return no;
}
// função que permite adicionar um nó no final da
// lista ligada
public static void inserirFinal(int valor) {
// vamos apontar para o nó inicial
No atual = inicio;
// criamos um novo nó
No novo = criarNo(valor);
// a lista ligada ainda está vazia?
if (atual == null){
// inicio recebe o novo nó
inicio = novo;
}
else { // temos um ou mais nós na lista ligada
// vamos localizar o último nó
while (atual.proximo != null) {
atual = atual.proximo;
}
// encontramos o último nó. Agora vamos inserir
// o novo nó depois dele
atual.proximo = novo;
}
}
// função usada para construir e retornar um novo nó
public static No criarNo(int valor) {
// cria o novo nó
No no = new No(valor, null);
// retorna o nó criado
return no;
}
// função usada para percorrer a lista ligada e
// exibir os valores contidos em seus nós
public static void exibirLista() {
// vamos apontar para o início da lista
No temp = inicio;
// a lista está vazia?
if (temp == null) {
System.out.println("A lista está vazia.");
}
else {
// esse laço se repete enquanto tempo for
// diferente de null
while (temp != null) {
// vamos mostrar o valor desse nó
System.out.print(temp.valor + " -> ");
// avança para o próximo nó
temp = temp.proximo;
}
// mostra o final da lista
System.out.println("null");
}
}
}
|
Java ::: Tratamento de Erros ::: Passos Iniciais |
Quais as diferenças entre checked exceptions, runtime exceptions e errors na linguagem Java?Quantidade de visualizações: 15941 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:
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:
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:
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:
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. |
C# ::: Fundamentos da Linguagem ::: Estruturas de Controle |
Como usar if e if..else em C# - A estrutura condicional if do C#Quantidade de visualizações: 22322 vezes |
A instrução condicional if (se) é usada quando queremos testar uma condição e, baseado nesta, executar alguma ação. Veja:
static void Main(string[] args){
int valor = 20;
// testa se o valor é maior que 10
if(valor > 10){
Console.WriteLine("O valor é maior que 10");
}
Console.WriteLine("\n\nPressione uma tecla para sair...");
Console.ReadKey();
}
Execute o código e veja que o texto "O valor é maior que 10" é exibido somente se o valor da variável valor for maior que 10. Note que neste teste temos somente uma instrução. Neste caso as chaves { e } podem ser omitidas:
if(valor > 10)
Console.WriteLine("O valor é maior que 10");
No entanto, quando duas ou mais instrução forem executadas, as chaves { e } são obrigatórias. Note também que o resultado do teste de uma instrução condicional if deve ser sempre true ou false. A instrução if..else (se..ou então) é útil quando queremos executar uma ação se uma condição for satisfeita e outra ação caso contrário. Veja:
static void Main(string[] args){
int valor = 5;
// testa se o valor é maior que 10
if(valor > 10){
Console.WriteLine("O valor é maior que 10");
}
else{
Console.WriteLine("O valor é menor ou igual a 10");
}
Console.WriteLine("\n\nPressione uma tecla para sair...");
Console.ReadKey();
}
Há ainda os casos em que temos que testar várias condições. Observe: static void Main(string[] args){
int valor = 8;
// testa se o valor é maior que 10
if(valor > 10){
Console.WriteLine("O valor é maior que 10");
}
// testa se o valor é menor que 10
else if(valor < 10){
Console.WriteLine("O valor é menor que 10");
}
// o valor é igual a 10
else{
Console.WriteLine("O valor é igual a 10");
}
Console.WriteLine("\n\nPressione uma tecla para sair...");
Console.ReadKey();
}
|
C# ::: Dicas & Truques ::: Sistema |
Como verificar o formato de um drive (NTFS, FAT32, etc) usando a propriedade DriveFormat da classe DriveInfo da linguagem C#Quantidade de visualizações: 7618 vezes |
|
A propriedade DriveFormat da classe DriveInfo pode ser usada para obter o formato de um drive, ou seja, ela nos permite saber se o formato de um drive é NTFS ou FAT32, por exemplo. Veja um trecho de código exemplificando seu uso:
using System;
using System.IO;
namespace Estudos{
class Program{
static void Main(string[] args) {
DriveInfo di = new DriveInfo("C");
// vamos obter o formato deste drive
string formato = di.DriveFormat;
// vamos exibir o resultado
Console.WriteLine("O formato deste drive é: " + formato);
}
}
}
Ao executar este código nós teremos o seguinte resultado: O formato deste drive é: NTFS |
Nossas 20 dicas & truques de programação mais populares |
|
CSS - Como definir uma imagem de fundo para a página HTML em CSS usando a propriedade background-image |
Você também poderá gostar das dicas e truques de programação abaixo |
|
C# - Como adicionar ou subtrair meses de uma data em C# usando o método AddMonths() da estrutura DateTime |
Nossas 20 dicas & truques de programação mais recentes |
Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site |
|
Python - Como criar o jogo Pedra, Papel, Tesoura em Python - Jogo completo em Python com código comentado |
Últimos Exercícios Resolvidos |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |





