Java >> Tutoriel Java >  >> Tag >> String

Comment comparer des chaînes en Java

Java est un langage de programmation orienté objet qui peut être utilisé pour développer des applications de bureau, des applications Web, des applications Android, des jeux, des connexions à des bases de données, etc. Dans cet article, nous allons étudier comment comparer des chaînes en Java. En Java, une chaîne est un type de données ou un objet utilisé pour stocker du texte. L'objet chaîne contient des caractères entourés de guillemets doubles.

Exemple :

package stringcomparison;
public class StringComparison 
{
    public static void main(String[] args) 
    {
      String greetings = "Good Morning Java Developers";
        System.out.println(greetings);                
	}        
}

Sortie :

Good Morning Java Developers

Package StringComparison – stringcomparison est le nom du package. En Java, un package est comme un dossier contenant plusieurs classes Java associées.
Public Class StringComparison – StringComparison, marque le nom de la classe. Une classe en Java est un plan dans lequel des objets sont créés. Public est le modificateur de classe, ce qui signifie que la classe est accessible depuis n'importe où dans la classe, dans le package et en dehors du package.
Public Static Void main(String[] args) - montre la méthode principale de Java. Public est un modificateur d'accès qui permet d'accéder à la méthode principale partout. String[] args est un tableau d'une séquence de caractères. Statique signifie qu'il n'y a qu'une seule occurrence de la méthode principale et que void est un type de retour vide.
System.out.println() - c'est une méthode en java qui est utilisée pour sortir des lignes de texte.

Cela dit, nous connaissons la syntaxe de base d'une classe Java. Voyons brièvement comment démarrer jusqu'à l'étape de comparaison de chaînes en Java.

Démarrer avec Java

Pour démarrer avec Java, vous devez avoir installé Java sur votre PC. Vérifiez si Java est installé sur votre ordinateur, appuyez sur Windows + Ropen et tapez cmd pour ouvrir l'invite de commande. Tapez ensuite la commande suivante. "java-version." Selon la version de Java que vous avez, il vous montrera la fenêtre suivante.

Si vous n'avez pas encore installé Java, vous pouvez le télécharger ici sur oracle.com, vérifier les versions disponibles et télécharger une version basée sur votre système d'exploitation. Je vous recommande également de télécharger l'un de ces environnements de développement intégrés Java ; NetBeans, Eclipse ou IntelliJ IDEA.

Comparaison de chaînes en Java

Intéressons-nous maintenant à la comparaison des chaînes. Cela peut être avantageux lors de la création d'applications Java; Prenons, par exemple, la création d'une application de livraison de nourriture de restaurant en Java qui vérifie qui a commandé un type particulier de nourriture. Vous voudrez peut-être comparer les noms de vos clients avec ceux figurant dans le dossier.

Il existe 3 façons différentes de comparer des chaînes en Java, ce qui peut être important lors de l'authentification, du tri ou de la correspondance des références. Ils incluent :

  1. Comparaison de chaînes à l'aide des méthodes equals () et equalsIgnoreCase() - effectue une comparaison de vérification d'égalité.
  2. Comparaison de chaînes à l'aide des méthodes compareTo() et compareToIgnoreCase(). – effectue une comparaison de commande
  3. Comparaison de chaînes à l'aide de l'opérateur (==) (opérateur d'égalité) :effectue uniquement la comparaison d'égalité référencée.

Comparaison de chaînes à l'aide de l'opérateur (==)

L'opérateur d'égalité compare si deux chaînes sont identiques. Pour qu'ils soient considérés comme identiques, ils doivent faire référence à la même allocation de mémoire. Si l'on a de l'espace supplémentaire, ils ne peuvent pas être considérés comme identiques.

Exemple :

public class StringComparison 
{
    public static void main(String[] args) 
    {
       String first_name = "codeunderscored";
		String last_name = "codeunderscored";
		if (first_name == last_name) 
            {
			System.out.println("The First Name matches the Last Name.");
		    } 
        else 
           {
			System.out.println("The First Name does not match the Last Name.");
		   }
	}        

    }

Sortie :

run:
The First Name matches the Last Name.
BUILD SUCCESSFUL (total time: 1 second)

Dans le code ci-dessus, l'opérateur ==utilise l'instruction if pour vérifier si les valeurs de la chaîne first_name et last_name sont égales et en font rapport. S'ils sont équivalents, il imprime la première instruction; sinon, il imprime la deuxième instruction.

Nous n'utilisons pas l'opérateur ==principalement pour comparer des chaînes car il effectue uniquement une vérification d'égalité de référence. Par cela, je veux dire que vous ne pouvez pas utiliser l'opérateur ==pour comparer des objets de chaîne. Au lieu de cela, si vous comparez deux objets chaîne, le programme les verra différemment même s'ils ont la même valeur. Regardons cela à l'aide d'un exemple :

package stringcomparison;

public class StringComparison 
{
    public static void main(String[] args) 
    {
           String first_name = new String ("moses");
           String last_name = new String ("moses");

		if (first_name == last_name) 
                {
			System.out.println("The First Name matches the Last Name.");
		} 
                else 
                {
			System.out.println("The First Name does not match the Last Name.");
		}
	}

}

Sortie :

run:
The First Name does not match the Last Name.
BUILD SUCCESSFUL (total time: 0 seconds)

Dans l'exemple ci-dessus, nous avons créé deux nouveaux objets de la méthode String(). Malgré l'attribution de la même valeur aux deux objets de chaîne, le programme les traite différemment et les affiche car ils ne correspondent pas. C'est parce que le programme compare l'objet lui-même plutôt que de comparer la valeur des chaînes.

Comparaison de chaînes à l'aide des méthodes equals () et equalsIgnoreCase().

Utilisation de equals() méthode.

Nous utilisons equals() méthode lorsque nous voulons vérifier si les objets de chaîne ont les mêmes caractères et dans la même séquence. Chaîne est égal à() la méthode est sensible à la casse ; par conséquent, il renverra faux si les valeurs comparées sont de casse différente bien qu'elles aient les mêmes caractères et la même séquence.

Exemple 1 :

package stringcomparison;

public class StringComparison 
{
    public static void main(String[] args) 
    {
           String first_name = new String ("codeunderscored");
            String last_name = new String ("codeunderscored");
            
            String name1 = "codeunderscored";
            String name2 = "codeunderscored";

		if (first_name.equals(last_name)) 
                {
			System.out.println("The First Name matches the Last Name.");
		} 
                else 
                {
			System.out.println("The First Name does not match the Last Name.");
		}
                if (name1.equals(name2)) 
                {
			System.out.println("The First Name matches the Last Name.");
		} 
                else 
                {
			System.out.println("The First Name does not match the Last Name.");
		}
	}        
}

Sortie :

run:
The First Name matches the Last Name.
The First Name matches the Last Name.
BUILD SUCCESSFUL (total time: 1 second)

C'est une sortie claire que le equals() La méthode peut être utilisée pour comparer à la fois des objets d'égalité de référence et des objets de chaîne.

Exemple 2 :

public class StringComparison 
{
    public static void main(String[] args) 
    {
          String first_name = new String ("codeunderscored");
            String last_name = new String ("Codeunderscored");
		if (first_name.equals(last_name)) 
                {
			System.out.println("The First Name matches the Last Name.");
		} 
                else 
                {
			System.out.println("The First Name does not match the Last Name.");
		}
	}        
}

Sortie :

run:
The First Name does not match the Last Name.
BUILD SUCCESSFUL (total time: 0 seconds)

La sortie montre que les objets de chaîne ne sont pas les mêmes. C'est parce que est égal à() la méthode est sensible à la casse, et depuis le deuxième objet de chaîne, nous avons attribué un C majuscule à ses premiers caractères, il voit les objets chaîne comme différents.

méthode equalsIgnoreCase()

La chaîne equalsIgnoreCase() la méthode compare la même chose que la méthode equals (). Il compare les chaînes si elles ont les mêmes caractères, la même séquence mais ignore la vérification de la casse. Si les deux chaînes ont les mêmes caractères et sont de la même séquence, cela ne détermine pas si elles sont de la même casse ou non, mais le programme les traite comme identiques. Il est insensible à la casse.

Exemple :

package stringcomparison
public class StringComparison 
{
    public static void main(String[] args) 
    {
          String first_name = new String ("codeunderscored");
            String last_name = new String ("CODEUNDERSCORED");
            if (first_name.equalsIgnoreCase(last_name)) 
                {
			System.out.println("The First Name matches the Last Name.");
		} 
                else 
                {
			System.out.println("The First Name does not match the Last Name.");
		}
	}        
}

Sortie :

run:
The First Name matches the Last Name.
BUILD SUCCESSFUL (total time: 0 seconds)

Comparaison de chaînes à l'aide des méthodes compareTo() et compareToIgnoreCase().

Méthode de chaîne compareTo()

Il est utilisé pour comparer lexicographiquement deux chaînes. Lexicographiquement signifie que les mots sont triés dans le dictionnaire/ordre alphabétique. On peut donc dire que deux chaînes sont lexicographiquement égales si elles contiennent le même nombre de caractères à la même position et sont de même longueur. Vous comparez de gauche à droite les deux chaînes.

Considérons quelques scénarios pour avoir une compréhension approfondie de la compareTo() sorties de la méthode. Vous avez StringC et StringD.

stringC.compareTo( stringD )

Si StringC et StringD sont lexicographiquement égaux, le programme renvoie 0.
Si StringC vient en premier, il renvoie une valeur négative.
Si StringD vient en premier, il renvoie une valeur positive.

Exemples :
"Fourmi".compareTo "fourmi" – il renvoie un entier négatif car la majuscule ‘A’ vient avant la minuscule ‘a’.
"evening".compareTo "everywhere" - renvoie un entier négatif, la lettre "n" vient avant la lettre "r".
"morning".compareTo" morning" - renvoie 0, ils ont les mêmes caractères dans la même position et aussi la même longueur.
"Morning".compareTo "evening" :renvoie une valeur positive puisque la lettre "e" vient après la lettre "m".
"Moses".compareTo "Njoroge" - renvoie une valeur positive puisque la lettre "n" vient après la lettre "m".

package stringcomparison;

public class StringComparison 
{
    public static void main(String[] args) 
    {
       //"Ant".compareTo "ant" – it  returns a negative integer because uppercase 'A' comes before lower case 'a'
        String a = "ant";
        String b = "Ant";
        int different= a.compareTo(b);
         System.out.println(""Ant".compareTo "ant":\n Negative value:" +different);
         System.out.println("============================================================");
 
         
   //"evening".compareTo "everywhere" – returns a negative integer, letter 'n' comes before letter 'r'  
        String c = "evening";
        String d = "everywhere";
        int differ= c.compareTo(d);
         System.out.println(""evening".compareTo "everywhere:\n Negative value:" +differ);
        System.out.println("============================================================");
        
   //"morning".compareTo" morning" – returns 0, they have the same characters in the same position and also the same length.
        String e = "morning";
        String f = "morning";
        int diff= e.compareTo(f);
         System.out.println(""morning".compareTo" morning":\n Return 0 value:" +diff);
         System.out.println("============================================================");

        
   //"Morning".compareTo "evening" – returns a positive value since the letter 'e' comes after the letter  'm'
        String g = "morning";
        String h = "evening";
        int dif= g.compareTo(h);
         System.out.println(""Morning".compareTo "evening":\n Positive value:" +dif);
         System.out.println("============================================================");

   //"moses".compareTo "njoroge" – returns a positive value since the letter 'm' comes after the letter  'n'
        String i = "moses";
        String j = "njoroge";
        int di= i.compareTo(j);
         System.out.println(""Morning".compareTo "evening":\n Positive value:" +di);
    } 
}

Sortie :

run:
“Ant”.compareTo ”ant”:
 Negative value:32
============================================================
“evening”.compareTo “everywhere:
 Negative value:-4
============================================================
“morning”.compareTo” morning”:
 Return 0 value:0
============================================================
“Morning”.compareTo ”evening”:
 Positive value:8
============================================================
“Morning”.compareTo ”evening”:
 Positive value:-1
BUILD SUCCESSFUL (total time: 0 seconds)

compareToIgnoreCase()

La méthode compareTo() est également sensible à la casse. Pour supprimer cette sensibilité à la casse, nous utilisons compareToIgnoreCase(). Il compare deux chaînes sans tenir compte des majuscules ou des minuscules.
Exemple :

package stringcomparison;

public class StringComparison 
{
    public static void main(String[] args) 
    {
       //"Ant".compareTo "ant" – it  returns a negative integer because uppercase 'A' comes before lower case 'a'
        String a = "morning";
        String b = "MORNING";
        int different= a.compareToIgnoreCase(b);
         System.out.println("value:" +different);
  } 
}:

Sortie :

run:
value:0
BUILD SUCCESSFUL (total time: 1 second)

Le programme ci-dessus considère les deux chaînes comme identiques malgré leur différence de casse.

Conclusion

Dans ce tutoriel, nous avons appris la comparaison de chaînes en Java. Généralement, il existe 3 façons de comparer des chaînes en Java :equals(), compareTo() et l'utilisation de l'opérateur ==. Le cas equalsIgnoreCase() et compareToIgnoreCase() sont utilisés lorsque nous ne voulons pas que les majuscules ou les minuscules soient prises en compte lors de la comparaison. Je pense que vous pouvez maintenant être en mesure de comparer des chaînes en Java.


Balise Java