Arithmetic error java

Основные типы исключений (Exception) в java

Перечень наиболее часто встречающихся исключений (исключительных ситуаций, ошибок) в языке программирования java с расшифровкой их значения.

ArithmeticException

Возникла исключительная ситуация, связанная с ошибкой при выполнении арифметического вычисления (например, с попыткой целочисленного деления на нуль). Класс ArithmeticalException унаследован от RuntimeException.

ArrayIndexOutOfBoundsException

Задано значение индекса массива, не принадлежащее допустимому диапазону. Имеется дополнительный конструктор, принимающий в качестве параметра ошибочное значение индекса и включающий его в текст описательного сообщения. Класс ArrayIndexOutOfBoundsException унаследован от IndexOutOfBoundException

ArrayStoreException

Предпринята попытка сохранения в массиве объекта недопустимого типа. Возникает, если попытаться записать в ячейку массива ссылку на объект неправильного типа.

Класс ArrayStoreException унаследован от RuntimeException.

ClassCastException

Выполнена неверная операция преобразования типов (ошибка приведения типов).

Класс ClassCastException унаследован от RuntimeException.

ConcurrentModificationException

Осуществлена попытка изменения объекта конкурирующим потоком вычислений (thread) с нарушением контракта класса (тип определен в пакете jav.util).

Также исключение может происходить при работе с коллекциями при обычной однопоточной работе. ConcurrentModificationException возникает когда коллекция модифицируется «одновременно» с проходом по коллекции итератором любыми средствами кроме самого итератора.

Класс ConcurrentModificationException унаследован от RuntimeException.

EmptyStackException

Возникает при попытке извлечения объекта из пустого стека. Тип обладает только конструктором без параметров, поскольку причина ситуации очевидна без дополнительных разъяснений (тип определен в пакете java.util).

Класс EmptyStackExceptionунаследован от RuntimeException.

IllegalArgumentException

Методу передано неверное значение аргумента (например, отрицательное, когда метод предполагает задание положительных значений).

Класс IllegalArgumentExceptionунаследован от RuntimeException.

IllegalMonitorStateException

Выполнено обращение к методу wait, notifyAll или notify объекта, когда текущий поток вычислений не обладает блокировкой (lock) этого объекта.

Класс IllegalMonitorStateException унаследован от RuntimeException.

IllegalStateException

Предпринята попытка выполнения операции в то время, когда объект не находится в соответствующем состоянии (например при регистрации или удалении ловушки события закрытия исполняющей системы (shutdown hook) после начала процедуры закрытия).

Класс IllegalStateExceptionунаследован от RuntimeException.

IllegalThreadStateException

Предпринята попытка выполнения операции в то время, когда объект потока вычислений не находится в соответствующем состоянии (например, вызван метод start для потока, который уже приступил к работе).

Класс IllegalThreadStateException унаследован от IllegalArgumentException

IndexOutOfBoundsException

Задано значение индекса массива или содержимого строки типа String, не принадлежащее допустимому диапазону.

Класс IndexOutOfBoundsException унаследован от RuntimeException

MissingResourceException

Не найден требуемый ресурс или пакет ресурсов (resource bundle). Единственный конструктор типа предусматривает задание трех аргументов: строки описательного сообщения, наименования класса ресурсов и объекта ключа, отвечающего отсутствующему ресурсу. Для получения строк наименования класса и ключа применяются методы detClassName и getKey соответственно (тип определен в пакете java.util).

Класс MissingResourceExceptionунаследован от RuntimeException.

NegativeArraySizeException

Предпринята попытка создания массива с размером, значение которого задано отрицательным числом.

Класс NegativeArraySizeException унаследован от RuntimeException.

NoSuchElementException

Операция поиска элемента в объекте одного из контейнерных классов завершилась неудачей (тип определен в пакете java.util).

Класс NoSuchElementException унаследован от RuntimeException.

NullPointerException

Возникает при попытке обращения к полю, методу или объекту по ссылке, равной null. Также исключение выбрасывается, когда метод, не допускающий передачи аргумента null, был вызван с заданием значения null. В последнем случае может быть сгенерировано и исключение типа IllegalArgumentException.

Класс NullPointerException унаследован от RuntimeException.

NumberFormatException

Строка, которая, как предполагалось должна содержать представление числа, не отвечает этому требованию. Исключение выбрасывается такими методами, как, например, Integer.parseInt.

Класс NumberFormatException унаследован от IllegalArgumentException.

SecurityException

Предпринята попытка выполнения операции, запрещенной системой обеспечения безопасности в соответствии с действующей политикой безопасности.

Класс SecurityException унаследован от RuntimeException.

StringIndexOutOfBoundsException

Задано значение индекса содержимого строки типа String, не принадлежащее допустимому диапазону. Имеется дополнительный конструктор, принимающий в качестве параметра ошибочное значение индекса и включающий его в текст описательного сообщения.

Класс StringIndexOutOfBoundsException унаследован от IndexOutOfBoundsException.

UndeclaredThrowableException

Выбрасывается при обращении к методу целевого объекта посредством объекта рефлективного класса Proxy, если метод invoke объекта InvocationHandler генерирует объявляемое исключение, которое не допускает присваивания ни одному из типов исключений, упомянутых в предложении throws метода целевого объекта. Рассматриваемое исключение содержит ссылку на исключение, генерируемое методом invoke, которое может быть получено с помощью метода getUndeclaredThrowable. Класс исключений UndeclaredThrowableException поддерживает два конструктора: оба принимают в качестве параметров ссылку на объект Throwable, а один из них, помимо того, строку описания (тип определен в пакете java.lang.reflect).

Класс UndeclaredThrowableException унаследован от RuntimeException.

UnsupportedOperationException

Предпринята попытка выполнения операции над объектом, который ее не поддерживает (например, модификация объекта, обозначенного признаком «только для чтения»). используется также классами коллекций из состава пакета java.util как реакция на вызов методов производного класса, реализация которых не обязательна.

Класс UnsupportedOperationException унаследован от RuntimeException.

Источник

Handling the ArithmeticException Runtime Exception in Java

Table of Contents

Introduction

Arithmetic is at the core of every program and every programming language in existence. From integer and floating-point arithmetic all the way down to bitwise and pointer arithmetic, these mathematical operations translate into machine instructions which execute with thundering speeds and manipulate the state of software applications used across all sorts of different domains. Most modern programming languages have a dedicated category of errors or exceptions for dealing with all the peculiar cases and problematic conditions that may arise while performing these arithmetic operations.

ArithmeticException & Why it is an Unchecked Exception

In Java, any arithmetic operation which creates an exceptional condition makes the Java Virtual Machine throw the ArithmeticException exception [1]. Generally speaking, anything that a scientific calculator isn’t able to process would throw this exception. At a lower level, certain rules and constraints are imposed by the programming language itself, so if any of these are broken, the ArithmeticException exception will emerge.

ArithmeticException inherits from the RuntimeException class which means it is an unchecked, runtime exception [2]. This is due to a language design decision made to reduce the exception handling clutter that would otherwise arise with the high frequency of arithmetic operations, but more importantly because throwing and propagating arithmetic exceptions wouldn’t make sense for the majority of cases, which in practice are the result of logical programming errors that need to be refactored, rather than exceptions that need to be handled. Consequently, Java doesn’t require ArithmeticException instances to be checked and will only let them manifest at runtime.

How to Handle ArithmeticException

To prevent the ArithmeticException exception in Java, one should diligently implement methods with arithmetic operations and ensure that they are correct from a mathematical and a semantical standpoint. If and when encountered, the ArithmeticException exception should instigate refactoring of the problematic code, and only in rare and justified cases, the exception should be explicitly handled.

ArithmeticException Examples

Division by zero (integer arithmetic)

Dividing a real number by zero is one of those mathematical operations that seem very simple but do not have a clean and definitive answer. The result of this operation is formally considered to be undefined, as any attempt at a definition leads to a contradiction [3]. Since this is a special case of the division operation, Java treats it as an exceptional condition and throws the ArithmeticException exception whenever it encounters it at runtime.

Preferred approach

The proper way to deal with division by zero is to make sure that the divisor variable is never zero, or when the input cannot be controlled and there is a possibility of zero manifesting itself in the equation, treating that as one of the expected options and resolving it accordingly. This usually means testing (validating) the value of the divisor before using it, as shown below:

Alternative approach

As with any other exception, it is possible to catch the ArithmeticException inside a try-catch construct, but this should generally be avoided as it creates memory overhead and understates the importance of validating input values and working with a bounded set of parameters.

Division by zero doesn’t always throw ArithmeticException

It is important to be aware that division by zero in the context of floating point numbers does NOT trigger the ArithmeticException . This is because the IEEE 754 standard [4] defines division by zero in floating point arithmetic as ±Infinity and the JVM specification follows this standard [5]. As it can be seen in the example below, setting the operand types to the double floating point number type, results in the positive Infinity constant [6] being assigned to the variable z , which then multiplied by itself yields Infinity again.

Non-terminating decimal expansion (floating point arithmetic)

Many Java software applications used in the financial sector or otherwise requiring the representation and manipulation of large numbers with great precision, rely on accurate floating point arithmetic and the use of specialized classes such as BigDecimal [7]. Working with these classes requires special attention to detail so as to avoid certain mistakes and prevent erroneous results. As an example, failing to specify a scale with a rounding mode to any operation that may produce a number with an infinite decimal expansion (such as 1.3333. ) [8] will throw an ArithmeticException .

The code in the example above declares two BigDecimal instances with the values of 1.8 and 9.2, and tries to divide the first one by the second one. However, since the result of 1.8/9.2 is 0.195652173913043478260869565217391304347826086…. with an endlessly repeating sequence, the BigDecimal::divide method is unable to return an exact value and the JVM throws an ArithmeticException . As the Java documentation for BigDecimal suggests:

“. In the case of divide, the exact quotient could have an infinitely long decimal expansion; for example, 1 divided by 3. If the quotient has a nonterminating decimal expansion and the operation is specified to return an exact result, an ArithmeticException is thrown. Otherwise, the exact result of the division is returned, as done for other operations.”

The way out of this issue is to specify a scale of the quotient to be returned and a rounding policy to apply to the calculated result. One of the ways to do this is by invoking the overridden version of the BigDecimal::divide method which takes two additional parameters for scale and rounding mode, as demonstrated below. Now the resulting computation is a valid number rounded down to 4 decimal places, as explicitly specified.

Safe type casts & putting ArithmeticException to good use

In rare instances, particularly when designing libraries for use by other programs and APIs, ArithmeticException can effectively be used as a safeguard against undesired results and consequences. One such case is numeric type conversions (aka. casts), which Java allows to be done in either direction, from a smaller capacity type to a larger one and vice versa. Casting from a larger to a smaller capacity type is known as downcasting, which is a process where certain information may be lost if the value is larger than what the smaller type can hold. As a specific example, below is a small program casting the maximum value a long type can hold to an integer, i.e., int type. The resulting value here is -1 which is not representative of nor close to the initial value in any way.

To avoid this from happening, an explicit check can be performed to see whether the input value falls within the boundaries of what the target type can hold, as shown below.

This naive and straightforward approach will prevent unsafe casts by triggering the ArithmeticException exception, which is a reasonable solution in this scenario. A more succinct and idiomatic way of accomplishing the same would be to use the native Java method Math::toIntExact which essentially does the same under the hood and makes the type cast safe, i.e., checked.

Conclusion

Arithmetic operations are some of the most frequently encountered operations found in programming code. Java has a dedicated type of exception called ArithmeticException for dealing with exceptional conditions that arise from these operations. The key to preventing the ArithmeticException is being very explicit and deliberate in dealing with special cases such as integer division by zero and non-terminating decimal expansions in floating point arithmetic. Practical examples of these cases alongside possible ways and mechanisms for dealing with them are presented in this article. Finally, a software design scenario where the ArithmeticException exception can be used in a purposeful and beneficial manner is explored, in the context of safe numeric type conversions.

Track, Analyze and Manage Errors With Rollbar

Managing Java errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Java errors easier than ever. Sign Up Today!

Источник

What Is Arithmetic exception?

Thrown when an exceptional arithmetic condition has occurred. For example, an integer “divide by zero” throws an instance of this class.

In this tutorial, we will take a look at a few examples that will highlight the causes of getting an ArithmeticException in the Java program. Also, we will discuss the common causes of Arithmetic exception and how can we handle this exception.

An arithmetic exception is an error that is thrown when a “wrong” arithmetic situation occurs. This usually happens when mathematical or calculation errors occur within a program during run-time. There various causes to an ArithmeticException, the following are a few of them:

List of all invalid operations that throw an ArithmeticException() in Java

• Dividing by an integer Zero
• Non-terminating decimal numbers using BigDecimal

Dividing by an integer Zero:

Java throws an Arithmetic exception when a calculation attempt is done to divide by zero, where the zero is an integer. Take the following piece of code as an example:

package co.java.exception;
public class ArithmaticExceptionEx 
{
   void divide(int a,int b)
   {
      int q=a/b;
      System.out.println("Sucessfully Divided");
      System.out.println("The Value After Divide Is :-" +q);
   }
   public static void main(String[] args) 
   {
      ArithmaticExceptionEx obj=new ArithmaticExceptionEx();
      obj.divide(10, 0);
   }
}

When we run the code, we get the following error:

Exception in thread "main" java.lang.ArithmeticException: / by zero at co.java.exception.ArithmaticExceptionEx.divide(ArithmaticExceptionEx.java:7) at co.java.exception.ArithmaticExceptionEx.main(ArithmaticExceptionEx.java:14)

Since we divided 10 by 0, where 0 is an integer, java throws the above exception. However, if the zero is a floating-point as in the following code, we get a completely different result.

Here, no exception is thrown, and “Q” now has a value of infinity.  Note that is (almost) always a bad idea to divide by zero, even if no exception is thrown.

Non-terminating decimal numbers using BigDecimal:

The BigDecimal class is a Java class used to represent decimal numbers up to a very high number of precision digits. The class also offers a set of functionalities that are not available using primitive data types such as doubles and floats. These functionalities include rounding up/down, defining the number of decimal places we need from a number, etc.

Since BigDecimals are used to represent numbers to a high degree of accuracy, a problem might occur with some numbers, for example, when dividing 1 by 3, or 2 by 12. These numbers do not have a specific number of decimal places, for example, 1/3 = 0.33333333333333333…

Take the following program for example :

package co.java.exception;
import java.math.BigDecimal;
public class ArithmeticExceptionExamples {
   public static void main(String[] args) {
      // TODO Auto-generated method stub
      BigDecimal x = new BigDecimal(1);
        BigDecimal y = new BigDecimal(3);
        x = x.divide(y);       
        System.out.println(x.toString());
   }
}

Take a Look On The Execution:

In the program above, since the class doesn’t know what to do with the division result, an exception is thrown.

Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. at java.math.BigDecimal.divide(Unknown Source) at co.java.exception.ArithmeticExceptionExamples.main(ArithmeticExceptionExamples.java:11)

As we said, the program doesn’t know what to do with the result of the division, hence an exception is thrown with the message “Non-terminating decimal expansion”. One possible solution to the above problem is to define the number of decimal places we require from a big decimal, and the form of rounding that will be used to limit the value to a certain number of decimals. For example, we could  say that z should be limited to 7 decimal places, by rounding up at the 7th decimal place:

package co.java.exception;
import java.math.BigDecimal;
public class ArithmeticExceptionExamples {
   public static void main(String[] args) {
   // TODO Auto-generated method stub
   BigDecimal x = new BigDecimal(1);
        BigDecimal y = new BigDecimal(3);        
        x = x.divide(y, 7, BigDecimal.ROUND_DOWN);//here we limit the # of decimal places        
        System.out.println(x.toString());
   }
}

Here, the program runs properly, since we defined a limit to the number of places the variable “x”  could assume.

If You Have any doubts feel free to drop your doubts in the Comment Section.