We Keep Coding

Java Incremental operator query (++i and i++) [duplicate]

This question already has answers here:
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
Java is NEVER pass-by-reference, right?...right? [duplicate]
(6 answers)
Closed 8 years ago.
I have the following code:
public class Book {
private static int sample1(int i) {
return i++;
}
private static int sample2(int j) {
return ++j;
}
public static void main(String[] arguments){
int i = 0;
int j = 0;
System.out.println(sample1(i++)); //0
System.out.println(sample1(++i)); //1
System.out.println(sample2(j++));//1
System.out.println(sample2(++j));//2
System.out.println(i);//2
System.out.println(j);//2
}
}
My expected output is in comments. The actual output is below:
0
2
1
3
2
2
I'm getting confused with the function calls and incemental operator. Can someone kindly explain the actual result?

Since sample1 and sample2 are just modifying their own local variables i and j (not those of the calling method), it's clearer if we rewrite them without those modifications:
private static int sample1(int i) {
return i; // was 'i++', which evaluates to the old i
}
private static int sample2(int j) {
return j + 1; // was '++j', which evaluates to j after incrementing
}
At which point it's straightforward to just substitute them in place — sample1(...) becomes ..., and sample2(...) becomes ... + 1:
int i = 0;
int j = 0;
System.out.println(i++);
System.out.println(++i);
System.out.println((j++) + 1);
System.out.println((++j) + 1);
System.out.println(i);
System.out.println(j);
We can make this a bit clearer by separating the incrementations into their own commands. i++ evaluates to the original value of i, so it's like incrementing i after running the surrounding command; ++i, by contrast, is like incrementing i before running the surrounding command. So we get:
int i = 0;
int j = 0;
System.out.println(i);
i++;
++i;
System.out.println(i);
System.out.println(j + 1);
j++;
++j;
System.out.println(j + 1);
System.out.println(i);
System.out.println(j);
. . . at which point it should be straightforward to trace through and see what it will output.
Does that all make sense?

First of all you need to know the difference between x++ and ++X;
In case of x++ :
First the current value will be used and it will be incremented next.
That means you will get the present value of x for the operation and if you
use x next time will get the incremented value;
In case of ++x :
First the current value will be incremented and it will be used (the incremented value) next, that means you will get the incremented value
at this operation and for other after this operation.
Now lets split the code and discuss them separately
method: sample1() :
private static int sample1(int i) {
return i++;
}
This method will take a int and return it first and then try to increment but as after returning the variable i will go out of scope so it will never be
incremented at all. exp in: 10-> out 10
method: sample2() :
private static int sample2(int j) {
return ++j;
}
This method will take a int and increment it first and then return it. exp in: 10-> out 11
In both case only the variables will change locally, that means if you call from main method the variables of main method will remain unaffected by the change
(as the sample1() and sample2() are making copy of the variables)
Now for the code of the main method
System.out.println(sample1(i++)); // it's giving sample1() `i=0` then making `i=1`
// so sample1() will return 0 too;
System.out.println(sample1(++i)); // it's making `i=2` and then giving sample1() `i=2`
// so sample1() will return 2;
System.out.println(sample2(j++)); // it's giving sample2() `j=0` then making `j=1`
// so sample2() will return 1;
System.out.println(sample2(++j)); // it's making `j=2` giving sample2() `j=2` then
// so sample2() will return 3;

You're experiencing the fun of prefix and postfix operators.
The prefix operator, ++i increments the variable i by one before using it in the expression, where the postfix operator (i++) uses i in the expression before incrementing it.
This means that your method sample1 doesn't do anything; it evaluates the expression containing i, but because that expression is a return statement, the local variable i goes out of scope, and we can't modify it anymore.
sample2, by contrast, increments the local copy of j before returning it, which is why you print higher values of j than you expect.

Easy:
1) First call:
a) Provide i (==0) to sample1(), which returns 0 (then increments the argument i, and that gets discarded).
b) increments i because of i++. i is now 1.
c) Prints the function result: 0.
2) Second call:
a) Increments i because of ++i. i is now 2.
b) Provide i (==2) to sample1(), which returns 2 (then increments the argument i, and that gets discarded)
c) Prints the function result: 2.
3) Third call:
a) Provide j (==0) to sample2(), which increments the argument, and therefore returns 1.
b) increments j because of j++. j is now 1.
c) Prints the function result: 1.
4) Fourth call:
a) Increments j because of ++j. j is now 2.
b) Provide j (==2) to sample2(), which increments the argument, and therefore returns 3.
c) Prints the function result: 3.
5 & 6) Fifth and Sixth call:
a) Prints the value of j: 2.
The key to remember here is that i++ increments the variable after passing it as an argument, whereas ++i increments the variable before passing it as an argument.
Hope this helps

1st print
before call: i = 0
increment after call
sample1 is called with a value of 0
sample 1 returns 0, the increment is discarded
after call: i = 1
2nd print
before call: i = 1
increment before call
sample1 is called with a value of 2
sample1 returns 2, the increment is discarded
after call: i = 2
3rd print
before call: j = 0
increment after call
sample2 is called with a value of 0
sample2 the increments 0 to 1, returns it
1 is printed
increment j to 1
after call: j = 1
4th print
before call: j = 1
increment before call
increment j to 2
sample2 is called with a value of 2
sample2 the increments 2 to 3, returns it
3 is printed
after call: j = 2
5th print
prints i
2 is printed
6th print
prints j
2 is printed

Both of them increase the variable i by one like i = i + 1;
The difference is that :
++i increments the value first and then return it
i++ return the value first and then increments it
This behavior difference doesn’t matter in a for loop.
If you want to know the difference try this :
int x = 0;
int y = x++;
int x = 0;
int y = ++x;
Here x++ returns the value then increments it but ++x first increments the value then returns that value

Form your example,
private static int sample1(int i) {
return i++;
}
private static int sample2(int j) {
return ++j;
}
public static void main(String[] arguments)
{
int i = 0;
int j = 0;
System.out.println(sample1(i++)); //0
System.out.println(sample1(++i)); //1
System.out.println(sample2(j++));//1
System.out.println(sample2(++j));//2
System.out.println(j);//2
System.out.println(j);//2
}
i = 0; sample1(i++) -> it pass '0'->in sample1 return i++ so, 0(++)
Here it returns 0 but incremented to 1 , so println is = 0 but finally i takes 1
i = 1; sample1(++i) -> it pass '2'-> in sample1 return i++ so, 2(++)
Here it returns 2, so println is = 2
j = 0; sample2(j++) -> it pass '0'-> in sample2 return ++j so, (++)0
Here it returns 1, so println is = 1.
j = 1; sample2(++j) -> it pass ++1 => 2, in sample2 return ++j so, (++)2
Here it returns 3, so println is = 3. But increment is ended with in sample2, not in
main so j still holds 2.
j = 2
j = 2

Converting an Iterative Method to a Recursive one (Java)

For my discrete structures class at uni, I need to write a method that solves the formulas below:
 
s[0] = 1
s[n-1] = s[n-2] + n for all n >= 2
Unfortunately, I've not implemented many recursive methods before, so I don't really know what I'm doing. Things just aren't "clicking" for me like they normally do.
I'd appreciate help in any way possible, but I'd rather fully understand this, rather than just copypaste someone else's work.
A basic example for what this method should accomplish if n = 8...
1 + 2 = 3,
3 + 3 = 6,
6 + 4 = 10,
10 + 5 = 15,
15 + 6 = 21,
21 + 7 = 28,
28 + 8 = 36, our answer.
I've written a method to solve this NON-recursively (shown below), so I do understand the math behind it.
public static int sequenceNonRecursive(int n){
int[] s = new int[n];
s[0] = 1;
if(n >= 2){
for(int i = 1; i < n; i++){
s[i] = s[i-1] + i + 1;
}
}
return s[n-1];
}
EDIT: I solved it. Thanks for your help, everyone! Look below for my answer.

The recurrence is defined a little oddly. I would rewrite it:
S0 = 1
Si = Si-1 + i + 1 — ∀ i > 0
The routine can be simplified to not use an array:
public static int sequenceNonRecursive (int n) {
int S_0 = 1; // 0th term is 1
int S_i = S_0; // S_i starts at S_0
for(int i = 1; i <= n; i++) {
int S_i_minus_1 = S_i; // use previous result to calculate next
S_i = S_i_minus_1 + i + 1; // next is previous added with index plus 1
}
return S_i;
}
Any loop can be converted into an equivalent recursive routine. The trick is that local variables turn into function parameters for the recursive routine and the loop control turns into an if. If the condition is false, the function returns with the result. Otherwise, the function does the computation as if it is the loop body, and then uses recursion to iterate.
As an illustration, given the function:
public static int someFunction (int n) {
int result = DEFAULT_RESULT;
for (int i = 0; i < n; ++i) {
result = UPDATE_RESULT(i, n, result);
}
return result;
}
Then, the body of this function can be changed to call a recursive function instead:
public static int someFunction (int n) {
return someFunctionWithRecursion(n, 0, DEFAULT_RESULT);
}
Notice how the initial values of local variables have been converted into parameters to the recursive routine. So, the recursive routine itself may look like:
public static int someFunctionWithRecursion (int n, int i, int result) {
if (! (i < n)) {
return result;
}
result = UPDATE_RESULT(i, n, result);
return someFunctionWithRecursion(n, i+1, result);
}
Notice that in the recursive call, the result has been updated, and the control variable i has been incremented, just as an iteration would have done in the original for() loop version of the code.
As an aside: The recurrence you are working on actually has a closed form:
Sn = (½)(n+1)(n+2)

It's actually easier. Imagine that your method works for all n's and that unless n is zero (the base case) you use
sequenceRecursive(n-1)
to get the value of the previous number and just expect it to work. (and it will)
Under the hood it will recurse down to the base case and build up the value as the calls return.

Recursion is like breaking down the original problem into sub problems and trying to solve them. To start with you need to figure out the base case(which in your case is n=0). Now you can move ahead and see how you can handle cases where n > 0 by breaking it down to the base case. Creating the sequence for n then n-1 then n-2 and so on till you reach the base case is the key to solve this problem recursively.

Structure your code something like this (just giving hints, leaving you to figure out the rest of the problem):
public static int sequenceRecursive(int n){
if( n == 0 )
//return something....
else
//return something else, which recursively relies on previous values of sequenceRecursive()
}

Let's first add 1 to all n's in your second equation: (if we increase them, we need to decrease the range, seeing that it's correct should be trivial)
s[0] = 1
s[n] = s[n-1] + (n+1) for all n >= 1
Why do we want to do this?
In short, the function definition is sequence(int n), not sequence(int n-1).
Here s[i] just corresponds to calling your function with input parameter i.
And the basic idea for the code:
public static int sequence(int n){
if (/* base case */)
// return value for base case
else
// return other case, includes calling sequence(x) for some x
}
Hope that gives you enough to work from.

I got it, guys. Thank ALL of you for your help! I can't believe how stupidly simple this was. As soon as I figured it out, I gave myself a forceful facepalm. I'm pretty sure I understand recursion now.
public static int sequenceRecursive(int n){
if( n == 0 )
return 0;
else
return n + sequenceRecursive(n-1);
}

Why is for/while loop variable incrementing by 1 after loop exit? Unwanted side effect

Here is the code -
int i = 0;
System.out.printf( "\n%d\n\n", i ); // show variable i before loop
for( i = 0; i < 8; i++ )
{
System.out.printf( "%d\t", i );
}
System.out.printf( "\n\n%d\n", i ); // show variable i after loop
Here is the output -
0
0 1 2 3 4 5 6 7
8
My problem arises when I want to use the variable i after the exit of the for loop. I would assume that i is reading 7, the 8th increment in zero based counting but it actually reads as 8!!! One more increment to variable i has been made on loop exit.
In order to remedy this I would have to do something like i-- at the end of the loop and before using it in any further code. This seems to me to make the code harder to understand.
Is there a better solution?

When i is 7, the condition i < 8 is still fulfilled, so there is no reason to exit the loop.
It is not very clear to declare the loop variable before the loop and use it afterwards anyway. Rather, consider declaring the loop variable with the loop statement.
int numIterations = 8;
for(int i = 0; i < numIterations; i++) {
// ...
}
// continue doing something with numIterations, or numIterations-1
If using numIterations-1 really bothers you, you could also instead use int maxCounter = 7 and use i <= maxCounter instead as loop invariant.

When you say
for( i = 0; i < 8; i++ )
the middle part, i < 8, is the loop invariant: as long as it holds, there will be a next iteration. Therefore once you leave the loop, it is because the invariant holds no longer and i cannot possibly be less than 8.

If you want something that is easier to read do the following:
int start = 0;
int end = 7;
System.out.printf( "\n%d\n\n", start );
for(int i = start; i <= end; i++ )
{
System.out.printf( "%d\t", i );
}
System.out.printf( "\n\n%d\n", end );

The loop exits when i == 8, because the loop condition says: keep iterating as long as i < 8. Or to put it another way: stop iterating when i >= 8.
So the last i++ inside the loop will assign 8 to i, exiting the loop. That explains the results you're obtaining, and they're as expected. Perhaps you incorrectly assumed that the last i++ isn't executed before exiting the loop.
To obtain the behavior you want, try this instead - the intent of the code is clearer:
int i = 0;
int iterations = 8;
System.out.printf( "\n%d\n\n", i );
while (i < iterations) {
System.out.printf( "%d\t", i );
i++;
}
System.out.printf( "\n\n%d\n", --i );

It's correct, otherwise it would never exit because 7 < 8.
In this code is of course useless to add more logic because you already know that at the end of the loop the variable will always be the same. I think you need it in a more complex code with conditionals statements, so in that case you can do this:
int i = 0;
System.out.printf( "\n%d\n\n", i ); // show variable i before loop
for( i = 0; i < 8; i++ )
{
if ( i == 3 ) // just for example
break;
System.out.printf( "%d\t", i );
}
System.out.printf( "\n\n%d\n", i ); // show variable i after loop
and this will print:
0
0 1 2 3
3

This is really simple if you know the order of operation
STEP_1 - Action before body operation.
SETP_2 - Evaluate logical expression that continue operation if true.
STEP_3 - Perform body operation.
STEP_4 - Action after body operation.
So:
for(STEP_1; STEP_2; STEP_4) {
STEP_3
}
Usually in step 1 we initialize our variable and in step 4 we modify it for next evaluation of loop.
int i = 0;
for(; i< 8; i++) {
}
The loop breaks when i == 8, as is declared before loop the value stay.

In the loop the variable i is incremented until it reaches 8 or more at which point the condition triggers leaving the loop.
This is just the way it works.
So you have two options that I can think of.
subtract one from the variable i after the loop.
put an if statement in the loop so that when i equals 7, it does a break.
for (i = 0; i < 8; i++) {
if (i == 7) break;
}
Another option would be do use a do while as in:
i = -1;
do {
i++; // increment i so that it is at the correct current value starting with zero
// loop stuff
} while (i < 7);

++ operator in java [duplicate]

This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
java operator ++ problem
This is the code. I know the difference between c++ and ++c.
public class sample {
public static void main(String[] b){
int count = 0,a=0;
for (int i = 0; i < 3; i++){
count=count++;
System.out.println(count);
}
But what I am expecting is
count=count;count=count+1;//output has to be 1 2 3
but the output is 0 0 0.

Your prediction is wrong.
count++ will increment count by 1 and return the old value (0). Which is your case. Afterwards, you assign the old value (0) to your count variable. To make it more understandable, just look at this code
count = count; // is the same as count = count++;
Don't use count = count++;, just use count++

In Java, this code is guaranteed to keep the variable with the same value.
It's like:
int temp;
temp = count;
count = count +1;
count = temp;
to acheieve what you want, write:
count++; //or
count += 1; //or
count = count +1;

Replace count=count++; with count++; .

count = count ++;
Here's what is happening.
First, count++ is evaluated, which evaluated to 0, but increments count. And this 0 is assigned to count. So count remains 0. The following is different, because ++count evaluates to 1, 2...
count = ++count;

I think this will give you a pretty good explanation.
Consider this class:
public class T
{
public void f() {
int count = 0;
count = count++;
}
}
This is the associated byte code:
public void f();
Code:
0: iconst_0
1: istore_1
2: iload_1
3: iinc 1, 1
6: istore_1
7: return
}
iconst_0 loads the constant 0 onto the stack (this is for assigning the variable count with value 0
istore_1 stores stack value (0 right now) into variable 1
iload_1 loads int value from variable 1 (0 right now) onto the stack
zinc 1, 1 increments by 1 variable 1 (count = 1 right now)
istore_1 stores stack value (0 right now from step #3) into variable 1
return
Now it should be pretty clear how count = count++ gets compiled in Java.

I slightly modified your code and I have made it to work
public class sample {
public static void main(String[] b){
int count = 0,a=0;
for (int i = 0; i < 3; i++){
count++;
System.out.println(count);
}
}
}
You don't have to reassign the value of count++ to count. Java will do it for you. I added some parentheses which were missing in your code. I hope this helps.

Does a for loop's while section execute each pass or only once in java?

for example would this be constant or change with each pass?
for(int i = 0; i < InputStream.readInt(); i++)

for(int i = 0; // executed once
i < InputStream.readInt(); // executed before each loop iteration
i++ // executed after each loop iteration
) {
....
}

The first section is executed once before the looping starts. The second section is checked before every loop and if it is true, the loop gets executed, if false the loop breaks. The last part is executed after every iteration.

It executes every time. The for syntax is sugar for
int i = 0
while(true)
{
if(!(i < InputStream.readInt()))
{
break;
}
// for body
i++
}

For times when a control-flow diagram is actually the best graphical representation of a concept.
http://upload.wikimedia.org/wikipedia/commons/0/06/For-loop-diagram.png
I think the main issue is the question: does
i < InputStream.readInt();
get executed each loop iteration? Yes, it does.
In this case it's not changing any sensitive variable, the only variable actually changing in your code is i, but InputStream.readInt() will be run each iteration to make the comparison and will therefore run readInt() again on InputStream.
What about something like:
for (int i=0; i < xObj.addOne().parseInt(); i++)
(given the method addOne returns a string representation of an integer one greater)
Is my "check" incrementing the value that would be incremented if I called xObj.addOne() like normal? Yes. and does it stay incremented to the next loop iteration? Yes.
It's just like doing
int x = 0;
for (int i=0; i < ++x; i++);
This will never terminate, as ++x is always greater than x (which is also i)
What about a nontrivial example?
int x = 6;
for (int i=0; i < x--; i++) {
System.out.print(i+" ");
}
outputs
0 1 2