Có sự khác biệt giữa x ++ và ++ x trong java không?

Có sự khác biệt giữa ++ x và x ++ trong java không?

++ x được gọi là preincrement trong khi x ++ được gọi là postincrement.

int x = 5, y = 5;

System.out.println(++x); // outputs 6
System.out.println(x); // outputs 6

System.out.println(y++); // outputs 5
System.out.println(y); // outputs 6

Đúng

++ x tăng giá trị của x rồi trả về x
x ++ trả về giá trị của x rồi tăng

thí dụ:

x=0;
a=++x;
b=x++;

sau khi mã được chạy, cả a và b sẽ là 1 nhưng x sẽ là 2.

Chúng được gọi là toán tử hậu tố và tiền tố. Cả hai sẽ thêm 1 vào biến nhưng có sự khác biệt trong kết quả của câu lệnh.

int x = 0;
int y = 0;
y = ++x;            // result: y=1, x=1

int x = 0;
int y = 0;
y = x++;            // result: y=0, x=1

Đúng,

int x=5;
System.out.println(++x);

sẽ in 6và

int x=5;
System.out.println(x++);

sẽ in 5.

Tôi đã hạ cánh ở đây từ một trong những lần trùng lặp gần đây của nó 's, và mặc dù câu hỏi này được trả lời nhiều hơn, tôi có thể không thể giúp ích dịch ngược mã và thêm 'chưa câu trả lời khác' :-)

Để chính xác (và có thể, một chút ngữ nghĩa),

int y = 2;
y = y++;

được biên dịch thành:

int y = 2;
int tmp = y;
y = y+1;
y = tmp;

Nếu bạn lớp javacnày Y.java:

public class Y {
    public static void main(String []args) {
        int y = 2;
        y = y++;
    }
}

và javap -c Y, bạn nhận được mã jvm sau (Tôi đã cho phép tôi nhận xét phương thức chính với sự trợ giúp của Đặc tả máy ảo Java ):

public class Y extends java.lang.Object{
public Y();
  Code:
   0:   aload_0
   1:   invokespecial  #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_2 // Push int constant `2` onto the operand stack. 

   1:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
                 // value of the local variable at index `1` (`y`) to this value.

   2:   iload_1  // Push the value (`2`) of the local variable at index `1` (`y`)
                 // onto the operand stack

   3:   iinc  1, 1 // Sign-extend the constant value `1` to an int, and increment
                   // by this amount the local variable at index `1` (`y`)

   6:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
                 // value of the local variable at index `1` (`y`) to this value.
   7:   return

}

Do đó, cuối cùng chúng ta có:

0,1: y=2
2: tmp=y
3: y=y+1
6: y=tmp

Khi xem xét những gì máy tính thực sự làm ...

++ x: nạp x từ bộ nhớ, cộng dồn, sử dụng, lưu trữ trở lại bộ nhớ.

x ++: nạp x từ bộ nhớ, sử dụng, cộng dồn, lưu trữ trở lại bộ nhớ.

Xét: a = 0 x = f (a ++) y = f (++ a)

trong đó hàm f (p) trả về p + 1

x sẽ là 1 (hoặc 2)

y sẽ là 2 (hoặc 1)

Và đó chính là vấn đề. Tác giả của trình biên dịch đã chuyển tham số sau khi truy xuất, sau khi sử dụng hoặc sau khi lưu trữ.

Nói chung, chỉ cần sử dụng x = x + 1. Cách đơn giản hơn.

Trong Java có sự khác biệt giữa x ++ và ++ x

++ x là một dạng tiền tố: Nó tăng biểu thức biến sau đó sử dụng giá trị mới trong biểu thức.

Ví dụ nếu được sử dụng trong mã:

int x = 3;

int y = ++x;
//Using ++x in the above is a two step operation.
//The first operation is to increment x, so x = 1 + 3 = 4
//The second operation is y = x so y = 4

System.out.println(y); //It will print out '4'
System.out.println(x); //It will print out '4'

x ++ là một dạng hậu tố: Giá trị của biến được sử dụng đầu tiên trong biểu thức và sau đó nó được tăng dần sau thao tác.

Ví dụ nếu được sử dụng trong mã:

int x = 3;

int y = x++;
//Using x++ in the above is a two step operation.
//The first operation is y = x so y = 3
//The second operation is to increment x, so x = 1 + 3 = 4

System.out.println(y); //It will print out '3'
System.out.println(x); //It will print out '4' 

Hy vọng điều này là rõ ràng. Chạy và chơi với mã trên sẽ giúp bạn hiểu.

Đúng.

public class IncrementTest extends TestCase {

    public void testPreIncrement() throws Exception {
        int i = 0;
        int j = i++;
        assertEquals(0, j);
        assertEquals(1, i);
    }

    public void testPostIncrement() throws Exception {
        int i = 0;
        int j = ++i;
        assertEquals(1, j);
        assertEquals(1, i);
    }
}

Có, sử dụng ++ X, X + 1 sẽ được sử dụng trong biểu thức. Sử dụng X ++, X sẽ được sử dụng trong biểu thức và X sẽ chỉ được tăng lên sau khi biểu thức đã được đánh giá.

Vì vậy, nếu X = 9, sử dụng ++ X, giá trị 10 sẽ được sử dụng, ngược lại, giá trị 9.

Nếu nó giống như nhiều ngôn ngữ khác, bạn có thể muốn thử đơn giản:

i = 0;
if (0 == i++) // if true, increment happened after equality check
if (2 == ++i) // if true, increment happened before equality check

Nếu điều trên không xảy ra như vậy, chúng có thể tương đương

Có, giá trị trả về lần lượt là giá trị sau và trước khi tăng.

class Foo {
    public static void main(String args[]) {
        int x = 1;
        int a = x++;
        System.out.println("a is now " + a);
        x = 1;
        a = ++x;
        System.out.println("a is now " + a);
    }
}

$ java Foo
a is now 1
a is now 2

OK, tôi đã hạ cánh ở đây vì gần đây tôi đã gặp vấn đề tương tự khi kiểm tra việc triển khai ngăn xếp cổ điển. Chỉ xin nhắc lại rằng điều này được sử dụng trong việc triển khai dựa trên mảng của Stack, nhanh hơn một chút so với danh sách liên kết.

Mã bên dưới, kiểm tra chức năng push và pop.

public class FixedCapacityStackOfStrings
{
  private String[] s;
  private int N=0;

  public FixedCapacityStackOfStrings(int capacity)
  { s = new String[capacity];}

  public boolean isEmpty()
  { return N == 0;}

  public void push(String item)
  { s[N++] = item; }

  public String pop()
  { 
    String item = s[--N];
    s[N] = null;
    return item;
  }
}

Có, có một sự khác biệt, trong đó x ++ (vị trí), giá trị của x sẽ được sử dụng trong biểu thức và x sẽ được tăng lên 1 sau khi biểu thức đã được đánh giá, mặt khác ++ x (đặt trước), x + 1 sẽ được sử dụng trong biểu thức. Lấy một ví dụ:

public static void main(String args[])
{
    int i , j , k = 0;
    j = k++; // Value of j is 0
    i = ++j; // Value of i becomes 1
    k = i++; // Value of k is 1
    System.out.println(k);  
}

Câu hỏi đã được trả lời, nhưng tôi cũng cho phép tôi bổ sung thêm.

Trước hết ++ có nghĩa là tăng một và - có nghĩa là giảm một.

Bây giờ x ++ có nghĩa là Phần tăng x sau dòng này và ++ x có nghĩa là Phần tăng x trước dòng này.

Kiểm tra ví dụ này

class Example {
public static void main (String args[]) {
      int x=17,a,b;
      a=x++;
      b=++x;
      System.out.println(“x=” + x +“a=” +a);
      System.out.println(“x=” + x + “b=” +b);
      a = x--;
      b = --x;
      System.out.println(“x=” + x + “a=” +a);
      System.out.println(“x=” + x + “b=” +b);
      }
}

Nó sẽ cho kết quả sau:

x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17

Với i ++, nó được gọi là postincrement và giá trị được sử dụng trong bất kỳ ngữ cảnh nào sau đó tăng dần; ++ i là preincrement tăng giá trị trước rồi sử dụng nó trong ngữ cảnh.

Nếu bạn không sử dụng nó trong bất kỳ ngữ cảnh nào, bạn sử dụng gì cũng không quan trọng, nhưng postincrement được sử dụng theo quy ước.

Có một sự khác biệt lớn.

Vì hầu hết các câu trả lời đã chỉ ra lý thuyết, tôi muốn chỉ ra một ví dụ dễ hiểu:

int x = 1;
//would print 1 as first statement will x = x and then x will increase
int x = x++;
System.out.println(x);

Bây giờ chúng ta hãy xem ++x:

int x = 1;
//would print 2 as first statement will increment x and then x will be stored
int x = ++x;
System.out.println(x);