Ik wil ALLEEN een actie uitvoeren ALS mijn string een betekenisvolle waarde heeft. Dus ik heb dit geprobeerd.
if (!myString.equals("")) {
doSomething
}
en dit
if (!myString.equals(null)) {
doSomething
}
en dit
if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}
en dit
if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}
en dit
if ( myString.length()>0) {
doSomething
}
En in alle gevallen mijn programma doSomethingondanks het feit dat mijn string LEEG IS. Het is gelijk aan null. Dus wat is daar mis mee?
TOEGEVOEGD:
Ik heb de oorzaak van het probleem gevonden. De variabele werd gedeclareerd als een string en als gevolg daarvan werd nulltoegewezen aan deze variabele getransformeerd naar "null"! Dus if (!myString.equals("null"))werkt.
Antwoord 1, autoriteit 100%
if (myString != null && !myString.isEmpty()) {
// doSomething
}
Als verdere opmerking, moet u op de hoogte zijn van deze term in het equals-contract:
Voor elke niet-null referentiewaarde
x, moetx.equals(null)return false.
De manier om te vergelijken met nullis door x == nullen x != nullte gebruiken.
Bovendien gooien x.fielden x.method()NullPointerExceptionals x == null.
Antwoord 2, autoriteit 12%
Als myStringnullis, roept u myString.equals(null)of myString.equals("")zal mislukken met een NullPointerException. U kunt geen instantiemethoden op een null-variabele aanroepen.
Controleer eerst op null als volgt:
if (myString != null && !myString.equals("")) {
//do something
}
Dit maakt gebruik van kortsluitingsevaluatieom de .equalsals myStringde nulcontrole niet doorstaat.
Antwoord 3, autoriteit 9%
Apache commons StringUtils.isNotEmptyis de beste manier om te gaan.
Antwoord 4, autoriteit 6%
Als myString in feite null is, zal elke aanroep naar de referentie mislukken met een Null Pointer Exception (NPE).
Gebruik sinds java 6 #isEmptyin plaats van lengtecontrole (maak in ieder geval NOOIT een nieuwe lege String met de controle).
if (myString != null && !myString.isEmpty()){
doSomething();
}
Trouwens, als je vergelijkt met String-letterwoorden zoals jij, zou je de instructie omkeren zodat er geen nulcontrole hoeft te worden uitgevoerd, d.w.z.
if ("some string to check".equals(myString)){
doSomething();
}
in plaats van:
if (myString != null && myString.equals("some string to check")){
doSomething();
}
Antwoord 5, autoriteit 4%
WERKEN !!!!
if (myString != null && !myString.isEmpty()) {
return true;
}
else {
return false;
}
Bijgewerkt
Voor Kotlin controleren we of de string null is of niet door te volgen
return myString.isNullOrEmpty() // Returns `true` if this nullable String is either `null` or empty, false otherwise
return myString.isEmpty() // Returns `true` if this char sequence is empty (contains no characters), false otherwise
Antwoord 6, autoriteit 2%
U moet controleren of het myString-object nullis:
if (myString != null) {
doSomething
}
Antwoord 7, autoriteit 2%
Als je string null is, zouden aanroepen als deze een NullReferenceException moeten opleveren:
myString.equals(null)
Maar goed, ik denk dat een methode als deze is wat je wilt:
public static class StringUtils
{
public static bool isNullOrEmpty(String myString)
{
return myString == null || "".equals(myString);
}
}
Dan kun je in je code de volgende dingen doen:
if (!StringUtils.isNullOrEmpty(myString))
{
doSomething();
}
Antwoord 8, autoriteit 2%
Ik raad u aan een bestaand hulpprogramma te gebruiken of uw eigen methode te maken:
public static boolean isEmpty(String string) {
return string == null || string.length() == 0;
}
Gebruik het dan gewoon wanneer je het nodig hebt:
if (! StringUtils.isEmpty(string)) {
// do something
}
Zoals hierboven vermeld, is de || en && operators kortsluiting. Dat betekent dat ze stoppen zodra ze hun waarde kunnen bepalen. Dus als (string == null) waar is, hoeft het lengtegedeelte niet te worden geëvalueerd, omdat de uitdrukking altijd waar zou zijn. Hetzelfde geldt voor &&, waarbij als de linkerkant onwaar is, de uitdrukking altijd onwaar is en niet verder hoeft te worden geëvalueerd.
Als extra opmerking is het gebruik van lengte over het algemeen een beter idee dan het gebruik van .equals. De prestatie is iets beter (niet veel) en vereist geen objectcreatie (hoewel de meeste compilers dit kunnen optimaliseren).
Antwoord 9, autoriteit 2%
Probeer,
myString!=null && myString.length()>0
Antwoord 10, autoriteit 2%
if (myString != null && myString.length() > 0) {
// your magic here
}
Trouwens, als je veel stringmanipulatie doet, is er een geweldige Spring-klasse met allerlei handige methoden:
http://static .springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html
Antwoord 11, autoriteit 2%
Elke keer als ik met strings te maken heb (bijna elke keer) stop ik en vraag ik me af welke manier echt de snelste manier is om te controleren op een lege string. Natuurlijk moet de string.Length == 0 controle de snelste zijn aangezien Length een eigenschap is en er geen andere verwerking zou moeten zijn dan het ophalen van de waarde van de eigenschap. Maar dan vraag ik me af, waarom is er een String.Empty? Het zou sneller moeten zijn om te controleren op String.Empty dan op lengte, houd ik mezelf voor. Nou, ik heb uiteindelijk besloten om het uit te testen. Ik heb een kleine Windows Console-app gecodeerd die me vertelt hoe lang het duurt om een bepaalde controle uit te voeren voor 10 miljoen herhalingen. Ik heb 3 verschillende strings gecontroleerd: een NULL string, een lege string en een “” string. Ik heb 5 verschillende methoden gebruikt: String.IsNullOrEmpty(), str == null, str == null || str == String.Leeg, str == null || str == “”, str == null || str.length == 0. Hieronder staan de resultaten:
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
Volgens deze resultaten is het gemiddeld controleren op str == nullde snelste, maar levert niet altijd op wat we zoeken. if str = String.Emptyof str = "", resulteert dit in false. Dan heb je er 2 die op de tweede plaats staan: String.IsNullOrEmpty()en str == null || str.length == 0. Aangezien String.IsNullOrEmpty()er mooier uitziet en gemakkelijker (en sneller) te schrijven is, raad ik aan om het boven de andere oplossing te gebruiken.
Antwoord 12
Ik zou zoiets als dit doen:
( myString != null && myString.length() > 0 )
? doSomething() : System.out.println("Non valid String");
- Testen op null controleert of myString een instantie van String bevat.
- length() geeft de lengte terug en is gelijk aan equals(“”).
- Als eerst wordt gecontroleerd of myString null is, wordt een NullPointerException vermeden.
Antwoord 13
Ik gebruik StringUtil.isBlank(string)
Het test of een tekenreeks leeg is: null, emtpy of alleen witruimte.
Dus dit is de beste tot nu toe
Hier is de originele methode uit de documenten
/**
* 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;
}
Antwoord 14
Voor mij is de beste controle of een string betekenisvolle inhoud heeft in Java deze:
string != null && !string.trim().isEmpty()
Eerst controleer je of de tekenreeks nullis om NullPointerExceptionte vermijden en dan trim je alle spatietekens om te voorkomen dat tekenreeksen die alleen spaties hebben gecontroleerd worden en tot slot controleer je of de bijgesneden string is niet leeg, dwz heeft lengte 0.
Antwoord 15
Dit zou moeten werken:
if (myString != null && !myString.equals(""))
doSomething
}
Zo niet, dan heeft myString waarschijnlijk een waarde die u niet verwacht. Probeer het als volgt af te drukken:
System.out.println("+" + myString + "+");
Als u de ‘+’-symbolen gebruikt om de tekenreeks te omringen, ziet u of er extra witruimte is waar u geen rekening mee houdt.
Antwoord 16
if(str.isEmpty() || str==null){
do whatever you want
}
Antwoord 17
Ok, zo werken datatypes in Java. (Je moet mijn Engels excuseren, ik gebruik waarschijnlijk niet de juiste vocab.
Je moet onderscheid maken tussen twee van hen. De basis datatypes en de normale datatypes. Basisgegevenstypen vormen vrijwel alles wat bestaat.
Er zijn bijvoorbeeld alle getallen, char, boolean etc.
De normale gegevenstypen of complexe gegevenstypen zijn al het andere.
Een String is een array van karakters, dus een complex datatype.
Elke variabele die u maakt, is in feite een verwijzing naar de waarde in uw geheugen.
Bijvoorbeeld:
String s = new String("This is just a test");
de variabele “s” bevat GEEN String. Het is een wijzer. Deze aanwijzer wijst naar de variabele in je geheugen.
Wanneer u System.out.println(anyObject)aanroept, wordt de methode toString()van dat object aangeroepen. Als het toStringvan Object niet heeft overschreven, zal het de aanwijzer afdrukken.
Bijvoorbeeld:
public class Foo{
public static void main(String[] args) {
Foo f = new Foo();
System.out.println(f);
}
}
>>>>
>>>>
>>>>Foo@330bedb4
Alles achter de “@” is de aanwijzer. Dit werkt alleen voor complexe gegevenstypen. Primitieve datatypes worden DIRECT opgeslagen in hun aanwijzer. Er is dus eigenlijk geen aanwijzer en de waarden worden direct opgeslagen.
Bijvoorbeeld:
int i = 123;
i slaat in dit geval GEEN aanwijzer op. ik zal de integerwaarde 123 opslaan (in byte ofc).
Ok, laten we terugkomen op de operator ==.
Het vergelijkt altijd de aanwijzer en niet de inhoud die is opgeslagen op de positie van de aanwijzer in het geheugen.
Voorbeeld:
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1 == s2);
>>>>> false
Deze beide String hebben een andere aanwijzer. String.equals(String other) vergelijkt echter de inhoud. U kunt primitieve gegevenstypen vergelijken met de operator ‘==’ omdat de aanwijzer van twee verschillende objecten met dezelfde inhoud gelijk is.
Null zou betekenen dat de aanwijzer leeg is. Een leeg primitief gegevenstype is standaard 0 (voor getallen). Null voor elk complex object betekent echter dat dat object niet bestaat.
Gegroet
Antwoord 18
Ik had dit probleem in Android en ik gebruik deze manier (werk voor mij):
String test = null;
if(test == "null"){
// Do work
}
Maar in Java-code gebruik ik :
String test = null;
if(test == null){
// Do work
}
En:
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);
}
Antwoord 19
Ik gebruik liever:
if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
// do something
}
Lees StringUtils.isBlank() vs String.isEmpty().
Antwoord 20
In Android kun je dit controleren met de hulpprogrammamethode isEmptyvan TextUtils,
public static boolean isEmpty(CharSequence str) {
return str == null || str.length() == 0;
}
isEmpty(CharSequence str)methode controleer beide voorwaarden, voor nullen lengte.
Antwoord 21
Ik gebruik altijd zo:
if (mystr != null && !mystr.isEmpty()){
//DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
//DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}
of u kunt dit naar uw project kopiëren:
private boolean isEmptyOrNull(String mystr){
if (mystr != null && !mystr.isEmpty()){ return true; }
else { return false; }
}
en noem het gewoon als:
boolean b = isEmptyOrNull(yourString);
het geeft true terug als het leeg of null is.b=trueals het leeg of null is
of je kunt try catch en catch gebruiken als het nul is.
Antwoord 22
Ik denk dat myString geen string is maar een array van strings. Dit is wat u moet doen:
String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
//Do something
}
Antwoord 23
Je kunt de tekenreeks die gelijk is aan null als volgt controleren:
String Test = null;
(Test+"").compareTo("null")
Als het resultaat 0 is, dan (Test+””) = “null”.
Antwoord 24
Ik heb de meeste van de hierboven gegeven voorbeelden geprobeerd voor een null in een Android-app die ik aan het bouwen was en HET IS ALLEMAAL FISLUKT. Dus bedacht ik een oplossing die voor mij altijd werkte.
String test = null+"";
If(!test.equals("null"){
//go ahead string is not null
}
Dus voeg eenvoudig een lege string samen zoals ik hierboven deed en test tegen “null” en het werkt prima. In feite wordt er geen uitzondering gegooid
Antwoord 25
Uitzondering kan ook helpen:
try {
//define your myString
}
catch (Exception e) {
//in that case, you may affect "" to myString
myString="";
}
Antwoord 26
Als u in Android werkt, kunt u de eenvoudige TextUtils-klasse gebruiken.
Controleer de volgende code:
if(!TextUtils.isEmpty(myString)){
//do something
}
Dit is eenvoudig gebruik van code. Antwoord kan worden herhaald. Maar het is eenvoudig om een enkele en eenvoudige controle voor u te hebben.
Antwoord 27
Je moet controleren met null if(str != null).