Сравнение двух строк java

Сравнение двух строк java

Строка — это последовательность символов. В Java объекты String являются неизменяемыми, что означает, что они постоянны и не могут быть изменены после создания.

Ниже приведены 5 способов сравнить две строки в Java:

  1. Использование пользовательской функции: определите функцию для сравнения значений со следующими условиями:
  1. if (string1> string2) возвращает положительное значение .
  2. если обе строки равны лексикографически
    т.е. (строка1 == строка2) возвращает .
  3. if (string1

// Java-программа для сравнения двух строк
// лексикографически

public class GFG <

// Этот метод сравнивает две строки

// лексикографически без использования

public static int stringCompare(String str1, String str2)

int l1 = str1.length();

int l2 = str2.length();

int lmin = Math.min(l1, l2);

for ( int i = 0 ; i

int str1_ch = ( int )str1.charAt(i);

int str2_ch = ( int )str2.charAt(i);

if (str1_ch != str2_ch) <

return str1_ch — str2_ch;

// Пограничный регистр для строк типа

// String 1 = "Geeks" и String 2 = "Geeksforgeeks"

// Если ни одно из указанных выше условий не выполняется,

// это означает, что обе строки равны

// Функция драйвера для проверки вышеуказанной программы

public static void main(String args[])

String string1 = new String( "Geeksforgeeks" );

String string2 = new String( "Practice" );

String string3 = new String( "Geeks" );

String string4 = new String( "Geeks" );

// Сравнение для String 1

System.out.println( "Comparing " + string1 + " and " + string2

// Сравнение для String 3 = String 4

System.out.println( "Comparing " + string3 + " and " + string4

// Сравнение для строки 1> строки 4

System.out.println( "Comparing " + string1 + " and " + string4

Использование String.equals (): В Java метод string equals () сравнивает две заданные строки на основе данных / содержимого строки. Если все содержимое обеих строк одинаково, возвращается значение true. Если все символы не совпадают, то возвращается false.

Здесь str1 и str2 — это строки, которые нужно сравнить.

Примеры:

// Java-программа для сравнения двух строк
// лексикографически

public class GFG <

public static void main(String args[])

String string1 = new String( "Geeksforgeeks" );

String string2 = new String( "Practice" );

String string3 = new String( "Geeks" );

String string4 = new String( "Geeks" );

String string5 = new String( "geeks" );

// Сравнение для строки 1! = Строка 2

System.out.println( "Comparing " + string1 + " and " + string2

// Сравнение для String 3 = String 4

System.out.println( "Comparing " + string3 + " and " + string4

// Сравнение для строки 4! = Строка 5

System.out.println( "Comparing " + string4 + " and " + string5

// Сравнение для строки 1! = Строка 4

System.out.println( "Comparing " + string1 + " and " + string4

Использование String.equalsIgnoreCase (): метод String.equalsIgnoreCase () сравнивает две строки независимо от регистра (нижнего или верхнего) строки. Этот метод возвращает значение true, если аргумент не равен NULL, а содержимое обеих строк совпадает с регистром игнорирования, в противном случае — false.

Здесь str1 и str2 — это строки, которые нужно сравнить.

Примеры:

// Java-программа для сравнения двух строк
// лексикографически

public class GFG <

public static void main(String args[])

String string1 = new String( "Geeksforgeeks" );

String string2 = new String( "Practice" );

String string3 = new String( "Geeks" );

String string4 = new String( "Geeks" );

String string5 = new String( "geeks" );

// Сравнение для строки 1! = Строка 2

System.out.println( "Comparing " + string1 + " and " + string2

// Сравнение для String 3 = String 4

System.out.println( "Comparing " + string3 + " and " + string4

// Сравнение для String 4 = String 5

System.out.println( "Comparing " + string4 + " and " + string5

// Сравнение для строки 1! = Строка 4

System.out.println( "Comparing " + string1 + " and " + string4

Использование метода Objects.equals ():Object.equals (Object a, Object b) возвращает true, если аргументы равны друг другу, и false в противном случае. Следовательно, если оба аргумента равны нулю, возвращается значение true, а если ровно один аргумент равен нулю, возвращается значение false. В противном случае равенство определяется с помощью метода equals () первого аргумента.

Синтаксис:

Здесь a и b оба являются строковыми объектами, которые должны сравниваться.

Примеры:

// Java-программа для сравнения двух строк
// лексикографически

public class GFG <

public static void main(String args[])

String string1 = new String( "Geeksforgeeks" );

String string2 = new String( "Geeks" );

String string3 = new String( "Geeks" );

String string4 = null ;

String string5 = null ;

// Сравнение для строки 1! = Строка 2

System.out.println( "Comparing " + string1 + " and " + string2

// Сравнение для String 2 = String 3

System.out.println( "Comparing " + string2 + " and " + string3

// Сравнение для строки 1! = Строка 4

System.out.println( "Comparing " + string1 + " and " + string4

// Сравнение для String 4 = String 5

System.out.println( "Comparing " + string4 + " and " + string5

Работает:
Он сравнивает и возвращает следующие значения следующим образом:

  1. if (string1> string2) возвращает положительное значение .
  2. если обе строки равны лексикографически
    т.е. (строка1 == строка2) возвращает .
  3. if (string1

// Java-программа для сравнения двух строк
// лексикографически

public class GFG <

public static void main(String args[])

String string1 = new String( "Geeksforgeeks" );

String string2 = new String( "Practice" );

String string3 = new String( "Geeks" );

String string4 = new String( "Geeks" );

Читайте также:  Платные звонки на мобильный

// Сравнение для String 1

System.out.println( "Comparing " + string1 + " and " + string2

// Сравнение для String 3 = String 4

System.out.println( "Comparing " + string3 + " and " + string4

// Сравнение для строки 1> строки 4

System.out.println( "Comparing " + string1 + " and " + string4

В общем случае в Java используются операторы equals () и « == » для сравнения объектов с целью проверки равенства, но здесь есть некоторые различия между ними:

  • Основное различие между методом .equals () и оператором == заключается в том, что один — это метод, а другой — оператор.
  • Можно использовать операторы == для сравнения ссылок ( сравнение адресов) и метод .equals () для сравнения содержимого .

Проще говоря, == проверяет, указывают ли оба объекта на одно и то же место в памяти, тогда как .equals () оценивает сравнение значений в объектах.

// Java-программа для понимания
// зачем избегать == оператора

public class Test <

public static void main(String[] args)

String s1 = new String( "HELLO" );

String s2 = new String( "HELLO" );

Объяснение: Здесь создаются два объекта String, а именно s1 и s2.

  • И s1, и s2 относятся к разным объектам.
  • Если для сравнения s1 и s2 используется оператор ==, то результат ложен, поскольку оба имеют разные адреса в памяти.
  • Используя equals, результат верен, потому что он сравнивает только значения, заданные в s1 и s2.

У меня есть 2 строки, которые содержат информацию о версии, как показано ниже:

Теперь, может ли кто-нибудь сказать мне эффективный способ сравнить эти версии внутри строк в Java и вернуть 0, если они равны, -1, если str1 str2.

Как указывали другие, String.split() — это очень простой способ выполнить нужное вам сравнение, и Майк Пак делает замечательную мысль, что с такими (вероятными) короткими строками это, вероятно, не имеет большого значения, но что эй! Если вы хотите провести сравнение без ручного разбора строки и иметь возможность отказаться от раннего, вы можете попробовать java.util.Scanner класс.

Я хотел сделать это сам, и я вижу три разных подхода к этому, и до сих пор почти все разделяют строки версии. Я не вижу, чтобы это было эффективным, хотя размер кода мудрый он хорошо читал и выглядел хорошо.

  • Предположим, что верхний предел числа секций (ординалов) в строке версии, а также предел представленного там значения. Часто 4 точки макс и максимум 999 для любого ординала. Вы можете видеть, куда это происходит, и он собирается преобразовать версию, чтобы она вписывалась в строку типа "1.0" = > "001000000000" со строковым форматом или каким-либо другим способом для заполнения каждого ординала. Затем сравните строку.
  • Разделите строки на порядковый разделитель (‘.’) и перейдем к ним и сравните разборную версию. Этот подход хорошо продемонстрировал Алекс Гительман.
  • Сравнение ординалов при их анализе из строк версии, о которых идет речь. Если все строки были просто указателями на массивы символов, как в C, тогда это был бы четкий подход (где вы заменили бы "." Нулевым терминатором, как он нашел, и переместили бы около 2 или 4 указателя.

Мысли о трех подходах:

  • Был сообщение в блоге, в котором показано, как перейти с 1. Ограничения указаны в строке строки строки, количестве разделов и максимальном значение раздела. Я не считаю сумасшедшим иметь такую ​​строку, которая разбивает 10 000 в одной точке. Кроме того, большинство реализаций по-прежнему разбивают строку.
  • Разделение строк заранее ясно, чтобы читать и думать, но мы каждую секунду перебираем каждую строку, чтобы сделать это. Я хотел бы сравнить, как это происходит со следующим подходом.
  • Сравнение строки по мере ее разделения дает вам преимущество в том, что вы можете прекратить расщепление в начале сравнения: "2.1001.100101.9999998" до "1.0.0.0.0.0.1.0.0.0.1". Если бы это были C, а не Java, преимущества могли бы быть ограничены объемом памяти, выделенной для новых строк для каждого раздела каждой версии, но это не так.

Я не видел, чтобы кто-нибудь показывал пример этого третьего подхода, поэтому я хотел бы добавить его здесь, чтобы получить ответ.

Unit test, демонстрирующий ожидаемый результат.

Я использую == оператор в моей программе, чтобы сравнить все мои строки до сих пор. Тем не менее, я столкнулся с ошибкой, изменил один из них на .equals() вместо этого, и он исправил ошибку.

Is == плохо? Когда его следует и не следует использовать? Какая разница?

23 ответов

== тесты для ссылочного равенства (являются ли они одним и тем же объектом).

.equals() тесты на равенство значений (являются ли они логически "равными").

объекты.equals () проверка null перед вызовом .equals() поэтому вам не нужно (доступно с JDK7, также доступно в гуавы).

строку.contentEquals() сравнивает контент String С содержанием любого CharSequence (доступно начиная с Java 1.5).

следовательно, если вы хотите проверить, имеют ли две строки одинаковое значение, вы, вероятно, захотите использовать Objects.equals() .

вы почти всегда хотите использовать Objects.equals() . В редкая ситуации, когда вы знаю вы имеете дело с интернированы строки, вы можете использовать == .

кроме того, строковый литерал всегда относится к то же самое экземпляр класса String . Это связано с тем, что строковые литералы-или, в более общем плане, строки, которые являются значениями постоянных выражений (§15.28) — "интернированы", чтобы поделиться уникальными экземплярами, используя метод String.intern .

аналогичные примеры также можно найти в JLS 3.10.5-1.

Читайте также:  Что такое файловая структура компьютера краткий ответ

== ссылки на объекты тестов, .equals() проверяет строковые значения.

иногда кажется, что == сравнивает значения, потому что Java делает некоторые закулисные вещи, чтобы убедиться, что идентичные строки в строке на самом деле являются одним и тем же объектом.

но остерегайтесь нулей!

== ручки null строки в порядке, но вызов .equals() из нулевой строки вызовет исключение:

так что если вы знаете, что fooString1 может быть null, скажите читателю, что, написав

следующее короче, но менее очевидно, что он проверяет значение null (из Java 7):

== сравнивает ссылки на объект.

.equals() сравнивает строковые значения.

иногда == дает иллюзии сравнения строковых значений, как в следующих случаях:

это потому, что при создании любого строкового литерала JVM сначала ищет этот литерал в пуле строк, и если он найдет совпадение, эта же ссылка будет дана новой строке. Из-за этого мы получаем:

(a==b) ===> правда

однако, == не в следующем случае:

в данном случае new String("test") оператор new String будет создан в куче, и эта ссылка будет дана b , так что b будет дана ссылка на кучу, а не в пуле строк.

теперь a указывает на строку в пуле строк, в то время как b указывает на строку в куче. Из-за этого мы получить:

if (a==b) = = = > false.

пока .equals() всегда сравнивает значение строки, поэтому оно дает true в обоих случаях:

используя .equals() всегда лучше.

на == оператор проверяет, являются ли две строки одним и тем же объектом.

на .equals() метод проверить, если две строки имеют одинаковое значение.

строки в Java являются неизменными. Это означает, что всякий раз, когда вы пытаетесь изменить/изменить строку, вы получаете новый экземпляр. Вы не можете изменить исходную строку. Это было сделано для того, чтобы эти экземпляры string можно было кэшировать. Типичная программа содержит много ссылок на строки, и кэширование этих экземпляров может уменьшить объем памяти и повысить производительность программы.

при использовании оператора == для сравнения строк вы не сравниваете содержимое строки, но на самом деле сравнивают адрес памяти. Если они оба равны, он вернет true и false в противном случае. Тогда как equals in string сравнивает содержимое строки.

Итак, вопрос в том, кэшируются ли все строки в системе, как получилось == возвращает false тогда как equals возвращает true? Ну, это возможно. Если вы создадите новую строку, например String str = new String("Testing") вы в конечном итоге создаете новую строку в кэше, даже если кэш уже содержит строку с тем же содержимым. Вкратце "MyString" == new String("MyString") всегда будет возвращать false.

Java также говорит о функции intern (), которая может использоваться в строке, чтобы сделать ее частью кэша so "MyString" == new String("MyString").intern() вернет true.

Примечание: == оператор намного быстрее, чем equals только потому, что вы сравниваете два адреса памяти, но вы должны быть уверены, что код не создает новые экземпляры строк в коде. В противном случае вы столкнетесь с ошибками.

убедитесь, что вы понимаете почему. Это потому что == сравнение только сравнивает ссылки; equals() метод выполняет символьное сравнение содержимого.

когда вы вызываете новый для a и b , каждый из них получает новую ссылку, которая указывает на "foo" в строке таблицы. Ссылки разные, но содержание одно и то же.

== означает, что ваши две строковые ссылки являются точно таким же объектом. Возможно, вы слышали, что это так, потому что Java сохраняет своего рода литеральную таблицу (что она делает), но это не всегда так. Некоторые строки загружаются по-разному, построены из других строк и т. д., так что вы никогда не должны предполагать, что две одинаковые строки хранятся в одном месте.

Equals делает реальное сравнение для вас.

Да == плохо для сравнения строк (любые объекты действительно, если вы не знаете, что они канонические). == просто сравнивает ссылки на объект. .equals() тесты для равенства. Для строк часто они будут одинаковыми, но, как вы обнаружили, это не всегда гарантировано.

Java имеет пул строк, под которым Java управляет выделением памяти для строковых объектов. См.пулы строк в Java

при проверке (сравнении) двух объектов с помощью == оператор сравнивает равенство адресов в пул строк. Если два строковых объекта имеют одинаковые адресные ссылки, он возвращает true , иначе false . Но если вы хотите сравнить содержимое двух строковых объектов, вы должны переопределить equals метод.

equals фактически является методом класса Object, но он переопределяется в класс String и дается новое определение, которое сравнивает содержимое object.

Читайте также:  Объектив canon ef 24 70mm

но ум его уважает случае строку. Если вы хотите сравнить без учета регистра, вы должны перейти к методу equalsIgnoreCase класса String.

.equals() сравнивает данные в классе (при условии, что функция реализована). == сравнивает местоположения указателей (расположение объекта в памяти).

== возвращает true, если оба объекта (не говоря уже о примитивах) указывают на один и тот же экземпляр объекта. .equals() возвращает true, если два объекта содержат одинаковые сведения equals() и == в Java

это может вам помочь.

== сравнивает ссылки на объекты в Java, и это не исключение для String объекты.

для сравнения фактического содержимого объектов (включая String ), нужно использовать equals метод.

если сравнение двух String объекты с помощью == оказывается true , потому что String объекты были интернированы, и виртуальная машина Java имеет несколько ссылок, указывающих на один и тот же экземпляр из String . Не следует ожидать, что сравнение String объект, содержащий то же содержимое, что и другой String объект с помощью == оценить как true .

Я согласен с ответом закератов.

но что вы можете сделать, это позвонить intern() на не-строковые литералы.

из примера zacherates:

если вы интерн не строковый литерал равенство true

== выполняет ссылка проверка равенства, относятся ли 2 объекта (строки в этом случае) к одному и тому же объекту в памяти.

на equals() метод будет проверять, является ли содержание или государства из 2 объектов одинаковы.

очевидно == быстрее, но будет (может) дать ложные результаты во многих случаях, если вы просто хотите сказать, если 2 String s удерживайте тот же текст.

наверняка использование метод.

не беспокойтесь о производительности. Некоторые вещи, чтобы поощрять использование String.equals() :

  1. реализация String.equals() сначала проверяет равенство ссылок (используя == ), и если 2 строки одинаковы по ссылке, дальнейший расчет не выполняется!
  2. если ссылки на 2 строки не совпадают, String.equals() затем проверит длину строк. Это также быстрая деятельность потому что String класс хранит длину строки, нет необходимости подсчитывать символы или кодовые точки. Если длины различаются, дальнейшая проверка не выполняется, мы знаем, что они не могут быть равными.
  3. только если мы добрались до этого места, содержимое 2 строк будет фактически сравниваться, и это будет сравнение с короткой рукой: не все символы будут сравниваться, если мы найдем несоответствующий символ (в той же позиции в 2 строках), никаких дополнительных символов не будет проверен.

когда все сказано и сделано, даже если у нас есть гарантии, что строки Интерны, используя equals() метод по-прежнему не является накладными расходами, которые можно было бы подумать, определенно рекомендуемый способ. Если вы хотите эффективную проверку ссылок, используйте перечисления, где гарантируется спецификацией языка и реализацией, что одно и то же значение перечисления будет одним и тем же объектом (по ссылке).

если вы похожи на меня, когда я впервые начал использовать Java, я хотел использовать оператор"==", чтобы проверить, равны ли два экземпляра строки, но к лучшему или худшему, это не правильный способ сделать это в Java.

в этом уроке я продемонстрирую несколько различных способов правильного сравнения строк Java, начиная с подхода, который я использую большую часть времени. В конце этого руководства по сравнению строк Java я также расскажу, почему оператор "= = " не работает при сравнении Java веревка.

Вариант 1: сравнение строк Java с методом equals Большую часть времени (возможно, 95% времени) я сравниваю строки с методом equals класса Java String, например:

эта строка equals метод смотрит на две строки Java, и если они содержат точно такую же строку символов, они считаются равными.

взглянув на быстрый пример сравнения строк с методом equals, если следующее тест был запущен, две строки не будут считаться равными, потому что символы не совсем одинаковы (случай символов отличается):

но, когда две строки содержат одну и ту же строку символов, метод equals вернет true, как в этом примере:

Вариант 2: сравнение строк с методом equalsIgnoreCase

в некоторых тестах сравнения строк вы захотите проигнорировать ли строки в верхнем или нижнем регистре. Если вы хотите проверить свои строки на равенство в этом случае без учета регистра, используйте метод equalsIgnoreCase класса String, например:

Вариант 3: сравнение строк Java с методом compareTo

существует также третий, менее распространенный способ сравнения строк Java, и это с помощью метода string class compareTo. Если две строки в точности совпадают, метод compareTo возвращает значение 0 (ноль). Вот краткий пример того, как выглядит этот подход сравнения строк:

пока я пишу об этой концепции равенства в Java, важно отметить, что язык Java включает метод equals в базовый класс объектов Java. Всякий раз, когда вы создаете свои собственные объекты и хотите предоставить средство, чтобы увидеть, являются ли два экземпляра вашего объекта "равными", вы должны переопределить (и реализовать) этот метод equals в своем классе (таким же образом Java язык обеспечивает это поведение равенства / сравнения в методе string equals).

Ссылка на основную публикацию
Спутник вылетел за пределы солнечной системы
«Во́яджер» (англ. voyager , от фр. voyageur — «путешественник») — название двух американских космических аппаратов, запущенных в 1977 году, а...
Снять пароль с роутера tp link
Домашняя беспроводная сеть Wi-Fi должна быть защищена паролем. Но ведь бывают разные случаи, скажете вы. Например, вы хотите пригласить друзей...
Снять пароль с макроса excel
Здравствуйте, друзья! Последние дни бился над такой задачей: Имеется файл .xls, в нем макрос на VBA, защищенный паролем. Файл создается...
Спутниковые системы связи курсовая работа
В данной курсовой работе рассмотрены история, особенности и перспективы развития спутниковой сети связи. Новейшие технологии спутниковой связи предлагают действенные технико-...
Adblock detector