Os erros de tempo de execução Java mais comuns

Feb 27 2023

Os erros de tempo de execução ocorrem quando um programa não contém nenhum erro de sintaxe, mas solicita que o computador faça algo que o computador não pode fazer de maneira confiável. Durante a compilação, o compilador não possui técnica para detectar esses tipos de erros.

Os erros de tempo de execução ocorrem quando um programa não contém nenhum erro de sintaxe, mas solicita que o computador faça algo que o computador não pode fazer de forma confiável . Durante a compilação, o compilador não possui técnica para detectar esses tipos de erros. É a JVM (Java Virtual Machine) que o detecta durante a execução do programa.

· Exceção StackOverflowError
· Exceção OutOfMemoryError
· NegativeArraySizeException
· ArithmeticException
· ArrayIndexOutOfBoundsException
· ArrayStoreException
· UnsupportedOperationException
· NoSuchElementException
· ClassCastException
· DateTimeException
· ConcurrentModificationException
· InputMismatchException
· IllegalFormatConversionException
· NumberFormatException
· InvalidParameterException
· NullPointerException

Exceção StackOverflowError

StackOverflowError é um erro que o Java não permite capturar, por exemplo, pilha ficando sem espaço, pois é um dos erros de tempo de execução mais comuns que podem ser encontrados.

A principal causa do StackOverflowError é que não fornecemos a condição de encerramento adequada para nossa função ou modelo recursivo, o que significa que ele se transformará em um loop infinito . Portanto, esse erro é lançado quando o Java fica sem memória disponível.

// Java program to demonstrate
// infinite recursion error
public class StackOverflowErrorClass {
 static int i = 0;
 // Method to print numbers
 public static int printNumber(int x)
 {
  i = i + 2;
  System.out.println(i);
  return i + printNumber(i + 2);
 }
 public static void main(String[] args)
 {
  // Recursive call without any
  // terminating condition
  StackOverflowErrorClass.printNumber(i);
 }
}

RunTime Error in java code :- Exception in thread “main” java.lang.StackOverflowError
at java.io.PrintStream.write(PrintStream.java:526)
at java.io.PrintStream.print(PrintStream.java:597)
at java.io.PrintStream.println(PrintStream.java:736)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:13)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
.
.
.

Exceção OutOfMemoryError

Erro de espaço/memória insuficiente (java.lang.OutOfMemoryError) em threads

Um java.lang.OutOfMemoryError é um erro de tempo de execução em Java que ocorre quando a Java Virtual Machine ( JVM ) não consegue alocar um objeto devido a espaço insuficiente no heap Java. O Java Garbage Collector ( GC ) não pode liberar o espaço necessário para um novo objeto, o que causa um java.lang.OutOfMemoryError . Esse erro também pode ser lançado quando a memória nativa é insuficiente para suportar o carregamento de uma classe Java.

Aqui está um exemplo de um lançamento devido ao espaço de heap Java insuficiente:

public class OutOfMemoryErrorExample {
    public static void main(String[] args) {
        Integer[] myArray = new Integer[1000 * 1000 * 1000];
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at OutOfMemoryErrorExample.main(OutOfMemoryErrorExample.java:8)

NegativeArraySizeException

O NegativeArraySizeException é uma exceção de tempo de execução em Java que ocorre quando um aplicativo tenta criar uma matriz com tamanho negativo . Como NegativeArraySizeException é uma exceção não verificada (estende RuntimeException ), ela não precisa ser declarada na cláusula throws de um método ou construtor.

Os desenvolvedores devem definir o tamanho da matriz como um número inteiro positivo. Se um sinal de menos entrar na declaração de tamanho da matriz, isso lançará NegativeArraySizeException.

class JavaError {
public static void main(String[] args) {
    int[] arr = new int[-5]; // Negative size of the array
    arr[8] = 89;
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.NegativeArraySizeException: -5
at JavaError.main(JavaError.java:4)

ArithmeticException

ex. dividir por zero erros

A manipulação de dados é uma função primária da maioria dos aplicativos Java. Quando a manipulação de dados inclui divisão, os desenvolvedores devem ter cuidado com a divisão por zero . Se zero se tornar o denominador em um cálculo, Java lançará uma ArithmeticException. Portanto, não podemos dividir nada de zero; portanto, quando tentamos fazer isso, obtemos uma exceção aritmética em tempo de execução.

class JavaError {
public static void main(String[] args) {
    int a = 23;
    int b = 0;
    System.out.println(a / b);
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArithmeticException: / by zeroat JavaError.main(JavaError.java:7)

Índice de matriz fora dos limites de exceção

quando um elemento inexistente em um array é acessado

Uma matriz em Java requer um tamanho definido. Se você tentar adicionar mais elementos do que a matriz pode acomodar, isso resultará em ArrayIndexOutOfBoundsException . O código a seguir tenta adicionar um elemento ao índice oito de uma matriz que foi criada para conter apenas cinco elementos:

Acessando o índice da matriz que não existe:

class JavaError {
public static void main(String[] args) {
    String[] arr = new String[5];
    arr[6] = "Hi"; // Accessing array index that does not exsist
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 5
at JavaError.main(JavaError.java:6)

Java aplica contagem baseada em zero a elementos em uma matriz, portanto, o índice 6 de uma matriz se referiria ao sétimo elemento. Mesmo o código a seguir dispararia um ArrayIndexOutOfBoundsException em Java, pois o índice 4 é uma referência ao quinto elemento de um array:

String[] arr = new String[5];
arr[5] = "Hi"; // Accessing array index that does not exsist

ArrayStoreException

O ArrayStoreException compartilha semelhanças com o ClassCastException. Essa exceção de tempo de execução Java ocorre quando o tipo errado de objeto é colocado em uma matriz.

No exemplo abaixo, um array BigInteger é criado, seguido de uma tentativa de adicionar um Double. O Double não compartilha um relacionamento com o BigInteger, portanto, isso aciona um ArrayStoreException em tempo de execução.

Number[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345);

BigInteger[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345); // Java compile error

UnsupportedOperationException

Os programadores Java costumam usar a classe Arrays para transformar uma matriz Java em uma lista mais amigável. No entanto, a lista que o Java retorna é somente leitura. Os desenvolvedores que desconhecem esse fato e tentam adicionar novos elementos se deparam com o UnsupportedOperationException. Este exemplo mostra como isso acontece:

Integer[] data = {1,2,3,5,8,13,21};
List<Integer> list = Arrays.asList(data);
list.add(new Integer(0));

NoSuchElementException

Você não pode iterar por meio de um iterador vazio. O código a seguir, que tenta obter o próximo elemento em um HashSet vazio, gera uma NoSuchElementException.

Set set = new HashSet();
set.iterator().next(); // Java runtime exception thrown

if (!set.isEmpty()) {
  set.iterator().next();
}

para erros de conversão de tipo de dados

Java é uma linguagem fortemente tipada. Ele reforça estritamente as hierarquias de tipo e não lançará um objeto para outro, a menos que eles compartilhem um relacionamento polimórfico. Portanto, ClassCastException acontece quando você tenta converter erroneamente um objeto para uma classe específica. Isso significa que seu objeto não é uma instância ou uma subclasse dessa classe.

No código a seguir, a tentativa de converter o objeto Date em um carimbo de data/hora gera um erro ClassCastException em tempo de execução.

Date today = new Date();Timestamp time = (Timestamp)today;

long seconds = System.currentTimeMillis();
Timestamp time = new Timestamp(seconds);
Date today = (Date)time; // this cast works

DateTimeException

A manipulação de dados é um empreendimento complicado. Fusos horários, linhas de data e formatos de data inconsistentes podem fazer com que o Java lance vários DateTimeExceptions em tempo de execução.

Por exemplo, o código a seguir compila, mas o campo HourOfDay da classe LocalDate fará com que a tentativa de formatar a data falhe.

LocalDate now = LocalDate.now();
DateTimeFormatter.RFC_1123_DATE_TIME.format(now);

LocalDate now = LocalDate.now();
DateTimeFormatter.ISO_DATE.format(now);

para cálculos paralelos implementados incorretamente

O método asList da classe Arrays não é a única vez que uma coleção requer o tratamento somente leitura.

Quando você itera sobre uma lista, a coleção subjacente deve ser corrigida e não atualizada. Portanto, o método add no trecho de código a seguir lança uma ConcurrentModificationException.

List servers = new ArrayList();
servers.add("Tomcat");
                   
Iterator<String> iterator = servers.iterator();
while (iterator.hasNext()) {
  String server = iterator.next();
  servers.add("Jetty");  // throws a Runtime Exception
}

InputMismatchException

o InputMismatchException geralmente ocorre ao trabalhar com programas Java que solicitam entrada dos usuários usando a classe Scanner . Essa exceção geralmente é causada durante a entrada do usuário, quando você espera um determinado tipo de entrada e o usuário insere um tipo diferente de entrada. Em outras palavras, essa exceção pode ocorrer quando a entrada for inválida para o tipo esperado. A entrada não corresponde ao padrão do tipo esperado ou está fora do intervalo.

Como passar dados inválidos, por exemplo, passar um valor numérico para o campo não numérico. Por exemplo, se um programa espera um valor Integer para uma entrada, mas o usuário insere um valor String , uma InputMismatchException é lançada.

Solução : envolva o código que solicita a entrada do usuário em um loop while que solicitará continuamente ao usuário a entrada correta.

IllegalFormatConversionException

Explicação : Isso está associado a printf() e String.format() . Isso significa que há um espaço reservado não associado (muitos espaços reservados, poucos argumentos) ou é o espaço reservado errado para o tipo nos argumentos. Por exemplo, um %s sendo um espaço reservado para um número inteiro gerará esse erro.

Solução : Certifique-se de que o número de espaços reservados corresponda ao número de argumentos e certifique-se de que os espaços reservados sejam do tipo correto.

NumberFormatException

Tentativa de converter uma string inválida em um número

O NumberFormatException ocorre quando é feita uma tentativa de converter uma string com formato impróprio em um valor numérico. Ou seja, quando não é possível converter uma string em qualquer tipo numérico (float, int, etc), esta exceção é lançada. É uma exceção de tempo de execução (exceção não verificada) em Java. É uma subclasse da classe IllegalArgumentException .

InvalidParameterException

Passando parâmetros/argumentos inválidos para um método

Essa exceção, uma subclasse de IllegalArgumentException projetada para uso pelas classes de mecanismo JCA/JCE, é lançada quando um parâmetro inválido é passado para um método .

Null Pointer Exception

O NullPointerException é um RuntimeException muito comum que os aplicativos Java encontram. essa exceção é lançada quando Java encontra uma referência nula quando não espera uma. e um desenvolvedor java escreve código que invoca um método nesta referência (objeto não inicializado).

String data = null;
System.out.println( data.length() ); // throws NullPointerException

Para evitar essa RuntimeException em seus programas Java, inicialize cada objeto que você criar antes de usá-lo e execute uma verificação nula em qualquer objeto que uma biblioteca externa passe para seus programas.