Java >> Java tutorial >  >> Tag >> String

Hvordan man sammenligner strenge i Java

String

Java er et objektorienteret programmeringssprog, der kan bruges til at udvikle desktop-applikationer, webapplikationer, android-applikationer, spil, databaseforbindelser osv. I denne artikel skal vi studere, hvordan man sammenligner strenge i Java. I java er en streng en datatype eller et objekt, der bruges til at gemme tekst. Strengobjektet indeholder tegn, der er omgivet af dobbelte anførselstegn.

Eksempel: 

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

Output: 

Good Morning Java Developers

Sammenligning af pakkestrenge – stringcomparison er navnet på pakken. I Java er en pakke som en mappe, der indeholder flere relaterede java-klasser.
Sammenligning af offentlig klassestreng – StringComparison, markerer klassenavnet. En klasse i java er en blueprint, hvor objekter oprettes. Public er klassemodifikatoren, hvilket betyder, at klassen kan tilgås fra hvor som helst i klassen, i pakken og uden for pakken.
Public Static Void main(String[] args) – viser java hovedmetode. Offentlig er en adgangsmodifikator, der gør det muligt at få adgang til hovedmetoden overalt. String[] args er en matrix af en sekvens af tegn. Statisk betyder, at der kun er én forekomst af hovedmetoden, og void er en tom returtype.
System.out.println() – det er en metode i java, der bruges til at udskrive tekstlinjer.

Med det sagt kender vi den grundlæggende syntaks for en java-klasse. Lad os kort diskutere, hvordan man kommer i gang med at sammenligne strenge i java.

Kom godt i gang med Java

For at komme i gang med Java skal du have java installeret på din pc. Tjek om Java er installeret på din computer, tryk på Windows+Ropen og skriv cmd for at åbne kommandoprompten. Skriv derefter følgende kommando. "java -version." Afhængigt af den java-version du har, vil den vise dig følgende vindue.

Hvis du ikke har installeret java endnu, kan du downloade det her på oracle.com, tjekke de tilgængelige versioner og downloade en version baseret på dit operativsystem. Jeg anbefaler også, at du downloader et hvilket som helst af disse java-integrerede udviklingsmiljøer; NetBeans, Eclipse eller IntelliJ IDEA.

Sammenligning af strenge i Java

Lad os nu grave ind i at sammenligne strenge. Dette kan være fordelagtigt, når du bygger Java-applikationer; lad os for eksempel tage en restaurant-madleveringsapp i java, der tjekker, hvem der har bestilt en bestemt type mad. Du ønsker måske at sammenligne din kundes navne med dem, der er registreret.

Der er 3 forskellige måder at sammenligne strenge i java på, hvilket kan være vigtigt under godkendelse, sortering eller referencematchning. De omfatter:

  1. String-sammenligning ved hjælp af metoderne equals () og equalsIgnoreCase() – udfører sammenligning af lighedstjek.
  2. String-sammenligning ved at bruge compareTo() og compareToIgnoreCase()-metoden. – udfører bestillingssammenligning
  3. String-sammenligning ved at bruge  (==) Operator (ligestillingsoperator) – udfører kun refererede lighedssammenligning.

String-sammenligning ved hjælp af (==) operator

Lighedsoperatoren sammenligner, hvis to strenge er ens. For at de kan betragtes som ens, skal de referere til den samme hukommelsestildeling. Hvis man har ekstra plads, kan de ikke henvises til at være ens.

Eksempel: 

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.");
		   }
	}        

    }

Output: 

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

I koden ovenfor bruger ==-operatoren if-sætningen tjekker, om værdierne af strengen fornavn og efternavn er ens, og rapporterer tilbage. Hvis de er ækvivalente, udskriver den det første udsagn; ellers udskriver den den anden sætning.

Vi bruger ikke ==operatoren for det meste til at sammenligne strenge, fordi den kun udfører referencelighedskontrol. Med dette mener jeg, at du ikke kan bruge ==-operatoren til at sammenligne strengobjekter. Hvis du i stedet sammenligner to strengobjekter, vil programmet se dem forskelligt, selvom de har samme værdi. Lad os se på dette ved at bruge et eksempel:

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.");
		}
	}

}

Output :

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

I eksemplet ovenfor har vi oprettet to nye objekter af String()-metoden. På trods af at begge strengobjekter tildeles samme værdi, behandler programmet dem forskelligt og udlæser dem, da de ikke matcher. Dette skyldes, at programmet sammenligner selve objektet i stedet for at sammenligne værdien af ​​strengene.

Sammenligning af strenge ved at bruge metoderne equals () og equalsIgnoreCase().

Brug equals() metode.

Vi bruger equals() metode, når vi vil kontrollere, om strengobjekterne har de samme tegn og i samme rækkefølge. Streng er lig med() metoden skelner mellem store og små bogstaver; derfor vil det returnere falsk, hvis værdierne, der blev sammenlignet, er af forskellige store og små bogstaver på trods af, at de har samme tegn og samme rækkefølge.

Eksempel 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.");
		}
	}        
}

Output: 

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

Det er et klart output, at er lig med() metode kan bruges til at sammenligne både referencelighed og strengobjekter.

Eksempel 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.");
		}
	}        
}

Output: 

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

Outputtet viser, at strengobjekterne ikke er ens. Dette er fordi er lig med() metoden skelner mellem store og små bogstaver, og siden det andet strengobjekt har vi tildelt et stort C i forhold til de første tegn, ser den strengobjekterne som forskellige.

equalsIgnoreCase() metode

Strengen equalsIgnoreCase() metode sammenligner det samme som equals() metode. Den sammenligner strenge, hvis de har de samme tegn, den samme sekvens, men ignorerer den store og små bogstaver. Hvis de to strenge har de samme tegn og er af samme rækkefølge, afgør det ikke, om de er af samme store og små bogstaver eller ej, men programmet behandler dem som ens. Der skelnes mellem store og små bogstaver.

Eksempel: 

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.");
		}
	}        
}

Output: 

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

Sammenligning af strenge ved at bruge metoderne compareTo() og compareToIgnoreCase().

String compareTo() metode

Det bruges til at sammenligne to strenge leksikografisk. Leksikografisk betyder ordene sorteret i ordbog/alfabetisk rækkefølge. Så vi kan sige, at to strenge er leksikografisk ens, hvis de indeholder det samme antal tegn i samme position og er af samme længde. Du sammenligner de to strenge fra venstre mod højre.

Lad os overveje nogle scenarier for at få en dyb forståelse af compareTo() metode output. Du har  StringC og StringD.

stringC.compareTo( stringD )

Hvis StringC og StringD er leksikografisk ens, returnerer programmet 0.
Hvis StringC kommer først, returnerer den en negativ værdi.
Hvis StringD kommer først, returnerer den en positiv værdi.

Eksempler :
"Myre".sammenlignTil "myre" – det returnerer et negativt heltal, fordi store bogstaver "A" kommer før små bogstaver "a".
"aften".compareTil "overalt" - returnerer et negativt heltal, bogstavet 'n' kommer før bogstavet 'r.'
“morning”.compareTo” morning” – returnerer 0, de har de samme tegn i samme position og også samme længde.
"Morning".compareTo "aften" - returnerer en positiv værdi, da bogstavet 'e' kommer efter bogstavet  'm.'
"Moses".compareTo "Njoroge" – returnerer en positiv værdi, da bogstavet 'n' kommer efter bogstavet  '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);
    } 
}

Output: 

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()

Metoden compareTo() skelner også mellem store og små bogstaver. For at fjerne denne følsomhed mellem store og små bogstaver, bruger vi compareToIgnoreCase(). Den sammenligner to strenge uden hensyn til store eller små bogstaver.
Eksempel: 

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);
  } 
}:

Output :

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

Ovenstående program ser de to strenge som ens på trods af deres forskelle i tilfælde.

Konklusion

I denne tutorial har vi lært om strengsammenligning i java. Generelt er der 3 måder at sammenligne strenge i java:equals(), compareTo() og ved at bruge ==-operatoren. Sagen equalsIgnoreCase() og compareToIgnoreCase() bruges, når vi ikke vil have store eller små bogstaver i betragtning under sammenligningen. Jeg tror, ​​du nu kan være i stand til at sammenligne strenge i java.


Java tag