I'm a novice in Java programming and I'm trying to guess why the output of the following code:
public class ForLoop {
public static void main(String[] args) {
int x;
for (x=1; x<=2; x++) {
x += 3;
}
System.out.print(x);
}
}
is 5 and not 7! For the first iteration, 1 is added to 3 (result: 4) and it is stored in the variable x so x is 4. In the second iteration, we add 3 to 4 and we must obtain 7. The error might be easy to find but I can't catch it. Please help and thanks.
This part:
for (x=1; x<=2; x++)
means that x will be incremented at the end of each iteration. So, in the first iteration, 3 is added to x because of this:
x += 3;
which results in a value of 4. Then, at the end of that iteration, x is incremented by 1, which comes to 5. Since 5 is greater than 2, the loop is then closed.
Big problem here using x as your iterator and your variable to update. This is what the computer is evaulating.
When you are inside the for loop, x is initially 1, then you add three to it, and then your iterator on the for loop adds 1 to it afterwards (making it five). At that point, your condition, (x<=2) is false for the for loop is complete.
change it to this and you will get your desired result:
public class ForLoop {
public static void main(String[] args) {
int x = 1;
for (int y = 0; y <= 1; y++) {
x += 3;
}
System.out.print(x);
}
}
In first pass the body is carried out, there x becomes 4. Then the incrementation is carried out. (The 3rd parameter of for loop) which results x to be 5.
In the second pass the condition is unmet as x is already 5 there but less than or equals to 2 is required to run the loop. So instead the loop will discontinue and x will be printed 5.
The code
int x;
for (x=1; x<=2; x++) {
x += 3;
}
works as follows:
int x;
x = 1; // for-initialization
while (x <= 2) { // for-condition
x += 3; // for-body
x++ // for-increment
}
Particularly:
the condition is tested before the loop body, and in your case
the loop body has an effect on the condition.
After the first iteration x is 4 as you say, but then x++ is executed, so x becomes 5. 5 is bigger than 2 (x<=2), so iteration stops.
Related
From the program below or here, why does the last call to System.out.println(i) print the value 7?
class PrePostDemo {
public static void main(String[] args) {
int i = 3;
i++;
System.out.println(i); // "4"
++i;
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
}
}
i = 5;
System.out.println(++i); //6
This prints out "6" because it takes i, adds one to it, and returns the value: 5+1=6. This is prefixing, adding to the number before using it in the operation.
i = 6;
System.out.println(i++); //6 (i = 7, prints 6)
This prints out "6" because it takes i, stores a copy, adds 1 to the variable, and then returns the copy. So you get the value that i was, but also increment it at the same time. Therefore you print out the old value but it gets incremented. The beauty of a postfix increment.
Then when you print out i, it shows the real value of i because it had been incremented: 7.
Another way to illustrate it is:
++i will give the result of the new i, i++ will give the result of the original i and store the new i for the next action.
A way to think of it is, doing something else within the expression. When you are printing the current value of i, it will depend upon whether i has been changed within the expression or after the expression.
int i = 1;
result i = ++i * 2 // result = 4, i = 2
i is evaluated (changed) before the result is calculated. Printing i for this expression, shows the changed value of i used for this expression.
result i = i++ * 2 // result = 2, i = 2
i is evaluated after the result in calculated. So printing i from this expression gives the original value of i used in this expression, but i is still changed for any further uses. So printing the value for i immediately after the expression, will show the new incremented value of i. As the value of i has changed, whether it is printed or used.
result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2
If you kept a consistent pattern and included print lines for all the values:
int i = 3;
System.out.println(i); // 3
System.out.println(i++); // 3
System.out.println(i); // "4"
System.out.println(++i); // 5
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
Think of ++i and i++ as similar to i = i+1. But it is not the same. The difference is when i gets the new increment.
In ++i , the increment happens immediately.
But if i++ is there, the increment will happen when the program goes to the next line.
Look at the code here.
int i = 0;
while(i < 10){
System.out.println(i);
i = increment(i);
}
private int increment(i){
return i++;
}
This will result in a nonending loop. Because i will be returned with the original value and after the semicolon, i will get incremented, but the returned value has not been. Therefore i will never actually returned as an incremented value.
Why wouldn't the variable have been updated?
Postfix: passes the current value of i to the function and then increments it.
Prefix: increments the current value and then passes it to the function.
The lines where you don't do anything with i make no difference.
Notice that this is also true for assignments:
i = 0;
test = ++i; // 1
test2 = i++; // 1
System.out.println(i++); // "6"
This sends println the value I had prior to this line of code (6), and then increments I (to 7).
An example of how the actual operators are implemented:
class Integer {
private int __i;
function Integer ++() { // Prefix operator i.e. ++x
__i += 1; // Increment
return this; // Return the object with the incremented value
}
function Integer ++(Integer x) { // Postfix operator, i.e., x++
__i+=1; // Increment
return x; // Return the original object
}
}
Maybe you can understand better Prefix/postfix with this example.
public class TestPrefixPostFix
{
public static void main (String[] args)
{
int x = 10;
System.out.println((x++ % 2 == 0) ? "yes " + x: " no " + x);
x = 10;
System.out.println((++x % 2 == 0) ? "yes " + x: " no " + x);
}
}
This may be easy to understand:
package package02;
public class C11PostfixAndPrefix {
public static void main(String[] args) {
// In this program, we will use the value of x for understanding prefix
// and the value of y for understaning postfix.
// Let's see how it works.
int x = 5;
int y = 5;
Line 13: System.out.println(++x); // 6 This is prefixing. 1 is added before x is used.
Line 14: System.out.println(y++); // 5 This is postfixing. y is used first and 1 is added.
System.out.println("---------- just for differentiating");
System.out.println(x); // 6 In prefixing, the value is same as before {See line 13}
System.out.println(y); // 6 In postfixing, the value increases by 1 {See line 14}
// Conclusion: In prefixing (++x), the value of x gets increased first and the used
// in an operation. While, in postfixing (y++), the value is used first and changed by
// adding the number.
}
}
It prints 7 for the last statement, because in the statement above, its value is 6 and it's incremented to 7 when the last statement gets printed.
This might help... it also took my to understand this puzzle.
public class Main {
public static void main(String[] args) {
int x = 5;
int y = 5;
System.out.println(++x);
System.out.println(y++);
System.out.println("------");
System.out.println(x);
System.out.println(y);
}
}
Well, think of it in terms of temporary variables.
i = 3;
i ++; // Is equivalent to: temp = i++; and so, temp = 3 and then "i" will increment and become i = 4;
System.out.println(i); // Will print 4
Now,
i = 3;
System.out.println(i++);
is equivalent to
temp = i++; // 'temp' will assume a value of the current "i", after which "i" will increment and become i = 4
System.out.println(temp); // We're printing 'temp' and not "i"
Was doing some Java practices and I got stuck at this particular question, I am given the following code:
public class DistanceSeparator {
public static void main(String[] args) {
printSeparatorSequence(3);
printSeparatorSequence(5);
printSeparatorSequence(8);
}
public static void printSeparatorSequence(int numberOfElements) {
for () {
}
System.out.println();
} //end of method printSeparatorSequence
} // end of class
And I am supposed to modify the code using A SINGLE FOR LOOP to show that:
If numberOfElements = 5
1 3 7 13 21
If numberOfElements = 7
1 3 7 13 21 31 43
Each showing an increment of + 2, +4, +6, +8, +10 and +12
The final output is to be this:
1 3 7
1 3 7 13 21
1 3 7 13 21 31 43 57
I just can't seem to get my head around how to get that outcome, and this is after 2hours of trying (yes I am that bad). Any help, please?
edit This was what I had, before deciding to seek help, it's obviously not working.
int j = 0;
for (int i = 1; i <= numberOfElements; i++) {
j = i * 2; // + by how much
int z = i + j; //sum
System.out.print(z + "");
}
edit 2 now I get it, oh my, to think I was so close. Guess I was too cluttered after being stuck for some time. Thanks a ton!
Here is the code to accomplish result you expected.
int current = 1;
for(int i = 0; i < numberOfElements; i++) {
current += i*2;
System.out.print(current + " ");
}
You just need to keep another variable to keep track of the difference (the change), and then constantly update it by the power of 2 of the iteration, i.e. for the first loop only increase it by 2^1, then by 2^2, then 2^3 and so on).
An example of how to achieve that:
for (int i = 0, diff = 0; i < numberOfElements; i++, diff += 2*i) {
System.out.print((1 + diff) + " ");
}
UPDATE: After you've edited your question with your code segment, you can see your problem was with this line:
int z = i + j; //sum
Since both i and j advance with each iteration, you lose your offset (you constantly reset it). You need to keep it static (like in my example: 1), and only update j by 2*i each iteration, otherwise your "base" for calculation is constantly changing and the formula doesn't hold anymore.
In your case, you are regenerating int z everytime the loop is called,
All you have to do is define z outside the loop and instantiate z as 1 and also, you are not retaining the previous values of z so that's why it wasn't working. So it should be z = z + j and put this line below the print statement and you are done.
Here is an snippet of code which would help you my way:
int j = 1;
for(int i=1; i<=numberOfElements; i++) {
System.out.println(j);
j = j + 2*i;
}
And, here is an snippet of code which would help you your way:
int j = 0;
int z = 1;
for (int i = 1; i <= numberOfElements; i++)
{
j = i * 2; // + by how much
System.out.print(z + " ");
z = z + j; //sum
}
Note the trend.
You are adding a multiple of 2 to the previous number to get the next number. The multiple of 2 to be added depends upon the position of the number. For example, to get the 1st number, you add 2 x 0 to 1. To get the 2nd number, you add 2 x 1 to the previous number (that gives 3). To get the 3rd number, you add 2 x 2 to the previous number (that gives 7). To get the 4th number, you add 2 x 3 to the previous number (that gives 13).
To get the number at nth position, you add 2 x (n-1) to the previous number.
Now take a look at the example below, keeping the above explanation in mind.
public static void printSeparatorSequence(int numberOfElements) {
int number = 1;
for (int i = 0; i<numberOfElements;i++) {
number = number + 2 * i;
System.out.print(number);
}
System.out.println();
} //end of method printSeparatorSequence
} // end of class
This is the solution of your problem. I have discussed the code by the comment lines given within the code.
public class DistanceSeparator
{
/* Main Method */
public static void main(String[] args)
{
/* printSeparatorSequence Function is Called */
printSeparatorSequence(3);
printSeparatorSequence(5);
printSeparatorSequence(8);
}
/* printSeparatorSequence Function Definition */
public static void printSeparatorSequence(int NumberOfElements)
{
/* variable j is used to get the multiples of
2 by multiplying with variable i within the for loop
and variable sum is used to get the total value */
int j=2,sum=1;
for(int i=0;i<NumberOfElements;i++)
{
sum=sum+(j*i);
/* Here total sum is printed with a space */
System.out.print(sum+" ");
}
/* It is used for new line */
System.out.println();
}
}
I'm new to Java.
I can't seem to understand why these two codes produce different outputs.
Please explain this to me.
What is the difference of y<=x; and y<=5;. As you can see the x is 5 too, I don't understand why I get different outputs.
for (int x = 0; x < 5; x++) {
for (int y = 1; y <=x ; y++) {
System.out.print("x");
}
for (int g = 4; g >= x; g--) {
System.out.print("*");
}
System.out.println();
}
Output:
*****
x****
xx***
xxx**
xxxx*
Code:
for (int x = 0; x < 5; x++) {
for (int y = 1; y <= 5; y++) {
System.out.print("x");
}
for (int g = 4; g >= x; g--) {
System.out.print("*");
}
System.out.println();
}
Output:
xxxxx*****
xxxxx****
xxxxx***
xxxxx**
xxxxx*
Basically the main difference is this line:
for(int y=1; y<=x; y++)
resp.
for(int y=1; y<=5; y++)
The number of times the loop is executed is different. Namely in the first case it is variable (so the number of 'x' increases), in the second case it is fixed (5 'x' printed each time).
(edit: typo)
xstarts at 0 so the first iteration has the condition y<=0, the second will have y<=1 and so on .. till y<=5
While the second one will have y<=5in every iteration, thats why you get xxxxx in every line.
In the first code you print x times the "x" String in each row.
for(int y=1; y<=x; y++) {
System.out.print("x");
}
BTW, it prints the following (which is different than what you claim in the question):
*****
x****
xx***
xxx**
xxxx*
In the second code you print 5 times the "x" String in each row.
for(int y=1; y<=5; y++) {
System.out.print("x");
}
As you can see the x is = 5 too
No, x iterates from 0 to 4, so in each iteration of the outer for loop, it has a different value.
In your first code your for(int y=1; y<=x; y++) for iterations of outer for loop is -
for(int y=1;y<=0;++y) (for first iteration of outer loop)
for(int y=1;y<=1;++y) (for second iteration of outer loop)
for(int y=1;y<=2;++y) (for third iteration of outer loop)
for(int y=1;y<=3;++y) (for fourth iteration of outer loop)
for(int y=1;y<=4;++y) (for fifth iteration of outer loop)
But in your second code its always -
for(int y=1; y<=5; ++y)
for all iterations of outer for loop.
It is very simple the will run for 5 time times and every itreation its value will be increamented by 1 i.e. from 0 to 4.
So in first loop inner loop will have the condition like this:
for (int y = 1; y <= x; y++) {
System.out.print("x");
}
But since in first loop the value of x is 0 hence it literally means:
for (int y = 1; y <= 0; y++) {
System.out.print("x");
}
But in the last iteartion of outer loop the value of x is 4 hence this is equivalent to:
for (int y = 1; y <= 4; y++) {
System.out.print("x");
}
So it iterates 4 times.
In your first example y is first less than x = 1 and during the next iteration it will be less x= 2 ... Because x values changes with your first for loop.
For the second example however you state that y have to be less than 5 which doesn't change at all.
They are different because in the first case your x varies from 0 to 4 based on :
for(int x=0; x<5; x++)
In the case second case x is fixed at 5.
I have replaced your two inner for loops with a new stringRepeat function. It might be easier to understand this way.
public class ForLoopStarsAndCrosses {
public static void main(String[] args) {
/// the total length ot the x's and stars
final int length = 5;
// start with 1 x until one less than the length (in this case 4)
for(int x = 1; x < length; x++) {
// the number of stars equals the total length minus the number of x's
final int nbStars = length - x;
// add the x's and the stars
final String output = stringRepeat("x", x) + stringRepeat("*", nbStars);
System.out.println(output);
}
System.out.println();
}
/** Repeat the string s n times */
private static String stringRepeat(String s, int n) {
String result = "";
for (int i = 0; i < n; i += 1) {
result += s;
}
return result;
}
}
Firstly, you should understand the difference between value and variable. Value is a constant as you write 5 but variable can be changeable.
For your question, first code and first round:
x = 1, y<= 1 and output: x
for(int y=1; y<=x; y++){
System.out.print("x");
}
but for the second code and first round:
y<=5 so output is: xxxxx
for(int y=1; y<=5; y++){
System.out.print("x");
}
it is very simple.
The purpose of loops (can be for, while, do-while) is that, how many number of times the same set of statements to be executed under a specific condition. "for" is a definite loop where there will be an index starting with an integer, keep increment it until the condition is achieved. "while" is a indefinite loop where there is no index and it will be executed until the condition is achieved. "do-while" is a loop similar to "while", which will be executed atleast once and then validates the condition for the next iteration.
Based on the above details,
for(int x=0; x<5; x++){
for(int y=1; y<=x; y++){
for(int x=0; x<5; x++){
for(int y=1; y<=5; y++){
The diff between these two conditions is that,
First condition:
In the first iteration, value of x is 0 and for the second loop y is started with 1.
Here when it compares the value with x which is 0 and 1<=0 which is false, this condition is failed and the statements under Y will not be executed and the control will go back control of x.
Second condition:
In the first iteration, value of x is 0 and for the second loop y is started with 1.
Here when it compares the value with 5, 1<=5 which is true, this condition is valid and the statements under Y will be executed and the control will go back control of x until y becomes 6 and condition checked is 6<=5 which is false, this condition is failed and the statements under Y will not be executed and the control will go back control of x
Note: Due to low reputation, I can't add comments and had to contribute this as an answer. Don't downvote this, instead suggest corrections by comment on the same.
When I run this class I am not getting a the sum/average. I am getting an error listed below. I am not sure why I am getting it. I am a student very new at this.
public class DebugEight2
{
public static void main(String[] args)
{
int[] someNums = {4,17,22,8,35};
int tot;
int x;
int sum = 0;
for(x = 0; x <= someNums.length; ++x)
tot = someNums[x];
sum = sum + someNums[x];
System.out.println("Sum is " + sum);
System.out.println("Average is " + sum * 1.0 / someNums.length);
}
}
Error:
"Exception in thread "main" java.lang.ArrayIndexOutofBoundsException: 4 at DebugEight1.main (DebugEight1.java:17)"
Array index starts from 0 and goes till it's length -1 See that <= in your for loop. So this for(x = 0; x <= someNums.length; ++x) should be for(x = 0; x < someNums.length; ++x)
Problem is your loop condition, remove the equal sign like this
for(x = 0; x < someNums.length; ++x)
You should also wrapp the code which is supposed to be inside the loop into brackets (without them, only the next line after the for loop condition will be executed)
for(x = 0; x < someNums.length; ++x) {
tot = someNums[x];
sum = sum + someNums[x];
}
first you should remove = from <= someNums.length; i will look like this < someNums.length; and then change ++x to x++ if you put ++x when loop starts it will check condition < someNums.length; and then pluse one +1 to x and so on, currently your array length is 5 when loop goes on last increment its size is 6 and there is no item on 6 location thats why it is throwing exception so you have you change it ++x to x++
public class DebugEight2
{
public static void main(String[] args)
{
int[] someNums = {4,17,22,8,35};
int tot;
int x;
int sum = 0;
for(x = 0; x <someNums.length; x++) /// just change here
tot = someNums[x];
sum = sum + someNums[x];
System.out.println("Sum is " + sum);
System.out.println("Average is " + sum * 1.0 / someNums.length);
}
}
Arrays are zero based and their indices go from 0 to someNums.length -1
You not only exceeding the bounds of the array but the variable sum is being assigned outside of scope of the loop. Adjust the upper bounds of the array and add braces:
for (x = 0; x < someNums.length; x++) {
tot = someNums[x];
sum = sum + someNums[x];
}
Hope this helps
You want to iterate while x is lesser than someNums.length; since max index in array is arraysLength - 1, so change x <= someNums.length; to x < someNums.length; in for loop
There is no need for tot (I assume it should store total numbers) variable because you already have someNums.length which represents how many numbers you summed. BTW you already are calculating avg using sum and someNums.length. So you can safely remove
tot = someNums[x];
from your code.
What you did is you looped beyond the scope of the array. Try doing someNums.length, you will get the number 5.
Going to your for loop we now know that it starts at 0 and increments until it gets to 5. And the for loop is traversing over the array and is pointing at the positions in your array.
So let's traverse through your loop.
At x = 0, someNums[x] = 4.
At x = 1, someNums[x] = 17,
At x = 2, someNums[x] = 22,
At x = 3, someNums[x] = 8,
At x = 4, someNums[x] = 35,
As you can see, your array has now ended, you no longer have any more elements to traverse over. But we have previously stated that your for loop increments until it gets to 5.
So at x = 5, someNums[x] will have to give you an error since you are pointing at a position and trying to retrieve information from that position that essentially does not exist.
There are two ways to solve your problem:
You change the loop to for(int x = 0; x < someNums.length; x++)
You change the loop to for(int x = 0; x <= someNums.length - 1; x++)
These will solve your problem because they will stop your loop at 4 and not at 5, therefore you will no longer receive an error.
From the program below or here, why does the last call to System.out.println(i) print the value 7?
class PrePostDemo {
public static void main(String[] args) {
int i = 3;
i++;
System.out.println(i); // "4"
++i;
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
}
}
i = 5;
System.out.println(++i); //6
This prints out "6" because it takes i, adds one to it, and returns the value: 5+1=6. This is prefixing, adding to the number before using it in the operation.
i = 6;
System.out.println(i++); //6 (i = 7, prints 6)
This prints out "6" because it takes i, stores a copy, adds 1 to the variable, and then returns the copy. So you get the value that i was, but also increment it at the same time. Therefore you print out the old value but it gets incremented. The beauty of a postfix increment.
Then when you print out i, it shows the real value of i because it had been incremented: 7.
Another way to illustrate it is:
++i will give the result of the new i, i++ will give the result of the original i and store the new i for the next action.
A way to think of it is, doing something else within the expression. When you are printing the current value of i, it will depend upon whether i has been changed within the expression or after the expression.
int i = 1;
result i = ++i * 2 // result = 4, i = 2
i is evaluated (changed) before the result is calculated. Printing i for this expression, shows the changed value of i used for this expression.
result i = i++ * 2 // result = 2, i = 2
i is evaluated after the result in calculated. So printing i from this expression gives the original value of i used in this expression, but i is still changed for any further uses. So printing the value for i immediately after the expression, will show the new incremented value of i. As the value of i has changed, whether it is printed or used.
result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2
If you kept a consistent pattern and included print lines for all the values:
int i = 3;
System.out.println(i); // 3
System.out.println(i++); // 3
System.out.println(i); // "4"
System.out.println(++i); // 5
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
Think of ++i and i++ as similar to i = i+1. But it is not the same. The difference is when i gets the new increment.
In ++i , the increment happens immediately.
But if i++ is there, the increment will happen when the program goes to the next line.
Look at the code here.
int i = 0;
while(i < 10){
System.out.println(i);
i = increment(i);
}
private int increment(i){
return i++;
}
This will result in a nonending loop. Because i will be returned with the original value and after the semicolon, i will get incremented, but the returned value has not been. Therefore i will never actually returned as an incremented value.
Why wouldn't the variable have been updated?
Postfix: passes the current value of i to the function and then increments it.
Prefix: increments the current value and then passes it to the function.
The lines where you don't do anything with i make no difference.
Notice that this is also true for assignments:
i = 0;
test = ++i; // 1
test2 = i++; // 1
System.out.println(i++); // "6"
This sends println the value I had prior to this line of code (6), and then increments I (to 7).
An example of how the actual operators are implemented:
class Integer {
private int __i;
function Integer ++() { // Prefix operator i.e. ++x
__i += 1; // Increment
return this; // Return the object with the incremented value
}
function Integer ++(Integer x) { // Postfix operator, i.e., x++
__i+=1; // Increment
return x; // Return the original object
}
}
Maybe you can understand better Prefix/postfix with this example.
public class TestPrefixPostFix
{
public static void main (String[] args)
{
int x = 10;
System.out.println((x++ % 2 == 0) ? "yes " + x: " no " + x);
x = 10;
System.out.println((++x % 2 == 0) ? "yes " + x: " no " + x);
}
}
This may be easy to understand:
package package02;
public class C11PostfixAndPrefix {
public static void main(String[] args) {
// In this program, we will use the value of x for understanding prefix
// and the value of y for understaning postfix.
// Let's see how it works.
int x = 5;
int y = 5;
Line 13: System.out.println(++x); // 6 This is prefixing. 1 is added before x is used.
Line 14: System.out.println(y++); // 5 This is postfixing. y is used first and 1 is added.
System.out.println("---------- just for differentiating");
System.out.println(x); // 6 In prefixing, the value is same as before {See line 13}
System.out.println(y); // 6 In postfixing, the value increases by 1 {See line 14}
// Conclusion: In prefixing (++x), the value of x gets increased first and the used
// in an operation. While, in postfixing (y++), the value is used first and changed by
// adding the number.
}
}
It prints 7 for the last statement, because in the statement above, its value is 6 and it's incremented to 7 when the last statement gets printed.
This might help... it also took my to understand this puzzle.
public class Main {
public static void main(String[] args) {
int x = 5;
int y = 5;
System.out.println(++x);
System.out.println(y++);
System.out.println("------");
System.out.println(x);
System.out.println(y);
}
}
Well, think of it in terms of temporary variables.
i = 3;
i ++; // Is equivalent to: temp = i++; and so, temp = 3 and then "i" will increment and become i = 4;
System.out.println(i); // Will print 4
Now,
i = 3;
System.out.println(i++);
is equivalent to
temp = i++; // 'temp' will assume a value of the current "i", after which "i" will increment and become i = 4
System.out.println(temp); // We're printing 'temp' and not "i"