767 bytes - это ограничение префикса для таблиц InnoDB в MySQL версии 5.6 (и предыдущих версиях). Это 1000 байтов для таблиц MyISAM. В MySQL версии 5.7 и выше этот предел был увеличен до 3072 байт.
Вы также должны знать, что если вы установите индекс в большом поле char или varchar, кодируемом utf8mb4, вам нужно разделить максимальная длина префикса индекса 767 байтов (или 3072 байта) на 4, что приводит к 191. Это связано с тем, что максимальная длина символа utf8mb4 составляет четыре байта. Для символа utf8 это будет три байта, в результате чего максимальная длина префикса индекса будет равна 254.
Один из вариантов - просто установить нижний предел для полей VARCHAR.
Еще один вариант ( в соответствии с ответом на эту проблему ) следует получить подмножество столбца, а не всю сумму, то есть:
ALTER TABLE `mytable` ADD UNIQUE (column1 (15), столбец 2 (200));
Подчеркните, как вам нужно получить ключ для применения, но мне интересно, стоит ли рассматривать вашу модель данных относительно этого объекта, чтобы увидеть, есть ли улучшения, которые позволят вам реализовать предполагаемые бизнес-правила, не затрагивая ограничение MySQL.
==
тесты для ссылочного равенства (независимо от того, являются ли они одним и тем же объектом).
.equals()
тесты для равенства значений (независимо от того, являются ли они логически «равными»).
Objects.equals () проверяет наличие null
перед вызовом .equals()
, поэтому вам не нужно (доступно с JDK7, также доступным в Guava ).
String.contentEquals () сравнивает содержимое String
с содержимым любого CharSequence
(доступно с Java 1.5).
Следовательно, если вы хотите проверить, имеет ли две строки одно и то же значение, вы, вероятно, захотите использовать Objects.equals()
.
// These two have the same value
new String("test").equals("test") // --> true
// ... but they are not the same object
new String("test") == "test" // --> false
// ... neither are these
new String("test") == new String("test") // --> false
// ... but these are because literals are interned by
// the compiler and thus refer to the same object
"test" == "test" // --> true
// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true
// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true
Вы почти всегда хотите использовать Objects.equals()
. В редкой ситуации, когда вы знаете, что имеете дело с интернированными строками, вы можете использовать ==
.
Из JLS 3.10. 5. Строковые литералы :
Кроме того, строковый литерал всегда ссылается на тот же экземпляр класса
String
. Это связано с тем, что строковые литералы, или, в более общем смысле, строки, которые являются значениями константных выражений ( §15.28 ), «интернированы», чтобы обмениваться уникальными экземплярами, используя методString.intern
.. Подобные примеры также можно найти в JLS 3.10.5-1 .
Строки в Java неизменяемы. Это означает, что всякий раз, когда вы пытаетесь изменить / изменить строку, вы получаете новый экземпляр. Вы не можете изменить исходную строку. Это сделано для того, чтобы эти экземпляры строк могли кэшироваться. Типичная программа содержит множество ссылок на строки и кеширование этих экземпляров, что может уменьшить объем памяти и увеличить производительность программы.
При использовании оператора == для сравнения строк вы не сравниваете содержимое строки , но фактически сравнивают адрес памяти. Если они равны, в противном случае они вернут true и false. Если значение равно в строке, сравнивает содержимое строки.
Итак, вопрос в том, что все строки кэшируются в системе, как получается ==
возвращает false, тогда как equals возвращает true? Ну, это возможно. Если вы создадите новую строку, например String str = new String("Testing")
, вы создадите новую строку в кеше, даже если в кеше уже содержится строка с тем же содержимым. Короче говоря, "MyString" == new String("MyString")
всегда будет возвращать false.
Java также говорит о функции intern (), которая может использоваться в строке, чтобы сделать ее частью кеша, поэтому "MyString" == new String("MyString").intern()
вернет true.
Примечание: == оператор намного быстрее, чем равен только потому, что вы сравниваете два адреса памяти, но вы должны быть уверены, что код не создает новые экземпляры String в коде. В противном случае вы столкнетесь с ошибками.
Я согласен с ответом от zacherates.
Но вы можете сделать вызов intern () в ваших нелиберальных строках.
Из примера zacherates:
// ... but they are not the same object
new String("test") == "test" ==> false
Если вы ставите нелитеральное равенство строки, это правда
new String("test").intern() == "test" ==> true
==
для сравнения строк.
– Stephen C
25 September 2015 в 23:16
Если вы похожи на меня, когда я впервые начал использовать Java, я хотел использовать оператор «==» для проверки того, были ли два экземпляра String одинаковыми, но к лучшему или худшему это не правильный способ сделать это в Java.
В этом уроке я продемонстрирую несколько разных способов правильно сравнить строки Java, начиная с подхода, который я использую большую часть времени. В конце этого руководства по сопоставлению Java String я также обсужу, почему оператор «==» не работает при сравнении строк Java.
Вариант 1: Сравнение строк Java с методом equals Большая часть (возможно, в 95% случаев). Я сравниваю строки с методом equals класса Java String следующим образом:
if (string1.equals(string2))
Этот метод String равен методу для двух строк Java, и если они содержат точно такую же строку символов, они считаются равными.
Взглянув на быстрый пример сравнения строк с методом equals, если был выполнен следующий тест, две строки не будут считаться равными, поскольку символы не являются точно такими же (случай символов различен):
String string1 = "foo";
String string2 = "FOO";
if (string1.equals(string2))
{
// this line will not print because the
// java string equals method returns false:
System.out.println("The two strings are the same.")
}
Но, когда две строки содержат одну и ту же строку символов, метод equals вернет true, как в этот пример:
String string1 = "foo";
String string2 = "foo";
// test for equality with the java string equals method
if (string1.equals(string2))
{
// this line WILL print
System.out.println("The two strings are the same.")
}
Вариант 2: Сравнение строк с методом equalsIgnoreCase
В некоторых строковых сравнительных тестах вы захотите игнорируйте, являются ли строки строчными или строчными. Если вы хотите проверить свои строки на равенство в этом случае нечувствительным образом, используйте метод equalsIgnoreCase класса String, например:
String string1 = "foo";
String string2 = "FOO";
// java string compare while ignoring case
if (string1.equalsIgnoreCase(string2))
{
// this line WILL print
System.out.println("Ignoring case, the two strings are the same.")
}
Вариант 3: сравнение строк Java с методом compareTo
Существует также третий, менее распространенный способ сравнения строк Java, и это с методом сравнения String класса. Если две строки точно совпадают, метод compareTo вернет значение 0 (ноль). Ниже приведен краткий пример того, как выглядит этот метод сравнения строк:
String string1 = "foo bar";
String string2 = "foo bar";
// java string compare example
if (string1.compareTo(string2) == 0)
{
// this line WILL print
System.out.println("The two strings are the same.")
}
Пока я пишу об этой концепции равенства в Java, важно отметить, что язык Java включает в себя метод equals в базовый класс Java Object. Всякий раз, когда вы создаете свои собственные объекты, и вы хотите предоставить средства для проверки того, являются ли два экземпляра вашего объекта «равными», вы должны переопределить (и реализовать) этот метод equals в своем классе (точно так же, как язык Java предоставляет это равенство / сравнение в методе String равно).
Вы можете посмотреть на это ==, .equals (), compareTo () и compare ()
Оператор == всегда предназначен для сравнения ссылок на объекты, тогда как метод сравнения строк .equals () переопределяется для сравнения содержимого:
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // It prints false (reference comparison)
System.out.println(s1.equals(s2)); // It prints true (content comparison)
В Java, когда оператор «==» используется для сравнения двух объектов, он проверяет, ссылаются ли объекты на одно и то же место в памяти. Другими словами, он проверяет, являются ли имена двух объектов в основном ссылками на одно и то же место в памяти.
Класс Java String фактически переопределяет реализацию equals () по умолчанию в классе Object и переопределяет этот метод, чтобы он проверял только значения строк, а не их местоположения в памяти. Это означает, что если вы вызываете метод equals () для сравнения двух объектов String, то, пока действительная последовательность символов равна, оба объекта считаются равными.
Оператор
==
проверяет, являются ли две строки точно одним и тем же объектом.Метод
blockquote>.equals()
проверяет, имеют ли две строки одно и то же значение.
Вы также можете использовать метод compareTo()
для сравнения двух строк. Если результат compareTo равен 0, то две строки равны, в противном случае сравниваемые строки не равны.
==
сравнивает ссылки и не сравнивает фактические строки. Если вы создали каждую строку, используя new String(somestring).intern()
, вы можете использовать оператор ==
для сравнения двух строк, в противном случае могут использоваться только методы equals () или compareTo.
Все объекты гарантированно имеют метод .equals()
, поскольку Object содержит метод, .equals()
, который возвращает логическое значение. Задача подкласса переопределять этот метод, если требуется дополнительное определение определения. Без него (т. Е. С помощью ==
) только адреса памяти проверяются между двумя объектами для равенства. String переопределяет этот метод .equals()
и вместо использования адреса памяти возвращает сравнение строк на уровне символа для равенства.
Ключевое замечание состоит в том, что строки хранятся в одном пуле, поэтому после создания строки он всегда хранится в программе по тому же адресу. Строки не меняются, они неизменяемы. Вот почему это плохая идея использовать регулярную конкатенацию строк, если у вас есть серьезное количество обработки строк. Вместо этого вы будете использовать предоставленные классы StringBuilder
. Помните, что указатели на эту строку могут измениться, и если вам было интересно увидеть, были ли два указателя одинаковыми ==
, это был бы прекрасный способ. Строки сами не делают.
equals()
для String
фактически находится в классе String
, а не в Object
. По умолчанию equals()
в Object
не сравнится, что содержимое одного и того же, и на самом деле просто возвращает true, когда ссылка одинаков.
– Jacob Schoen
20 November 2012 в 19:04
final String
) и строки, в которых ваша программа явно стажеров, хранятся в том, что вы называете «куском пула». Все остальные String
объекты подлежат сборке мусора, если на них больше нет ссылок на живые ссылки, как и любой другой тип объекта. Кроме того, хотя для всего интернирующего механизма требуется неизменность, в противном случае это не имеет отношения к этому.
– Ted Hopp
10 April 2014 в 19:13
.equals()
сравнивает данные в классе (при условии, что функция реализована). ==
сравнивает местоположения указателя (расположение объекта в памяти).
==
возвращает true, если оба объекта (NOT TALKING OF PRIMITIVES) указывают на экземпляр SAME. .equals()
возвращает true, если два объекта содержат одни и те же данные equals()
Versus ==
в Java
Это может вам помочь.
Если метод equals()
присутствует в классе java.lang.Object
, и ожидается, что он проверяет эквивалентность состояния объектов! Это означает, что содержимое объектов. В то время как ожидается, что оператор ==
проверяет, что фактические экземпляры объекта одинаковы или нет.
Пример
Рассмотрим две различные ссылочные переменные, str1
и str2
:
str1 = new String("abc");
str2 = new String("abc");
Если вы используете equals()
System.out.println((str1.equals(str2))?"TRUE":"FALSE");
, вы получите выход как TRUE
, если вы используете ==
.
System.out.println((str1==str2) ? "TRUE" : "FALSE");
Теперь вы получите вывод FALSE
в качестве вывода, потому что оба str1
и str2
указывают на два разных объекта, хотя оба они имеют одинаковое строковое содержимое. Именно из-за new String()
каждый новый объект создается каждый раз.
Оператор ==
проверяет, указывают ли две ссылки на один и тот же объект или нет. .equals()
проверьте фактическое содержимое строки (значение).
Обратите внимание, что метод .equals()
принадлежит классу Object
(суперкласс всех классов). Вам необходимо переопределить его в соответствии с вашим требованием к классу, но для String оно уже реализовано и проверяет, имеет ли две строки одно и то же значение.
String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s2; //true
s1.equals(s2); //true
Причина: строка литералы, созданные без нуля, хранятся в пуле строк в области перментонов кучи. Таким образом, оба s1 и s2 указывают на один и тот же объект в пуле. String s1 = new String("Stack Overflow");
String s2 = new String("Stack Overflow");
s1 == s2; //false
s1.equals(s2); //true
Причина. Если вы создаете объект String с использованием ключевого слова new
, ему выделяется отдельное пространство в куче. Функция:
public float simpleSimilarity(String u, String v) {
String[] a = u.split(" ");
String[] b = v.split(" ");
long correct = 0;
int minLen = Math.min(a.length, b.length);
for (int i = 0; i < minLen; i++) {
String aa = a[i];
String bb = b[i];
int minWordLength = Math.min(aa.length(), bb.length());
for (int j = 0; j < minWordLength; j++) {
if (aa.charAt(j) == bb.charAt(j)) {
correct++;
}
}
}
return (float) (((double) correct) / Math.max(u.length(), v.length()));
}
Тест:
String a = "This is the first string.";
String b = "this is not 1st string!";
// for exact string comparison, use .equals
boolean exact = a.equals(b);
// For similarity check, there are libraries for this
// Here I'll try a simple example I wrote
float similarity = simple_similarity(a,b);
==
и equals
уже были ответы на другие решения, я просто предложил другой способ сравнить строки по-разному
– Khaled.K
10 September 2015 в 20:45
Java имеет пул строк, в котором Java управляет распределением памяти для объектов String. См. String Pools в Java
Когда вы проверяете (сравниваете) два объекта с помощью оператора ==
, он сравнивает равенство адресов в пуле строк. Если два объекта String имеют одинаковые адреса, то он возвращает true
, в противном случае false
. Но если вы хотите сравнить содержимое двух объектов String, вы должны переопределить метод equals
.
equals
- фактически метод класса Object, но он переопределяется в класс String и дается новое определение, которое сравнивает содержимое объекта.
Example:
stringObjectOne.equals(stringObjectTwo);
Но помните, что это относится к случаю String. Если вы хотите сравнить регистр без учета регистра, вы должны пойти для метода equalsIgnoreCase класса String.
Давайте посмотрим:
String one = "HELLO";
String two = "HELLO";
String three = new String("HELLO");
String four = "hello";
one == two; // TRUE
one == three; // FALSE
one == four; // FALSE
one.equals(two); // TRUE
one.equals(three); // TRUE
one.equals(four); // FALSE
one.equalsIgnoreCase(four); // TRUE
==
сравнивает ссылки на объекты.
.equals()
сравнивает значения String.
Иногда ==
дает иллюзии сравнения значений String, как в следующих случаях:
String a="Test";
String b="Test";
if(a==b) ===> true
Это связано с тем, что при создании любого строкового литерала JVM сначала ищет этот литерал в пуле строк, и если он найдет совпадение, эта же ссылка будет передана новой String. Из-за этого получаем:
(a == b) ===> true
String Pool
b -----------------> "test" <-----------------a
Однако ==
не выполняется в следующем случае:
String a="test";
String b=new String("test");
if (a==b) ===> false
В этом случае для new String("test")
оператор new String будет создан в куче, и эта ссылка будет указана на b
, поэтому b
будет дана ссылка на кучу, а не на String pool.
Теперь a
указывает на String в пуле String, а b
указывает на String в куче. Из-за этого мы получаем:
, если (a == b) ===> false.
String Pool
"test" <-------------------- a
Heap
"test" <-------------------- b
Пока .equals()
всегда сравнивает значение String, поэтому дает true в обоих случаях:
String a="Test";
String b="Test";
if(a.equals(b)) ===> true
String a="test";
String b=new String("test");
if(a.equals(b)) ===> true
Таким образом, использование .equals()
всегда лучше.
.equals()
сравнивает экземпляры (ссылки / адрес), где в качестве методов класса String .equals()
переопределяется для сравнения содержимого (символов)
– Satyadev
7 May 2016 в 10:54
String
объекты для сохранения объема памяти, поскольку String
известен тем, что он неизменен (я надеюсь, что правильно говорю здесь). Также проверьте stackoverflow.com/questions/3052442/…
– Roland
10 November 2017 в 14:34
==
проверяет ссылки на объекты, .equals()
проверяет строковые значения.
Иногда кажется, что ==
сравнивает значения, потому что Java делает некоторые закулисные вещи, чтобы убедиться, что одинаковые строки в строке являются одним и тем же объектом.
Для Например:
String fooString1 = new String("foo");
String fooString2 = new String("foo");
// Evaluates to false
fooString1 == fooString2;
// Evaluates to true
fooString1.equals(fooString2);
// Evaluates to true, because Java uses the same object
"bar" == "bar";
Но будьте осторожны с нулями!
==
обрабатывает строки null
в порядке, но вызов .equals()
из пустой строки приведет к исключению:
String nullString1 = null;
String nullString2 = null;
// Evaluates to true
System.out.print(nullString1 == nullString2);
// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));
Итак, если вы знаете, что fooString1
может но не менее очевидно, что он проверяет значение null (из Java 7):
System.out.print(Objects.equals(fooString1, "bar"));
==
do i> всегда сравнивает значения! (Просто определенные значения являются ссылками!)
– aioobe
24 July 2012 в 13:44
?.
. Это преобразует nullString1?.equals(nullString2);
в полностью нулевой оператор. Однако это не поможет, если у вас есть validString?.equals(nullString);
- это все еще вызывает исключение.
– Charles Wood
25 June 2014 в 17:28
==
сравнивает ссылки на объекты в Java и не является исключением для объектов String
.
Для сравнения фактического содержимого объектов (в том числе String
) необходимо использовать equals
.
Если сравнение двух объектов String
с использованием ==
оказывается true
, это связано с тем, что объекты String
были интернированы, а виртуальная машина Java имеет несколько ссылки указывают на тот же экземпляр String
. Не следует ожидать сравнения одного объекта String
, содержащего то же содержимое, что и другой объект String
, используя ==
для оценки как true
.
String a = new String("foo");
String b = new String("foo");
System.out.println(a == b); // prints false
System.out.println(a.equals(b)); // prints true
Убедитесь, что вы понимаете, почему. Это потому, что сравнение ==
сравнивает только ссылки; equals()
метод сопоставляет содержимое по символу.
Когда вы вызываете new для a
и b
, каждый получает новую ссылку, указывающую на "foo"
в таблице строк. Ссылки разные, но контент один и тот же.
Да, ==
плохо для сравнения строк (любые объекты действительно, если вы не знаете, что они канонические). ==
просто сравнивает ссылки на объекты. .equals()
тесты для равенства. Для строк часто они будут такими же, но, как вы обнаружили, это не гарантируется всегда.
Да, это плохо ...
==
означает, что ваши две ссылки на строки - это точно один и тот же объект. Возможно, вы слышали, что это так, потому что Java хранит личную таблицу (что она делает), но это не всегда так. Некоторые строки загружаются по-разному, построены из других строк и т. Д., Поэтому вы никогда не должны предполагать, что две одинаковые строки хранятся в одном месте.
Equals делает реальное сравнение для вас.
==
сравнивает опорное значение объектов, тогда как equals()
метод присутствует в java.lang.String
класса сравнивает содержимое String
объекта (к другому объекту). equals()
для String
фактически находится в классе String
, а не в Object
. По умолчанию equals()
в Object
не сравнится, что содержимое одного и того же, и на самом деле просто возвращает true, когда ссылка одинаков.
– Jacob Schoen
20 November 2012 в 19:04
equals()
, если у вас нет веской причины. i> То, что вы называете безопасностью, полностью зависит от контекста. Например, при сравнении паролей, чтобы определить, введен ли пользователь правильный пароль, небезопасно игнорировать различия в регистре. – Nicolas Barbulesco 22 August 2013 в 10:06