Increment and Decrement Operators

COMP 1010 Home > Java Fundamentals

Introduction Increment and decrement are arithmetic operators which quickly add or subtract one from a variable. These operators work on basic data types such as int and long. These operators can appear as an expression by themselves or as part of a complex expression. Increment and decrement can be used to add or subtract one from a variable.

{{{Body}}}

The Increment and Decrement Operators

The increment and decrement operators increase or decrease the value of a variable by 1. The increment operator is ++ and decrement is --. These operators can be used on int, long, float and double data types. They are primarily used on integer value variables such as int and long. Increasing or decreasing the value of a variable can be done by using the increment or decrement operators.

Usage

There are two ways to use these operators. We can use these operators on their own along with a variable, or as part of a larger expression. Using them as part of a larger expression may be difficult depending on the complexity of the expression. As useful as these operators are, we should always keep in mind that code readability is important. Care should be taken when using these operators in complex expressions. We look at the two ways of using increment and decrement below.

As Basic Expression

We can use these operators by placing them before or after the variable. If the operator is placed before a variable, it is known as preincrement or predecrement. Pre - increment/decrement means the variable is increased or decreased before we use it for anything else. If the operator is placed after a variable, it is known as postincrement or postdecrement. Post - increment/decrement means the variable is used by the expression and then modified after.

The following code snippet demonstrates the difference between these four operators:

  int number = 5;

  ++number; // preincrement, the variable 'number' would be 6 as a result
  number++; // postincrement, the variable 'number' would be 7 as a result
  --number; // predecrement, number = 6
  number--; // postdecrement, number = 5

When an expression is only the increment or decrement operator, there is no difference between post and pre. The results are the same. You can change ++number with number++ and still get the same results.

These increment and decrement expressions are really shorthand for:

  number = number + 1; // longer way of writing number++ or ++number
  number = number - 1; // longer way of writing number-- or --number

Note that the regular rules for arithmetic in Java apply here. Be careful not to unintentionally increment or decrement beyond the range a variable can hold. Strange things can happen when this occurs.

Within a Complex Expression

These increment and decrement operators can occur as part of a larger expression as well. Some might write the operator as part of a complex expression to avoid writing the increment or decrement on its own line. In this case, the meaning of the expression may change depending on whether the operator is placed before or after the variable name. It may be easy to add these operators to some complex expressions. Other complex expressions may be a nightmare and should generally be avoided. Again, when using these operators in complex expressions, readability is very important.

When a preincrement is done, the variable is changed before it is used in the expression. Oppositely, when a postincrement is done the variable is changed after the expression is evaluated.

The following example illustrates the difference between pre- and post- increment.

  int number = 3;
  int value = (++number) * 2; // number is increased to 4 and then multiplied by 2
  // value = 8, number = 4

  int number = 3;
  int value = (number++) * 2; // number is multiplied by 2 and then number is increased to 4
  //value = 6, number = 4  

As you can see, whether or not the modified value of number is used as part of the expression in which it occurs depends on which side of the variable the ++, and likewise --, occur.

Precautions

Note that some expressions have unclear meaning, such as number = number++ or number = ++number. Does the variable number receive its incremented value, or is number incremented after the assignment has taken place? It is best to avoid assignment to a variable when that variable is incremented or decremented as part of the assignment's expression.

Summary

The increment and decrement operators are used to add or subtract one from a variable. These operators can be used on the basic data types of int, long, float, and double. The operators can be used as part of a complex expression or as a simple expression. The most common use for the increment operator is as a counter. The increment and decrement operators easily add or subtract one to a variable.

Full Program of Examples

class Increment_Decrement_Example
{

    public static void main(String args[])
    {
        System.out.println("Starting Increment_Decrement_Example...");
        
        int a, b, c, d, e, f;
        int iResult1, iResult2, iResult3;
        int iCount;

        /*** Section 1
        *
        *   A standard use for the increment operator is a counter.
        * These are generally found in loops and other control structures.
        *
        ***/
        
        System.out.println("\nSection 1:");
        
        iCount = 0;
        
        for(int i=0; i<10; i++) // This 'for loop' uses the increment operator
        {			// You can change the i++ to ++i with no problems
        
            if(0 == i%2) // We are looking for even numbers and counting them.
            {
                ++iCount; // this saves having to write 'iCount = iCount + 1;'
            }
        }
        
        System.out.println(" There are " + iCount  + " even numbers from 0 to 9.");
        
        
        
        /*** Section 2
        *
        *   Increment and decrement can be used as part of an expression.
        * Generally it is a good idea to only use them in simple expressions.
        * The more complex the expression, the more difficult it is to predict 
        * the results.
        * 
        ***/
        
        System.out.println("\nSection 2:");
        
        a = 5;
        b = 6;
        c = 7;
        
        iResult1 = a + (b++);
        iResult2 = (++a) + c;
        iResult3 = a + b - (c--);
        
        System.out.println(" a = " + a + ", b = " + b + ", c = " + c);
        System.out.println(" iResult1 = " + iResult1 + ", iResult2 = " + 
                        iResult2 + ", iResult3 = " + iResult3);
        
        
        
        /*** Section 3
        *
        *   Remember that readability is important to a program. You can create
        * quite a mess of code if you are not careful using the increment and
        * decrement operators.
        *
        * Lets add some more variables with a,b and c.
        *
        ***/
        
        System.out.println("\nSection 3:");
        
        a = 1;
        b = 2;
        c = 3;
        d = 4;
        e = 5;
        f = 6;
        
        // This expression works, but is it difficult to read?
        iResult1 = a++ + ++b - --c + d-- + ++e + --f;
        
        // What do you think the result is?
        System.out.println(" iResult1 = a++ + ++b - --c + d-- + ++e + --f;");
        System.out.println(" iResult1 = " + iResult1);
        
        
        
        /*** Section 4
        *
        *   If you are going to use these operators in a complex expression
        * you also need to be careful between post and pre.
        *
        * Take care when you are using these operators and you will rarely have
        * problems.
        *
        ***/
		
        System.out.println("\nSection 4:");
        
        a = 1;
        b = 2;
        c = 3;
        
        iResult1 = a++ + c * --b / b--; // This line works?
        
        // Comment out the line above and uncomment the one below. Then recompile
        // and rerun the program. are the results the same?
        
//        iResult1 = a++ + c * b-- / --b; // Does this expression work?

        System.out.println(" iResult1 = " + iResult1 + "\n");
    }
}