Saya ingin melakukan beberapa tindakan HANYA JIKA saya string memiliki nilai yang berarti. Jadi, saya mencoba ini.
if (!myString.equals("")) {
doSomething
}
dan ini
if (!myString.equals(null)) {
doSomething
}
dan ini
if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}
dan ini
if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}
dan ini
if ( myString.length()>0) {
doSomething
}
Dan dalam semua kasus program saya melakukan sesuatu
meskipun pada kenyataan bahwa saya string KOSONG. Itu sama dengan null
. Jadi, apa yang salah dengan itu?
DITAMBAHKAN:
Saya menemukan alasan dari masalah. Variabel dideklarasikan sebagai string dan, sebagai akibatnya, null
ditugaskan untuk variabel ini berubah menjadi "null"
! Jadi, jika (!myString.sama dengan("null"))
bekerja.
if (myString != null && !myString.isEmpty()) {
// doSomething
}
Sebagai komentar lebih lanjut, anda harus mengetahui istilah ini dalam sama dengan
kontrak:
Dari Object.equals(Object)
:
Untuk non-null referensi nilai
x
,x.equals(null)
harusreturn false
.
Cara untuk membandingkan dengan null
adalah dengan menggunakan x == null
dan x != null
.
Selain itu, x.field
dan x.metode()
melempar NullPointerException
jika x == null
.
Jika myString
adalah null
, kemudian memanggil myString.equals(null)
atau myString.sama dengan("")
akan gagal dengan NullPointerException
. Anda tidak dapat memanggil setiap contoh metode null variabel.
Memeriksa null pertama seperti ini:
if (myString != null && !myString.equals("")) {
//do something
}
Hal ini membuat penggunaan short-circuit evaluasi untuk tidak mencoba .sama dengan
jika myString
gagal null cek.
Jika myString sebenarnya null, maka setiap panggilan untuk referensi akan gagal dengan Null Pointer Exception (NPE). Sejak java 6, gunakan #isEmpty bukan panjang check (dalam hal apapun tidak PERNAH membuat String kosong dengan check).
if (myString !=null && !myString.isEmpty()){
doSomething();
}
Kebetulan jika membandingkan dengan String literal seperti yang anda lakukan, akan membalikkan pernyataan agar tidak harus memiliki null cek, saya.e,
if (("some string to check").equals(myString)){
doSomething();
}
bukannya :
if (myString !=null && !myString.equals("some string to check")){
doSomething();
}
BEKERJA !!!!
if (myString != null && !myString.isEmpty()) {
return true;
}
else {
return false;
}
Jika anda string null, panggilan seperti ini harus membuang NullReferenceException:
myString.equals(null)
Tapi bagaimanapun, saya pikir metode seperti ini adalah apa yang anda inginkan:
public static class StringUtils
{
public static bool isNullOrEmpty(String myString)
{
return myString == null || "".equals(myString);
}
}
Kemudian dalam kode anda, anda dapat melakukan hal-hal seperti ini:
if (!StringUtils.isNullOrEmpty(myString))
{
doSomething();
}
if (myString != null && myString.length() > 0) {
// your magic here
}
Kebetulan, jika anda melakukan banyak manipulasi string, ada's Spring kelas dengan segala macam metode yang berguna:
http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html
Setiap kali saya harus berurusan dengan string (hampir setiap waktu) saya berhenti dan bertanya-tanya mana cara ini benar-benar cara tercepat untuk memeriksa string kosong. Tentu saja string.Length == 0 check harus menjadi yang tercepat sejak Suhu udara adalah properti dan seharusnya ada't akan ada pengolahan lain dari mengambil nilai dari properti. Tapi kemudian saya bertanya pada diri sendiri, mengapa ada String.Kosong? Ini harus lebih cepat untuk memeriksa String.Kosong dari panjang, aku berkata pada diriku sendiri. Yah aku akhirnya memutuskan untuk menguji itu. Saya dikodekan kecil Jendela Konsol aplikasi yang memberitahu saya berapa lama waktu yang dibutuhkan untuk melakukan suatu memeriksa 10 juta repetisi. Aku memeriksa 3 senar yang berbeda: NULL string, string Kosong, dan "," string. Saya menggunakan 5 metode yang berbeda: String.IsNullOrEmpty(), str == null, str == null || str == String.Kosong, str == null || str == "", str == null || str.length == 0. Berikut ini adalah hasil:
String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds
str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds
str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds
str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds
str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds
Menurut hasil penelitian ini, rata-rata memeriksa str == null
adalah yang tercepat, tetapi mungkin tidak selalu menghasilkan apa yang kita're looking for. jika str = String.Kosong
atau str = ""
, maka hasilnya adalah false. Maka anda memiliki 2 yang terikat di tempat kedua: String.IsNullOrEmpty()
dan str == null || str.length == 0
. Sejak String.IsNullOrEmpty()
terlihat lebih baik dan lebih mudah (dan cepat) untuk menulis saya akan merekomendasikan menggunakan ini atas solusi lain.
Saya akan mendorong menggunakan sebuah utilitas yang ada, atau membuat anda sendiri dengan metode:
public static boolean isEmpty(String string) {
return string == null || string.length() == 0;
}
Kemudian hanya menggunakannya ketika anda membutuhkannya:
if (! StringUtils.isEmpty(string)) {
// do something
}
Seperti disebutkan di atas, | | dan && operator sirkuit pendek. Itu berarti segera setelah mereka dapat menentukan nilai mereka, mereka berhenti. Jadi jika (string == null) adalah benar, panjang bagian yang tidak perlu dievaluasi, sebagai ekspresi akan selalu menjadi kenyataan. Demikian juga dengan &&, dimana jika sisi kiri adalah palsu, ekspresi yang selalu salah dan tidak perlu dievaluasi lebih lanjut.
Sebagai catatan tambahan, menggunakan panjang ini umumnya ide yang lebih baik dari yang menggunakan .sama. Kinerja yang sedikit lebih baik (tidak banyak), dan doesn't membutuhkan objek penciptaan (meskipun sebagian besar kompiler mungkin mengoptimalkan hal ini).
Saya telah menggunakan StringUtil.isBlank(string)
Tes jika string kosong: null, tidak menemukan apa-apa, atau hanya spasi.
Jadi yang satu ini adalah yang terbaik sejauh ini
Berikut ini adalah orignal metode dari docs
/**
* Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
* @param string string to test
* @return if string is blank
*/
public static boolean isBlank(String string) {
if (string == null || string.length() == 0)
return true;
int l = string.length();
for (int i = 0; i < l; i++) {
if (!StringUtil.isWhitespace(string.codePointAt(i)))
return false;
}
return true;
}
I'd melakukan sesuatu seperti ini:
( myString != null && myString.length() > 0 )
? doSomething() : System.out.println("Non valid String");
Untuk memeriksa apakah string yang memiliki konten yang bermakna di Jawa adalah yang satu ini:
string != null && !string.trim().isEmpty()
Pertama anda memeriksa apakah string null
untuk menghindari NullPointerException
dan kemudian anda memangkas semua karakter ruang untuk menghindari memeriksa string yang hanya memiliki spasi putih dan akhirnya anda memeriksa jika dipangkas string tidak kosong, saya.e memiliki panjang 0.
Oke ini adalah bagaimana tipe data yang bekerja di pulau Jawa. (Anda harus memaafkan saya di inggris, saya prob. tidak menggunakan hak vocab. Anda harus membedakan antara dua dari mereka. Dasar tipe data dan tipe data normal. Dasar tipe data yang cukup banyak membuat segala sesuatu yang ada. Misalnya, ada semua angka, char, boolean, dll. Normal jenis data atau kompleks jenis data adalah segala sesuatu yang lain. String adalah sebuah array karakter, oleh karena itu data yang kompleks, jenis.
Setiap variabel yang anda buat adalah benar-benar pointer pada nilai di memori anda. Misalnya:
String s = new String("This is just a test");
variabel "s" TIDAK mengandung String. Itu adalah pointer. Pointer ini menunjuk pada variabel di memori anda.
Ketika anda menelepon Sistem.keluar.println(anyObject)
, yang toString()
metode dari objek yang disebut. Jika hal itu tidak menimpa `toString dari Object, maka akan mencetak pointer.
Misalnya:
public class Foo{
public static void main(String[] args) {
Foo f = new Foo();
System.out.println(f);
}
}
>>>>
>>>>
>>>>Foo@330bedb4
Semuanya balik "@" adalah pointer. Ini hanya bekerja untuk kompleks jenis data. Primitif tipe data LANGSUNG disimpan dalam pointer. Jadi sebenarnya tidak ada pointer dan nilai-nilai yang disimpan secara langsung.
Misalnya:
int i = 123;
saya TIDAK menyimpan pointer dalam kasus ini. aku akan menyimpan nilai integer 123 (dalam byte ofc).
Oke, jadi mari kita kembali ke ==
operator.
Itu selalu membandingkan pointer dan bukan konten yang disimpan pada pointer's posisi dalam memori.
Contoh:
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1 == s2);
>>>>> false
Ini kedua String memiliki pointer yang berbeda. String.equals(String lain) namun membandingkan isi. Anda dapat membandingkan primitif tipe data dengan '==' operator karena pointer dari dua objek yang berbeda dengan isi yang sama adalah sama.
Null berarti bahwa pointer kosong. Kosong primitif tipe data secara default adalah 0 (untuk bilangan). Null untuk setiap obyek yang kompleks namun berarti, bahwa objek tidak ada.
Salam
Ini harus bekerja:
if (myString != null && !myString.equals(""))
doSomething
}
Jika tidak, maka myString mungkin memiliki nilai bahwa anda tidak mengharapkan. Cobalah mencetak keluar seperti ini:
System.out.println("+" + myString + "+");
Menggunakan '+' simbol untuk mengelilingi string akan menunjukkan anda jika ada spasi tambahan di sana bahwa anda're tidak akuntansi untuk.
Aku punya masalah ini di android dan saya menggunakan cara ini (Bekerja untuk saya):
String test = null;
if(test == "null"){
// Do work
}
Tetapi di pulau jawa kode yang saya gunakan :
String test = null;
if(test == null){
// Do work
}
Dan :
private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
return compareDateStrings(strDate0, strDate1);
}
private Integer compareDateStrings(String strDate0, String strDate1) {
int cmp = 0;
if (isEmpty(strDate0)) {
if (isNotEmpty(strDate1)) {
cmp = -1;
} else {
cmp = 0;
}
} else if (isEmpty(strDate1)) {
cmp = 1;
} else {
cmp = strDate0.compareTo(strDate1);
}
return cmp;
}
private boolean isEmpty(String str) {
return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
return !isEmpty(str);
}
Saya lebih memilih untuk menggunakan:
if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
// do something
}
Di Android, anda dapat memeriksa ini dengan utilitas metode isEmpty
dari TextUtils
,
public static boolean isEmpty(CharSequence str) {
return str == null || str.length() == 0;
}
isEmpty(CharSequence str)
metode memeriksa kedua kondisi, untuk null
dan panjang.