Bài 12. Những Phép Toán Một Ngôi Trong Java | Tự Học Java Căn Bản

Phép Toán Một Ngôi Trong Java Là Gì?

Trong lập trình Java, các phép toán một ngôi (Unary Operators) được sử dụng để thực hiện các phép toán trên một toán hạng duy nhất. Những phép toán này rất phổ biến và dễ sử dụng khi cần thay đổi giá trị của một biến hoặc thực hiện một số phép toán đơn giản.

Các phép toán một ngôi bao gồm:

• Phép toán tăng (++)
• Phép toán giảm (--)
• Phép toán đảo ngược giá trị boolean (!)
• Một số phép toán khác như phép đảo dấu (-)

Cùng khám phá chi tiết ngay sau đây nhé.

Phép Toán Tăng Giảm Một Ngôi

Phép toán tăng và giảm một ngôi được sử dụng để thay đổi giá trị của một biến nguyên thủy (primitive) theo một đơn vị là 1. Các phép toán này thường được sử dụng để cập nhật các giá trị trong vòng lặp hoặc thay đổi giá trị của biến trong các chương trình.

Tăng đơn (Tiền tố và Hậu tố)

• Tăng đơn (tiền tố): ++a
  Phép toán này sẽ tăng giá trị của biến a lên 1 trước khi sử dụng giá trị của nó trong biểu thức.

• Tăng đơn (hậu tố): a++
  Phép toán này sẽ tăng giá trị của biến a lên 1 sau khi sử dụng giá trị của nó trong biểu thức.

Ví dụ:

public class UnaryOperators {
    public static void main(String[] args) {
        int a = 5;

        // Tăng đơn tiền tố
        System.out.println("++a: " + (++a));  // Tăng trước, a = 6

        // Tăng đơn hậu tố
        System.out.println("a++: " + (a++));  // Tăng sau, a = 6, nhưng giá trị là 6
        System.out.println("a: " + a);        // a = 7
    }
}

Kết quả:

++a: 6
a++: 6
a: 7

Giảm đơn (Tiền tố và Hậu tố)

• Giảm đơn (tiền tố): --a
  Phép toán này sẽ giảm giá trị của biến a xuống 1 trước khi sử dụng giá trị của nó trong biểu thức.

• Giảm đơn (hậu tố): a--
  Phép toán này sẽ giảm giá trị của biến a xuống 1 sau khi sử dụng giá trị của nó trong biểu thức.

Ví dụ:

public class UnaryOperators {
    public static void main(String[] args) {
        int a = 5;

        // Giảm đơn tiền tố
        System.out.println("--a: " + (--a));  // Giảm trước, a = 4

        // Giảm đơn hậu tố
        System.out.println("a--: " + (a--));  // Giảm sau, a = 4, nhưng giá trị là 4
        System.out.println("a: " + a);        // a = 3
    }
}

Kết quả:

--a: 4
a--: 4
a: 3

Phép Toán Đảo Ngược (NOT)

Phép toán đảo ngược (NOT) được sử dụng để thay đổi giá trị boolean của một biến. Phép toán này có thể đảo ngược giá trị true thành false và ngược lại. Ký hiệu của phép toán này trong Java là !.

• Đảo ngược giá trị boolean: !a
  Nếu a là true, thì !a sẽ trả về false. Nếu a là false, thì !a sẽ trả về true.

Ví dụ:

public class UnaryOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("!a: " + !a);  // false
        System.out.println("!b: " + !b);  // true
    }
}

Kết quả:

!a: false
!b: true

Một Số Phép Toán Khác

Phép Đảo Dấu (-)

Ngoài các phép toán tăng (++) và giảm (--), Java còn có phép đảo dấu (-), được sử dụng để thay đổi dấu của một số. Phép toán này đặc biệt hữu ích khi cần chuyển đổi giữa số dương và số âm một cách nhanh chóng.

Khi áp dụng dấu - trước một số hoặc biến kiểu số, giá trị của nó sẽ bị đảo ngược:

• Nếu số đó là dương, nó sẽ trở thành âm.
• Nếu số đó là âm, nó sẽ trở thành dương.

Ví dụ:

public class UnaryOperatorExample {
    public static void main(String[] args) {
        int a = 5;
        int b = -10;

        System.out.println("Giá trị ban đầu của a: " + a);
        System.out.println("Giá trị sau khi đảo dấu của a: " + (-a));

        System.out.println("Giá trị ban đầu của b: " + b);
        System.out.println("Giá trị sau khi đảo dấu của b: " + (-b));
    }
}

Kết quả:

Giá trị ban đầu của a: 5
Giá trị sau khi đảo dấu của a: -5
Giá trị ban đầu của b: -10
Giá trị sau khi đảo dấu của b: 10

Toán tử Bitwise NOT (~)

Toán tử bitwise NOT (~) là một toán tử một ngôi trong Java, hoạt động trực tiếp trên các bit nhị phân của một số nguyên. Toán tử này đảo ngược tất cả các bit trong biểu diễn nhị phân của số đó, tức là:

• Bit 1 trở thành 0
• Bit 0 trở thành 1

~x = -(x + 1)

Điều này có nghĩa là khi áp dụng ~ cho một số x, kết quả thu được sẽ là nghịch đảo của x rồi trừ đi 1.

Ví dụ:

public class BitwiseNotExample {
    public static void main(String[] args) {
        int num = 5;       // 0000 0101 (5 trong nhị phân)
        int result = ~num;  // 1111 1010 (-6 trong nhị phân)

        System.out.println("Giá trị ban đầu: " + num);
        System.out.println("Kết quả sau khi dùng ~: " + result);
    }
}

Kết quả:

Giá trị ban đầu: 5
Kết quả sau khi dùng ~: -6

Toán tử ép kiểu ((type))

Toán tử ép kiểu ((type)) được sử dụng để chuyển đổi kiểu dữ liệu của một biến từ kiểu này sang kiểu khác.

(type) variable

Trong đó:

• type là kiểu dữ liệu muốn chuyển đổi.
• variable là biến cần chuyển đổi.

Ví dụ:

public class TypeCastingExample {
    public static void main(String[] args) {
        double pi = 3.14;
        int intPi = (int) pi;  // intPi = 3

        System.out.println("Giá trị ban đầu: " + pi);
        System.out.println("Giá trị sau khi ép kiểu: " + intPi);
    }
}

Kết quả:

Giá trị ban đầu: 3.14
Giá trị sau khi ép kiểu: 3

Phép Toán Một Ngôi Và Các Ứng Dụng Thực Tiễn

Phép toán một ngôi được sử dụng rất nhiều trong lập trình, đặc biệt là khi xử lý các vòng lặp hoặc cập nhật giá trị của các biến. Những phép toán này giúp làm gọn mã nguồn và dễ dàng thực hiện các phép toán đơn giản.

Dùng trong Vòng Lặp

Phép toán tăng và giảm đơn rất hữu ích trong việc kiểm soát các vòng lặp. Chúng ta có thể sử dụng các phép toán này để thay đổi giá trị của biến điều khiển vòng lặp sau mỗi lần lặp.

Ví dụ:

public class UnaryOperators {
    public static void main(String[] args) {
        for (int i = 0; i < 5; ++i) {
            System.out.println("i: " + i);  // Tăng i mỗi lần lặp
        }
    }
}

Dùng trong Cập Nhật Biến

Phép toán tăng và giảm giúp làm gọn mã khi chúng ta muốn cập nhật giá trị của một biến mà không cần viết lại biểu thức đầy đủ.

Ví dụ:

public class UnaryOperators {
    public static void main(String[] args) {
        int x = 10;

        // Cập nhật biến bằng phép toán một ngôi
        x++;  // Tăng giá trị của x lên 1
        System.out.println("Giá trị x sau khi tăng: " + x);  // 11

        x--;  // Giảm giá trị của x xuống 1
        System.out.println("Giá trị x sau khi giảm: " + x);  // 10
    }
}

Kết quả:

Giá trị x sau khi tăng: 11
Giá trị x sau khi giảm: 10

Kết Luận

Các phép toán một ngôi trong Java, bao gồm các phép toán tăng, giảm và đảo ngược, là công cụ mạnh mẽ giúp lập trình viên dễ dàng thay đổi giá trị của các biến. Chúng giúp làm gọn mã nguồn và hỗ trợ trong nhiều tình huống, chẳng hạn như trong vòng lặp, cập nhật biến, và xử lý giá trị boolean. Hiểu rõ về các phép toán này sẽ giúp bạn tối ưu hóa mã và nâng cao hiệu quả lập trình trong Java.

Hy vọng rằng bài viết này đã giúp bạn nắm rõ cách sử dụng các phép toán một ngôi trong Java. Hãy thử áp dụng chúng trong các bài tập và dự án của bạn để làm quen với cách thức hoạt động của chúng!

Bài tiếp theo: Bài 13. Cách gán dữ liệu trong Java