Мне удалось восстановить мое ядро Linux, используя команды, предоставленные в этом сообщении. Особая благодарность @muru за помощь.
Для справки, вот команды, которые я выполнил:
ubuntu@ubuntu:~$ sudo mount /dev/mapper/ubuntu--vg-root /mnt
ubuntu@ubuntu:~$ sudo mount --bind /dev /mnt/dev
ubuntu@ubuntu:~$ ls /mnt/boot
efi
ubuntu@ubuntu:~$ sudo mount /dev/sda2 /mnt/boot
ubuntu@ubuntu:~$ sudo chroot /mnt
root@ubuntu:/# mount -t proc none /proc
root@ubuntu:/# mount -t sysfs none /sys
root@ubuntu:/# mount -t devpts none /dev/pts
root@ubuntu:/# export HOME=/root
root@ubuntu:/# export LC_ALL=C
root@ubuntu:/# apt-get update
root@ubuntu:/# apt-get -y install linux-image-generic
root@ubuntu:/# umount /proc || umount -lf /proc
root@ubuntu:/# umount /sys /dev/pts
root@ubuntu:/# exit
exit
ubuntu@ubuntu:~$ sudo umount /mnt/dev /mnt
Я думаю, что когда вы определяете String, вы определяете объект. Поэтому вам нужно использовать .equals(). Когда вы используете примитивные типы данных, вы используете ==, но с String (и любым объектом) вы должны использовать .equals().
Строки в Java неизменяемы. Это означает, что всякий раз, когда вы пытаетесь изменить / изменить строку, вы получаете новый экземпляр. Вы не можете изменить исходную строку. Это сделано для того, чтобы эти экземпляры строк могли кэшироваться. Типичная программа содержит множество ссылок на строки и кеширование этих экземпляров, что может уменьшить объем памяти и увеличить производительность программы.
При использовании оператора == для сравнения строк вы не сравниваете содержимое строки , но фактически сравнивают адрес памяти. Если они равны, в противном случае они вернут true и false. В то время как equals in string сравнивает содержимое строки.
Итак, вопрос в том, что все строки кэшируются в системе, откуда == возвращает 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
Если вы похожи на меня, когда я впервые начал использовать Java, я хотел использовать оператор «==» для проверки того, были ли два экземпляра String одинаковыми, но к лучшему или худшему, это не правильный способ сделать это в Java.
В этом уроке я продемонстрирую несколько разных способов правильно сравнить строки Java, начиная с подхода, который я использую большую часть времени. В конце этого руководства по сопоставлению Java String я также обсужу, почему оператор «==» не работает при сравнении строк Java.
Вариант 1: Сравнение строк Java с методом equals Большая часть (возможно, в 95% случаев). Я сравниваю строки с методом equals класса Java String следующим образом:
if (string1.equals(string2))
Этот метод String equals проверяет две строки Java, и если они содержат (! d4)
Взглянув на быстрый пример сравнения строк с методом 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.")
}
Вариант 1: Сравнение строк Java с методом equals
В некоторых строковых сравнительных тестах вы будете t, чтобы игнорировать, являются ли строки строчными или строчными. Если вы хотите проверить свои строки на равенство в этом случае нечувствительным образом, используйте метод 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 ()
Оператор == всегда предназначен для сравнения ссылок на объекты, тогда как метод String класса .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, то до тех пор, пока действительная последовательность символов равна, оба объекта считаются равными.
Оператор == проверяет, две строки - это точно один и тот же объект. Метод .equals() проверяет, имеют ли две строки одинаковое значение.Вы также можете использовать метод compareTo() для сравнения двух строк. Если результат compareTo равен 0, то две строки равны, в противном случае сравниваемые строки не равны.
== сравнивает ссылки и не сравнивает фактические строки. Если вы создали каждую строку с помощью new String(somestring).intern(), вы можете использовать оператор == для сравнения двух строк, в противном случае могут использоваться только методы equals () или compareTo.
Все объекты гарантированно имеют метод .equals(), поскольку Object содержит метод .equals(), который возвращает логическое значение. Задача подкласса переопределять этот метод, если требуется дополнительное определение определения. Без него (т. Е. Используя ==) только адреса памяти проверяются между двумя объектами для равенства. String переопределяет этот метод .equals() и вместо использования адреса памяти возвращает сравнение строк на уровне символа для равенства.
Ключевое замечание состоит в том, что строки хранятся в одном пуле модулей, поэтому после создания строки он всегда сохраняется в программе по тому же адресу. Строки не меняются, они неизменяемы. Вот почему это плохая идея использовать регулярную конкатенацию строк, если у вас есть серьезное количество обработки строк. Вместо этого вы будете использовать предоставленные классы StringBuilder. Помните, что указатели на эту строку могут измениться, и если вам было интересно увидеть, были ли два указателя одинаковыми ==, это был бы прекрасный способ. Строки сами этого не делают.
.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 оно уже реализовано и проверяет, имеют ли две строки одно и то же значение.
Случай 1String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s2; //true
s1.equals(s2); //true
Причина: строковые литералы, созданные без null сохраняются в пуле строк в области перментонов кучи. Таким образом, оба s1 и s2 указывают на тот же объект в пуле. Случай 2 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);
Java имеет пул String, под которым 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
== выполняет контрольную проверку равенства, независимо от того, относятся ли 2 объекта (строки в этом случае) к одному и тому же объекту в памяти.
Метод equals() будет проверять, будет ли ссылка или состояния из двух объектов одинаковы.
Очевидно, что == работает быстрее, но во многих случаях может (может) дать ложные результаты, если вы просто хотите сказать, если 2 String s сохраняют один и тот же текст.
Определенно рекомендуется использовать метод equals().
Не беспокойтесь о производительности. Некоторые способы поощрения использования String.equals():
Выполнение String.equals() сначала проверяет ссылочное равенство (используя ==), и если 2 строки одинаковы по ссылке, дальнейшие вычисления не выполняются! Если две строковые ссылки не совпадают, String.equals() будет проверять длину строк. Это также является быстрой операцией, поскольку класс String хранит длину строки, не нужно считать символы или кодовые точки. Если длины отличаются, дальнейшая проверка не выполняется, мы знаем, что они не могут быть равными. Только если мы доберемся до этого, будет фактически сопоставлено содержимое двух строк, и это будет короткое сравнение: не все персонажи будут сравниваться, если мы найдем несоответствующий символ (в том же положении в 2 строках ), никакие другие символы не будут проверяться.Когда все сказано и сделано, даже если у нас есть гарантия, что строки являются стажерами, использование метода equals() все еще не является издержками, которые можно было бы подумать, определенно рекомендуемым способом. Если вам нужна эффективная проверка ссылок, используйте перечисления, где гарантируется спецификацией и реализацией языка, что одно и то же значение перечисления будет одним и тем же объектом (по ссылке).
== сравнивает ссылки на объекты.
.equals() сравнивает значения String.
Иногда == дает иллюзии сравнения значений String, как в следующих случаях:
String a="Test";
String b="Test";
if(a==b) ===> true
Это связано с тем, что при создании любого строкового литерала JVM сначала ищет этот литерал в пуле String, и если он находит совпадение, эта же ссылка будет передана новой 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 в пуле строк, а b указывает на String в куче. Из-за этого мы получаем:
(a == b) ===> true
String Pool
"test" <-------------------- a
Heap
"test" <-------------------- b
Хотя .equals() всегда сравнивает значение String, поэтому он дает истину в обоих случаях:
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() проверяет строковые значения.
Иногда кажется, что == сравнивает значения, потому что 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"));
== сравнивает ссылки на объекты в Java и не является исключением для объектов String.
== сравнивает ссылки на объекты в Java .
Если сравнение двух объектов 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" в таблице строк. Ссылки разные, но контент один и тот же.