Is it valid to assign a value to a variable inside println() function in Java?

I am a new guy to Java and programming and I am trying this piece of code:

public class Main {
    public static void main(String[] args){
        int x = 10;
        System.out.println(x = 1);
    }
}

It did compile and print out "1", but my IntelliJ said that the first x variable is never been accessed and the second x is redundant. Once I remove the first x variable:

public class Main {
    public static void main(String[] args){
        System.out.println(x = 1);
    }
}

This is surely incorrect but according to my IDE the int x = 10; was never been used. It seems that the only usage of this statement is to provide a declaration of x*. Am I right? Is it ever possible to assign a value to a variable in System.out.println()?

First of all: Don't do this. Modifying a variable in a print statement violates the principle of least surprise.

You first example is indeed legal Java code. The issue is that you have managed to confuse Intellij's code for generating warnings about unused variables. Not entirely surprising ... given that what you code is doing is something that no programmer ought to contemplate doing (IMO!). This is an obscure Intellij bug.

^{(Or maybe not a bug. After all, the variable is never referred to after the assignment. Even though the value that was written into the variable is being used. Either way, you did something bizarre (IMO) and got a warning. Solution: don't do it.)}

The second example is indeed not legal Java code. The x variable must be declared.

> It seems that the only usage of this statement is to provide a declaration of x. Am I right?

Correct.

> Is is ever possible to assign a value to a variable in System.out.println()?

Yes. That's what the first example does. What you are seeing is Warning, not an Error. Intellij's Java compiler is actually generating bytecodes ... which run and behave as one would expect them to. (Modulo the total unexpectedness of seeing an assignment expression in a print call in the first place!)

There are multiple ways to debug this.
I would recommend to print value of x before assigning new values. This is how you can use the existing value of x. After using it you can assign new value to x.

int x = 10;
System.out.println("x before assigning new Value :  "+x+"  And X after assigning new Value : "+(x = 1));

Output :

x before assigning new Value :  10  And X after assigning new Value : 1.

Your first example printed 1 because the assignment operation x = 1 actually returns the value of 1. IntelliJ thinks that you didn't access the value of x because you didn't; you only accessed the return value of x = 1.

Yes, I think writing System.out.println(x = 1) will assign the value 1 to x. However, as other answers have stated, don't do this.

I haven't checked your first example for warnings in IntelliJ, but your second example does not compile, nor should it, because x is never declared.

Your first example does indeed "access" x, as you will see if you modify your code to:

public class Main {
    public static void main(String[] args){
        int x = 10;
        System.out.println(x = 1);
        System.out.println(x);
    }
}

IntelliJ is probably warning you that your construct is "useless", since the initial value of x is never used, and the "correct" equivalent code would be:

public class Main {
    public static void main(String[] args){
        System.out.println(10);
    }
}

As far as whether you should assign to a variable inside a println statement, this is an opinion, but I think that Java programmers in general would agree that you should not. It's "legal", i.e. will compile, but it is an unexpected construct, so might easily be missed by someone reading the code.