Have a look at this code
Integer x = 5;
Integer y = 2;
Integer xy = x+y;
System.out.println("xy = " + xy); // outputs: 7
System.out.println("xy2 = " + xy2); // outputs: 7
x++;
System.out.println("xy = " + xy); // outputs: 7
System.out.println("xy2 = " + xy2); // outputs: 7
How can I get the code to output 8 without using a method that calculates it for you?
An Integer in Java is immutable. You can not change its value. In addition, it's a special autoboxing type to provide an Object wrapper for the int primitive.
In your code, for example, x++ does not modify the Integer object x is referencing. It un-autoboxes it to a primitive int, post-increments it, re-autoboxes it returning a new Integer object and assigns that Integer to x.
Edit to add for completeness: Autoboxing is one of those special things in Java that can cause confusion. There's even more going on behind the scenes when talking about memory / objects. The Integer type also implements the flyweight pattern when autoboxing. Values from -128 to 127 are cached. You should always use the .equals() method when comparing Integer objects.
Integer x = 5;
Integer y = 5;
if (x == y) // == compares the *reference (pointer) value* not the contained int value
{
System.out.println("They point to the same object");
}
x = 500;
y = 500;
if (x != y)
{
System.out.println("They don't point to the same object");
if (x.equals(y)) // Compares the contained int value
{
System.out.println("But they have the same value!");
}
}
See: Why aren't Integers cached in Java? for more info (and of course the JLS)
You need to update xy after modifying x. So:
x++;
xy = x + y;
xy2 = x + y;
In Java you'll need to update a variable yourself if you want the value to change. It's not like other languages where you express a relationship between two variables and this relationship is maintained whenever a variable changes.
The expression:
xy = x + y
doesn't mean that now xy is depends on the values of x and y (if they changed, xy is changed too). You can see it as follows: the value of the expression x + y is inserted into xy.
Therefore, you must increase the value of x (by x++), before your set the value of xy.
I'm new to java, and I'm not really sure of the context for this question, but if all you want to do is output 8, you can just make it xy++ instead of x++.
Integer x = 5;
Integer y = 2;
Integer xy = x+y;
int xy2 = x+y; // just testing to see if it makes a difference
System.out.println("xy = " + xy); // outputs: 7
System.out.println("xy2 = " + xy2); // outputs: 7
**xy++;**
System.out.println("xy = " + xy); // **outputs: 8**
System.out.println("xy2 = " + xy2); // outputs: 7
Related
The following code is designed to factorize a number typed into the variable x.
public class testMod{
public static void main(String[]args){
double x = 11868681080091051216000;
StringBuilder output = new StringBuilder("1 * ");
for(double y = 2; y <= x; y++){
while (x % y == 0) {
System.out.print("Calculating... \n");
String printNumber = y + " * ";
x = x / y;
output.append(printNumber);
System.out.print(output.substring(0, output.length() - 2) + "\n");
}
}
}
}
The problem is that the compiler treats 11868681080091051216000 as an int, regardless of the attempt to assign it to a double. As such, it's out of range.
To specify a double literal, you can simply append D to the end – but do note that you'll lose precision this way:
double x = 11868681080091051216000D;
System.out.println(x); // prints 186868108009105E22
If you need the full precision, you can use a BigInteger instead, but you'll still need to specify that number in expressions that Java can handle, such as a product of its factors.
public class test{
public static void main(String[] args) {
Integer i = new Integer(400);
Integer x = i;
i = i + 1;
x == i;
}
}
Can anybody help me to understand the memory's changed about heap and stack. If x == i compares memory's address ?
The only line which is not self-explanatory here is:
i = i + 1;
Because of autoboxing, this line is actually equivalent to:
i = Integer.valueOf(i.intValue() + 1);
^ auto-unboxing
^ autoboxing
So the intValue of i is moved to the stack; 1 is added; then a new instance of Integer may be created on the heap (since values as high as 401 are not guaranteed to be cached by Integer internally).
As for x == i: assuming you mean something like
System.out.println(x == i);
That would always print false, since x and i are different instances.
example: i point to address a1;
x = i means x point to address a1;
i = i + 1 means x point to address a2;
so x == i will return false as a1 doesn't equals a2.
Please someone explain the ("x = " + x) part of the code.
public class While-With-Nested-If {
public static void main(String [] args) {
int x = 1;
while(x < 100) {
System.out.println("x = " + x);
if(x % 2 == 0) {
x++;
} else {
x *= 2;
}
}
}
}
In this case the operator is used to concatenate a string with the string representation of x.
It depends on the operand type.
For String type operands it creates a new String instance (String objects are immutable) and assigns to it the concatenation of two operands.
For numeric types it works as addition operator.
In this case, it concatenates a String with the string representation of x. For example: x = 42;
The "+" operator acts as syntactic sugar for the concatenation operator in regards to String operations.
It is used to concatenate the two strings in your case.
When you write
String a = b + c + d;
then it gets converted into:
String a = new StringBuilder(b).append(c).append(d).toString();
You may refer Oracle docs for more details
In this code block while loop will iterate till x is less than 100 in order to print all the values of x during "while" loop executes the System.out.println("x = " + x); is used.
Here java will send each value of x to output console by appending it to the "x = " string(text) so on each iteration of while loop you will get output on console like
x = 1
x = 2
x = 3
and so on...
x = 99
The + operator concatenates if the operands' type is string, and it performs summing if the operands are ints, floats or doubles.
Here is the out put:
X = 1, X = 2, X = 3, X = 6, X = 7, X = 14, X = 15, X = 30, X = 31, X = 62, X = 63...
Is it possible for me to do something like the following below in order to save time from doing if else statement?
int x = 1;
int y = 2;
char z = '+';
System.out.println(x + z + y); //e.g. 1 + 2 i.e. 3
Please advise.
You can't. In your expression, the '+' char is converted to its int value. (The result of that expression would be 46: 1 + 43 + 2).
You'd have to use an if (or switch) statement:
int x = 1;
int y = 2;
char z = '+';
if (z == '+') System.out.println(x + y);
else if (z == '-') System.out.println(x - y);
// else if (z == '*') ... and so on
If you are only interested in the result, you can evaluate the String directly using Java's JavaScript ScriptEngine:
import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
public class Eval {
public static void main(String[] args) throws Exception {
ScriptEngineManager s = new ScriptEngineManager();
ScriptEngine engine = s.getEngineByName("JavaScript");
int x = 1;
int y = 2;
char z = '+';
String exp = "" + x + z + y;
System.out.println(engine.eval(exp));
}
}
Output:
3.0
Note: there can be some issues with the use of ScriptEngine. So do not allow the user to enter the expression to be evaluated directly. Using with variables (x, y and z like you do) takes care of this problem, though.
No, that wouldn't work as expected. (it will compile and run, but since the unicode value of + is 0x2B, or 43, and a char is treated like a number in this case, your expression x + z + y evaluates to 1 + 43 + 2, so it prints 46) You can use if/else or switch statements to evaluate what operation to do, which would work for simple inputs, or you can look at a more general expression parsing library, e.g. exp4j or jexel.
That will compile but not run in the way you expect.
z will be converted to an int, which will be that character's value in the default charset (most likely ASCII).
As an example, on my computer that results in "46"
The output should be 1 + 2 + 43 = 46
For char, it will take the Ascii value of '+'
public void increment(){
int zero = 0;
int oneA = zero++; // Compiles
int oneB = 0++; // Doesn't compile
int oneC = getInt()++; // Doesn't compile
}
private int getInt(){
return 0;
}
They are all int's, why won't B & C compile? Is it to do with the way ++ operator differs from = 0 + 1;?
Invalid argument to operation ++/--
i++ is an assignment to a variable i.
In your case, zero++ is an equivalent to zero = zero + 1. So 0++ would mean 0 = 0 + 1, which makes no sense, as well as getInt() = getInt() + 1.
More accurately :
int oneA = zero++;
means
int oneA = zero;
zero = zero + 1; // OK, oneA == 0, zero == 1
int oneB = 0++;
means
int oneB = 0;
0 = 0 + 1; // wrong, can't assign value to a value.
int oneC = getInt()++;
means
int oneC = getInt();
getInt() = getInt() + 1; // wrong, can't assign value to a method return value.
From a more general point of view, a variable is a L-value, meaning that it refers to a memory location, and can therefore be assigned. L in L-value stands for left side of the assignment operator (i.e. =), even if L-values can be found either on the left side or the right side of the assignment operator (x = y for instance).
The opposite is R-value (R stands for right side of the assignment operator). R-values can be used only on the right side of assignment statements, to assign something to a L-value. Typically, R-values are literals (numbers, characters strings...) and methods.
Because as stated in JLS:
The result of the postfix expression must be a variable of a type that
is convertible (§5.1.8) to a numeric type, or a compile-time error
occurs.
getInt() is not int
getInt() returns int
++ operator does two things increment + assignment
So for ++ operator to work you need a variable to store the result of increment operation which 0 and getInt() both are not.
The pre- and post- operators only operate on variables or lvalues as they are called. lvalue is short for left value, i.e. something that can stand to the left in an assignment.
In your example:
zero = 1; // OK
0 = 1; // Meaningless
getInt() = 1; // Also meaningless
//jk
Both B and C make the compiler say:
unexpected type, required: variable, found: value
So you can't increment a value, only a variable.
Why doesn't the post increment operator work on a method that returns an int?
Because it is a getter method, and it doesn't make sense to change a value via getter.
int z = x + y++;
is equivalent to:
int z = x + y;
y = y + 1;
so it is not valid to have something like:
int z = x + getY()++;
which is equivalent to:
int z = x + getY();
getY() = getY() + 1; // invalid!
0++
It is equivalent to 0 = 0 + 1; and certainly it is not possible.
i.e. it has to be l-value to assign to it.
getInt()++;
Similar reason here.
Because 0 is a rValue (i.e. You can use it only from right of the assignment operator) not a lValue.
++ operator increments the value and sets it to itself therefore 0++ will give You an error.
My answer its kind of "out of the box".
When I have doubt about an operator usage, I think "which its the overloaded function equivalent" of this operator ?
I, know, that Java operators doesn't have operator overloading, its just an alternative way to make a solution.
In this case:
...
x++;
...
should be read as:
...
int /* function */ postincrement (/* ref */ int avalue)
{
int Result = avalue;
// reference value,
avalue = avalue + 1;
return Result;
}
...
postincrement(/* ref */ x);
...
And:
...
++x;
...
...
int /* function */ preincrement (/* ref */ int avalue)
{
// reference value,
avalue = avalue + 1;
int Result = avalue;
return Result;
}
...
preincrement(/* ref */ x);
...
So, both, versions of "++", work as a function that receives a variable parameter by reference.
So, a literal value like "0++" or a function result like "getInt()++", are not a variable references.
Cheers.
postincrement and preincrement can apply only with the help of variable.So the first case compile.
Since function return is RHS expression and pre/post increment/decrement operations can be applied to LHS expressions only.