{"id":6460,"date":"2024-04-21T23:19:25","date_gmt":"2024-04-22T06:19:25","guid":{"rendered":"https:\/\/zentut.com\/?page_id=6460"},"modified":"2024-04-21T23:19:27","modified_gmt":"2024-04-22T06:19:27","slug":"java-arithmetic-operators","status":"publish","type":"page","link":"https:\/\/www.zentut.com\/java-tutorial\/java-arithmetic-operators\/","title":{"rendered":"Java Arithmetic Operators"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how to use Java arithmetic operators to perform various mathematical operations on numeric values.<\/p>\n\n\n\n

Introduction to Java arithmetic operators<\/h2>\n\n\n\n

Arithmetic operators allow you to perform mathematical operations on numeric values. Java provides all basic arithmetic operators that perform addition (+), subtraction (-), multiplication (+), and division (\/). Also, it offers a remainder operator (%) that returns the remainder of a division. <\/p>\n\n\n\n

The following table illustrates the arithmetic operators in Java:<\/p>\n\n\n\n

Operator<\/th>Description<\/th><\/tr><\/thead>
+<\/code><\/td>Additive operator<\/td><\/tr>
-<\/code><\/td>Subtraction operator<\/td><\/tr>
*<\/code><\/td>Multiplication operator<\/td><\/tr>
\/<\/code><\/td>Division operator<\/td><\/tr>
%<\/code><\/td>Remainder operator<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

These arithmetic operators can be applied to both integers and floats. Depending on the type of numbers, the result will be different. For example:<\/p>\n\n\n\n

<\/td>Integer<\/strong><\/td>Float<\/strong><\/td><\/tr>
Operation<\/strong><\/td>Operator<\/strong><\/td>Equation<\/strong><\/td>Result<\/strong><\/td>Equation<\/strong><\/td>Result<\/strong><\/td><\/tr>
Add<\/td>+<\/td>15 + 2<\/td>17<\/td>15.0 + 2.0<\/td>17.0<\/td><\/tr>
Subtract<\/td>–<\/td>15 – 2<\/td>13<\/td>15.0 – 2.0<\/td>13.0<\/td><\/tr>
Multiply<\/td>*<\/td>15 * 2<\/td>30<\/td>15.0 * 2.0<\/td>30.0<\/td><\/tr>
Divide<\/td>\/<\/td>15\/2<\/td>7<\/td>15.0\/2.0<\/td>7.5<\/td><\/tr>
Remainder<\/td>%<\/td>15%2<\/td>1<\/td>15.0%2.0<\/td>1.0<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

It’s important to note that when you divide two integers, you’ll get an integer, not a float. Therefore, there will be no fractional part. e.g., 15\/2 returns 7 instead of 7.5.<\/p>\n\n\n\n

The following program illustrates how to use the Java arithmetic operators on integers:<\/p>\n\n\n

public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n\n        int<\/span> x = 15<\/span>;\n        int<\/span> y = 2<\/span>;\n\n        int<\/span> result = x + y;\n        System.out.println(result); \/\/ 17<\/span>\n\n        result = x - y;\n        System.out.println(result); \/\/ 13<\/span>\n\n        result =  x * y;\n        System.out.println(result); \/\/ 30<\/span>\n\n        result =  x \/ y;\n        System.out.println(result); \/\/ 7<\/span>\n\n        result =  x % y;\n        System.out.println(result); \/\/ 1<\/span>\n\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
17<\/span>\n13<\/span>\n30<\/span>\n7<\/span>\n1<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Similarly, the following program shows how to use the Java arithmetic operators on floating-point numbers:<\/p>\n\n\n
public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n\n        float<\/span> x = 15.0f<\/span>;\n        float<\/span> y = 2.0f<\/span>;\n\n        float<\/span> result = x + y;\n        System.out.println(result); \/\/ 17.0<\/span>\n\n        result = x - y;\n        System.out.println(result); \/\/ 13.0<\/span>\n\n        result =  x * y;\n        System.out.println(result); \/\/ 30.0<\/span>\n\n        result =  x \/ y;\n        System.out.println(result); \/\/ 7.5<\/span>\n\n        result =  x % y;\n        System.out.println(result); \/\/ 1.0<\/span>\n\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
17.0<\/span>\n13.0<\/span>\n30.0<\/span>\n7.5<\/span>\n1.0<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Prefix and postfix operators<\/h2>\n\n\n\n
The prefix and postfix operators are used with variables<\/a> to increment and decrement their values by one.<\/p>\n\n\n\n
Prefix operators<\/h3>\n\n\n\n
A prefix operator is placed before a variable. Java provides two prefix operators ++x<\/code> and --x<\/code>, where x<\/code> is a variable.<\/p>\n\n\n\n
The ++x<\/code> prefix operator increments a variable’s value by one and the --x<\/code> prefix operator decrements a variable value by one before the value is used in an expression. <\/p>\n\n\n\n
The following example illustrates how to use the ++count<\/code> prefix operator to increment the count<\/code> variable by one:<\/p>\n\n\n
public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span> count = 0<\/span>;\n        System.out.println(++count); \/\/ 1<\/span>\n        System.out.println(count);   \/\/ 1<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
1<\/span>\n1<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
    \n
  • First, define a variable called count<\/code> and initialize its value to 0.<\/li>\n\n\n\n
  • Second, increment the count<\/code> variable by one and return it. The System.out.println()<\/code> displays the value of the count<\/code> variable which is 1.<\/li>\n\n\n\n
  • Third, display the value of the count<\/code> variable again. As a result, it shows 1 as expected.<\/li>\n<\/ul>\n\n\n\n
    The following program shows how to use the prefix operator --count<\/code> to decrease the value of the count<\/code> variable by one:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span> count = 1<\/span>;\n        System.out.println(--count); \/\/ 0<\/span>\n        System.out.println(count);   \/\/ 0<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    0<\/span>\n0<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Postfix operators<\/h3>\n\n\n\n
    The postfix operators are placed after a variable. Java has two postfix operators: x++<\/code> and x--<\/code>, where x<\/code> is a variable.<\/p>\n\n\n\n
    The postfix operator x++<\/code> increments the variable’s value and x--<\/code> decrements the variable’s value after<\/strong> the value is used in the expression.<\/p>\n\n\n\n
    The following program uses the postfix operator count++<\/code> to increment a variable’s value after the value is used in the System.out.println()<\/code>:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span> count = 0<\/span>;\n        System.out.println(count++); \/\/ 0<\/span>\n        System.out.println(count);   \/\/ 1<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    0<\/span>\n1<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The count++<\/code> returns the value of the count<\/code> variable first before incrementing the count<\/code>‘s value by one. Therefore, the first System.out.println()<\/code> displays 0 while the second one shows 1.<\/p>\n\n\n\n
    The following program illustrates how to use the postfix operator count--<\/code> to decrement a variable:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        int<\/span> count = 1<\/span>;\n        System.out.println(count--); \/\/ 1<\/span>\n        System.out.println(count);   \/\/ 0<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    1<\/span>\n0<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, we define the count<\/code> variable and initialize its value to 1. The count--<\/code> returns the count’s value first and then decreases the count<\/code>‘s value by one.<\/p>\n\n\n\n
    Compound assignment operators<\/h2>\n\n\n\n
    To add a value to a variable, you use the +<\/code> operator and assign the result back to the variable. For example, the following adds 2<\/code> to the x<\/code> variable:<\/p>\n\n\n
    int<\/span> x = 15<\/span>;\nx = x + 2<\/span>;<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Since the variable x<\/code> appears on both the left and right sides of the expression, it’s quite redundant. <\/p>\n\n\n\n
    To remove the redundancy, Java allows you to use something called a compound assign operator<\/strong> like this:<\/p>\n\n\n
    int<\/span> x = 15<\/span>;\nx += 2<\/span>;<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the x += 2<\/code> is equivalent to the x = x + 2<\/code>.<\/p>\n\n\n\n
    By definition, a compound assignment operator combines an operator (addition, subtraction, multiplication, division, modular) with the assignment operator (=):<\/p>\n\n\n\n
    Arithmetic Operators<\/th>Compound Assignment Operators<\/th><\/tr><\/thead>
    x = x + n;<\/td>x += n;<\/td><\/tr>
    x  = x  – n;<\/td>x -= n;<\/td><\/tr>
    x = x * n;<\/td>x *= n;<\/td><\/tr>
    x = x \/ n;<\/td>x \/= n;<\/td><\/tr>
    x = x % n;<\/td>x %= n;<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    Operator precedence<\/h2>\n\n\n\n
    If an expression contains multiple operators, Java uses a set of rules that determines the order in which operators are evaluated. <\/p>\n\n\n\n
    This set of rules is called operator precedence<\/strong>. In Java, the operator that has higher precedence will be evaluated first.<\/p>\n\n\n\n
    The following table shows the precedence of postfix operators, prefix operators, and arithmetic operators from high to low:<\/p>\n\n\n\n
    Operator<\/th>Operator Precedence (high to low)<\/th><\/tr><\/thead>
    Postfix operators<\/td>x++, x–<\/td><\/tr>
    Prefix operators<\/td>++x, –x<\/td><\/tr>
    Multiplicative operators<\/td>*, \/ , %<\/td><\/tr>
    Additive operators<\/td>+, –<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    The operators with the same precedence e.g., (+, -) are evaluated from left to right. To override precedence, you use parenthesis. If nested parenthesis is used, they are evaluated from the inside out.<\/p>\n\n\n\n
    The following program illustrates how operator precedence works:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n       int<\/span> x = 1<\/span>;\n       int<\/span> y = 2<\/span>;\n       int<\/span> z = 3<\/span>;\n\n       int<\/span> result1 = x + y * z;\n       int<\/span> result2 = (x + y) * z;\n\n       System.out.println(result1); \/\/ 7<\/span>\n       System.out.println(result2); \/\/ 9<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this program, we have three variables x<\/code>, y<\/code>, and z<\/code> and perform two different calculations:<\/p>\n\n\n\n
      \n
    • result1<\/code> calculates x + y * z<\/code>. Since multiplication has higher precedence than addition, y * z<\/code> is evaluated first, and then the result is added to x<\/code>. The result1<\/code> is 7<\/code> because multiplication is performed before addition: 1 + 2 * 3<\/code> equals 1 + 6<\/code>, which is 7<\/code>.<\/li>\n\n\n\n
    • result2<\/code> calculates (x + y) * z<\/code>. Here, we use parentheses to explicitly specify that the addition should be performed first, and then the result is multiplied by z<\/code>.  The result2<\/code> is 9<\/code> because we use parentheses to ensure addition is performed first: (1 + 2) * 3<\/code> equals 3 * 3<\/code>, which is 9<\/code>.<\/li>\n<\/ul>\n\n\n\n
      Summary<\/h2>\n\n\n\n
        \n
      • Java supports basic arithmetic operators including +, -, *, \/, and %.<\/li>\n\n\n\n
      • Use the prefix and postfix operators to increment or decrement a variable by one.<\/li>\n\n\n\n
      • Use compound assignment operators to make the code more concise.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
        Summary: in this tutorial, you’ll learn how to use Java arithmetic operators to perform various mathematical operations on numeric values. Introduction to Java arithmetic operators Arithmetic operators allow you to perform mathematical operations on numeric values. Java provides all basic arithmetic operators that perform addition (+), subtraction (-), multiplication (+), and division (\/). Also, it […]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":2190,"menu_order":6,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-6460","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6460","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/comments?post=6460"}],"version-history":[{"count":2,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6460\/revisions"}],"predecessor-version":[{"id":6462,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6460\/revisions\/6462"}],"up":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/2190"}],"wp:attachment":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/media?parent=6460"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}