Les opérateurs de comparaisons permettent de comparer leurs opérandes et de renvoyer une valeur logique en fonction du résultat.

Tous ces opérateurs renvoient un résultat booléen ; si la comparaison est réussie, la valeur logique true est retournée, dans le cas contraire c'est false.

int x = 12;;
int y = 24;
boolean resultat = x < y;
// resultat = true
a = "bonjour";
b = "hello";
boolean resultat = a == b;
// resultat = false

Les opérandes ne peuvent être que des types numériques soit des nombres entiers (byte, short, int et long) ou à virgule flottante (float et double) ou encore des caractères (char) pour les opérateurs de comparaisons suivants : <, >, <=, >=, ==, !=.

Les deux opérateurs d'égalité (==) et de différence (!=) peuvent également être utilisés sur des références d'objet.
Dans ce cas, l'opération consiste en une comparaison de références et non de types de référence.
Les références sont comparées afin de contrôler si elles désignent le même objet.

public class inst {
  public static void main(String[] args) {
  Classe ref = new Classe();
  Classe x = new Classe();
  Object y = ref;
  Object z = null;
  if (ref == x)
      System.out.println("ref et x sont égales !");
  else
      System.out.println("ref et x ne sont pas égales !");

  if (ref == y)
      System.out.println("ref et y sont égales !");
  else
      System.out.println("ref et y ne sont pas égales !");

  ref = null;
  if (ref == z)
      System.out.println("ref et z sont égales !");
  else
      System.out.println("ref et z ne sont pas égales !");
  }
}

class Classe {
 //Instructions...
}

Au temps d'exécution, les résultats des opérateurs == et != sont respectivement true et false, si les valeurs des opérandes sont nulles ou se référent au même objet ou au même tableau, sinon le résultat est false et true.

Deux instances d'une même classe représentant un même objet possèdent des références différentes.

Une erreur au moment de la compilation se produit, si il est impossible de transtyper le type d'un opérande vers l'autre et réciproquement, les valeurs de ces deux opérandes sont forcément différentes lors du temps d'exécution.

Pour une comparaison de deux références d'objet, il est préférable d'utiliser plutôt la méthode equals() définie dans la classe java.lang.Object.

Opérateur	Description	Exemples
x == y	Si la valeur y est égale à x, l'opérateur retourne true. Dans ce cas, si le type de donnée ne correspond pas alors Javascript tentera de convertir les opérandes dans le type approprié afin d'effectuer la comparaison.	if (choix == 1)
x != y	Si la valeur y est différente de x, l'opérateur retourne true	if (valeur != prix)
x > y	Si la valeur de y est supérieure à x, l'opérateur retourne true	if (montant > 1500)
x >= y	Si la valeur de y est supérieure ou égale à x, l'opérateur retourne true	if (hab >= pop)
x < y	Si la valeur de y est inférieure à x, l'opérateur retourne true	if (numero < page)
x <= y	Si la valeur de y est inférieure ou égale à x, l'opérateur retourne	if (fin <= premier)

La promotion arithmétique se charge de convertir un des opérandes vers le type le plus large des deux pour effectuer la comparaison.

int x = 16;
byte y = 32;
resultat = x > y;
// y est transtypé à int pour effectuer la comparaison