So sánh 2 biến số trong java năm 2024

Có lẽ việc so sánh giữa 2 số nguyên hay số thực trong Java thì có lẽ các bạn đã quen thuộc, tuy nhiên đối với 2 ký tự char thì lại khiến các bạn hơi hoang mang một chút. Tuy nhiên việc so sánh 2 ký tự char trong Java cũng rất đơn giản, chúng ta sẽ cùng nhau tìm hiểu qua bài viết này.

Sử dụng toán tử quan hệ

Các bạn có bất ngờ không, chúng ta hoàn toàn có thể sử dụng các toán tử quan hệ : >, <, >=, <=, == để so sánh 2 ký tự char.

class Main {

public static void main(String[] args){
    char a = 'a';
    char b = 'b';
    if(a > b) {
        System.out.println("a is greater");
    }else if(a < b) {
        System.out.println("a is less than b");
    }else 
        System.out.println("Both are equal");
}

Output: a is less than b

Sử dụng Character.compare()

Chúng ta còn có thể sử dụng method compare() được xây dựng sẵn trong Character class.

class Main {

public static void main(String[] args){
    char a = 'a';
    char b = 'b';
    if(Character.compare(a, b) > 0) {
        System.out.println("a is greater");
    }else if(Character.compare(a, b) < 0) {
        System.out.println("a is less than b");
    }else 
        System.out.println("Both are equal");
}

Output: a is less than b

So sáng bằng

Ngoài các cách trên dùng để so sánh bằng 2 ký tự char thì chúng ta có thể sử dụng equals() method để so sánh bằng 2 ký tự.

Trong lập trình, các con số ở khắp mọi nơi. Nếu bạn đào sâu và nhớ thời trung học, bạn có thể nhớ lại rằng máy tính biểu thị tất cả thông tin ở định dạng số: tổ hợp của số không và số một, còn được gọi là mã nhị phân.

Có rất nhiều toán tử số trong lập trình, vì vậy chúng ta sẽ sử dụng các ví dụ để khám phá những toán tử quan trọng nhất :) Hãy bắt đầu với toán tử số học đơn giản nhất . Đây là các toán tử cộng (

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

4), trừ (

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

5), nhân (

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

6. và chia (

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

7. nổi tiếng.

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;
       System.out.println(x+y);  
       System.out.println(x-y);  
       System.out.println(x*y);  
       System.out.println(x/y);  
   }  
}  

Đầu ra bảng điều khiển: 1032 966 32967 30 Bạn đã sử dụng tất cả những thứ này. Đối với nhóm này, bạn có thể thêm vào

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

8toán tử phần dư hoặc modulo ( ).

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

Đầu ra của bảng điều khiển: 1 Trong ví dụ này, chúng ta chia 33 cho 2. Điều này mang lại 16, với một "đuôi" phụ (một) không chia hết cho 2. "Đuôi" này là kết quả của phép toán "dư thừa từ phép chia". Java cũng thực hiện các toán tử so sánh/quan hệ (giống như trong toán học). Họ có lẽ cũng quen thuộc với bạn từ trường học:

• bằng (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 33%2;  
     System.out.println(y);  
  

  } }
  9)
• lớn hơn (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x=y);// We expect false to be displayed  
  

  } }
  0)
• nhỏ hơn (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x=y);// We expect false to be displayed  
  

  } }
  1)
• lớn hơn hoặc bằng (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x=y);// We expect false to be displayed  
  

  } }
  2)
• nhỏ hơn hoặc bằng (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x=y);// We expect false to be displayed  
  

  } }
  3)
• không bằng (

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x=y);// We expect false to be displayed  
  

  } }
  4)

Ở đây bạn nên chú ý đến một điểm quan trọng khiến nhiều người mới bắt đầu mắc lỗi. Toán tử "bằng" được viết

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

9, không phải

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

6. Trong Java, một

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

6là toán tử gán , được sử dụng khi một biến được gán một số, chuỗi hoặc giá trị của một biến khác.

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

Đầu ra bảng điều khiển: 999 Rất tiếc! Đây rõ ràng không phải là kết quả mà chúng tôi mong đợi. Đó là một loại dữ liệu hoàn toàn khác: chúng tôi dự kiến ​​sẽ thấy một boolean nhưng chúng tôi đã nhận được một số. Tất cả là vì chúng ta đã sử dụng toán tử gán trong ngoặc đơn thay vì phép so sánh .

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

8 Giá trị của

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

9(999) được gán cho biến

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

0và sau đó chúng tôi hiển thị giá trị của

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

0. Đây là cách đúng đắn để làm điều đó:

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

Đầu ra của bảng điều khiển: sai Bây giờ chúng ta đã so sánh đúng hai số! :) Đây là một tính năng khác của toán tử gán (

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

6): nó có thể được "xâu chuỗi" lại với nhau:

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

Đầu ra của bàn điều khiển: 256 Ghi nhớ phép gán từ phải sang trái . Biểu thức ( ) này

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

3sẽ được thực hiện theo các bước:

• public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x==y);  
  

  } }

  4, đó là,

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x==y);  
  

  } }
  5

• public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x==y);  
  

  } }

  6, đó là,

  public class Main { public static void main(String[] args) {

     int x = 33;  
     int y = 999;  
     System.out.println(x==y);  
  

  } }
  7

Toán tử đơn nguyên.

Chúng được gọi là " đơn nguyên " từ từ " uno ", có nghĩa là " một ". Họ có tên này bởi vì, không giống như các toán tử trước đó, họ hành động trên một số duy nhất chứ không phải nhiều số. Bao gồm các:

• Phép trừ đơn phương. Nó lật dấu của số.

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

Đầu ra của bảng điều khiển: -999 999 Chúng tôi đã sử dụng toán tử trừ một ngôi hai lần. Kết quả là, số của chúng tôi lúc đầu là số âm, sau đó nó lại trở thành số dương!

• Tăng (++) và giảm (--)

Toán

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

8tử tăng một số lên một và

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

9toán tử giảm một số bằng cùng một lượng.

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

Đầu ra bảng điều khiển: 1000 999 Ký hiệu này có thể quen thuộc với bạn nếu bạn đã nghe nói về ngôn ngữ C++. Những người tạo ra nó đã sử dụng cái tên thú vị này để truyền đạt ý tưởng rằng "C++ là phần mở rộng của ngôn ngữ C". Một phiên bản cải tiến phổ biến của Notepad được gọi là Notepad++ Đây là một điểm quan trọng. Có hai loại toán tử tăng và giảm: hậu tố và tiền tố .

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

0- hậu tố

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

1- tiền tố Sự khác biệt cơ bản giữa việc đặt dấu cộng/trừ trước hoặc sau số là gì? Chúng ta sẽ xem trong ví dụ sau:

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

Đầu ra bảng điều khiển: 999 Đã xảy ra lỗi! Chúng tôi muốn tăng thêm

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

01 và gán giá trị mới cho biến y. Nói cách khác, y phải là 1000. Nhưng thay vào đó, chúng ta nhận được một số khác: 999. Có vẻ như x không tăng và toán tử tăng không hoạt động? Nhưng nó đã làm việc. Để thuyết phục bản thân, hãy thử hiển thị

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

0ở cuối :)

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

Đầu ra của bảng điều khiển: 999 1000 Trên thực tế, đây chính là lý do tại sao thao tác này được gọi là hậu tố: nó được thực hiện sau biểu thức chính. Điều này có nghĩa là, trong trường hợp của chúng ta:

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

4

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

5được thực hiện trước (và biến

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 999;  
       System.out.println(x=y);// We expect false to be displayed  
   }  
}  

9sẽ được khởi tạo thành giá trị của

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

0), và chỉ sau đó mới

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

0được thực thi. Nếu đây không phải là hành vi chúng ta muốn thì sao? Sau đó, chúng ta cần sử dụng ký hiệu tiền tố :

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

Trong trường hợp này,

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

1được xử lý trước và chỉ sau đó là

  
public class Main {
   public static void main(String[] args) {
       int x = 999;  
       int y = 33;  
       int z = 256;
       x = y = z;  
       System.out.println(x);  
   }  
}  

5; Thực thi. Bạn nên ghi sự khác biệt này vào bộ nhớ ngay lập tức để tránh mắc lỗi trong một chương trình thực tế khi sử dụng hậu tố thay vì tiền tố có thể đảo lộn mọi thứ :)

toán tử hợp chất

Ngoài ra, trong Java còn có cái gọi là toán tử ghép. Họ kết hợp hai toán tử:

• Phân công
• toán tử số học

Bao gồm các:

• public class Main { public static void main(String[] args) {

     int x = 999;  
     // Change the sign for the first time  
     x = -x;  
     System.out.println(x);  
     // Change the sign for the second time  
     x= -x;  
     System.out.println(x);  
  

  } }
  1

• public class Main { public static void main(String[] args) {

     int x = 999;  
     // Change the sign for the first time  
     x = -x;  
     System.out.println(x);  
     // Change the sign for the second time  
     x= -x;  
     System.out.println(x);  
  

  } }
  2

• public class Main { public static void main(String[] args) {

     int x = 999;  
     // Change the sign for the first time  
     x = -x;  
     System.out.println(x);  
     // Change the sign for the second time  
     x= -x;  
     System.out.println(x);  
  

  } }
  3

• public class Main { public static void main(String[] args) {

     int x = 999;  
     // Change the sign for the first time  
     x = -x;  
     System.out.println(x);  
     // Change the sign for the second time  
     x= -x;  
     System.out.println(x);  
  

  } }
  4

• public class Main { public static void main(String[] args) {

     int x = 999;  
     // Change the sign for the first time  
     x = -x;  
     System.out.println(x);  
     // Change the sign for the second time  
     x= -x;  
     System.out.println(x);  
  

  } }
  5

Hãy xem xét một ví dụ:

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

0

Đầu ra của bảng điều khiển: 1032

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

6 có nghĩa là

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

7. Hai biểu tượng được sử dụng liên tiếp vì mục đích ngắn gọn. Các kết hợp

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

2,

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

3,

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

4và

  
public class Main {
   public static void main(String[] args) {
       int x = 999;
       // Change the sign for the first time  
       x = -x;  
       System.out.println(x);
       // Change the sign for the second time  
       x= -x;  
       System.out.println(x);  
   }  
}  

5hoạt động theo cách tương tự.

Toán tử logic

Ngoài các toán tử số, Java còn có các phép toán liên quan đến các giá trị boolean ( true và false ). Các thao tác này được thực hiện bằng cách sử dụng các toán tử logic

• public class Main { public static void main(String[] args) {

     int x = 999;  
     x++;  
     System.out.println(x);  
     x--;  
     System.out.println(x);  
  

  } }
  2- logic KHÔNG . Nó lật giá trị của một boolean

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

1

Đầu ra bảng điều khiển: sai

• public class Main { public static void main(String[] args) {

     int x = 999;  
     x++;  
     System.out.println(x);  
     x--;  
     System.out.println(x);  
  

  } }
  3- logic VÀ . Nó chỉ trả về true nếu cả hai toán hạng đều đúng.

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

2

Đầu ra của bảng điều khiển: false true Kết quả của thao tác đầu tiên là sai, vì một trong các toán hạng là sai, cụ thể là

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

4. Để trả về giá trị true,

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

3toán tử yêu cầu cả hai toán hạng đều đúng (như trường hợp ở dòng thứ hai).

• public class Main { public static void main(String[] args) {

     int x = 999;  
     x++;  
     System.out.println(x);  
     x--;  
     System.out.println(x);  
  

  } }
  6- logic HOẶC . Nó trả về true khi ít nhất một trong các toán hạng là true.

Khi chúng tôi sử dụng toán tử này, ví dụ trước của chúng tôi tạo ra một kết quả khác:

  
public class Main {
   public static void main(String[] args) {
       int x = 33;  
       int y = 33%2;  
       System.out.println(y);  
   }  
}  

3

Đầu ra của bảng điều khiển: đúng Biểu thức

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

4vẫn là sai, nhưng đối với toán tử OR , phần đầu tiên (

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

8. là hoàn toàn đủ.