ตรวจสอบว่าสตริงไม่เป็นโมฆะและไม่ว่างเปล่า


490

ฉันจะตรวจสอบได้อย่างไรว่าสตริงไม่เป็นโมฆะและไม่ว่างเปล่า?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

8
คุณควรจะใช้PreparedStatementและแทนที่จะสร้างเคียวรี SQL โดยการต่อสายอักขระเข้าด้วยกัน หลีกเลี่ยงทุกชนิดของช่องโหว่ฉีดอ่านได้มากขึ้น ฯลฯ
polygenelubricants

2
คุณสามารถสร้างคลาสที่จะตรวจสอบค่า Null หรือวัตถุ Null ที่จะช่วยคุณปรับปรุงความสามารถในการนำกลับมาใช้ใหม่ .. stackoverflow.com/a/16833309/1490962
Bhushankumar Lilapara

คำตอบ:


895

สิ่งที่เกี่ยวกับisEmpty () ?

if(str != null && !str.isEmpty())

ตรวจสอบให้แน่ใจว่าได้ใช้ส่วนต่าง ๆ ของ&&คำสั่งนี้เนื่องจาก java จะไม่ดำเนินการประเมินส่วนที่สองหากส่วนแรกของความ&&ล้มเหลวดังนั้นให้แน่ใจว่าคุณจะไม่ได้รับข้อยกเว้นตัวชี้ null จากstr.isEmpty()หากstrเป็นโมฆะ

ระวังใช้ได้ตั้งแต่ Java SE 1.6 เท่านั้น คุณต้องตรวจสอบstr.length() == 0เวอร์ชั่นก่อนหน้า


หากต้องการละเว้นพื้นที่ว่างด้วย:

if(str != null && !str.trim().isEmpty())

(เนื่องจาก Java 11 str.trim().isEmpty()สามารถลดลงได้str.isBlank()ซึ่งจะทดสอบพื้นที่สีขาว Unicode อื่น ๆ ด้วย)

ห่อด้วยฟังก์ชั่นที่ใช้งานง่าย:

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

กลายเป็น:

if( !empty( str ) )

80
โปรดทราบว่าisEmpty()ดูเหมือนจะต้องการอินสแตนซ์ของสตริง (ไม่คงที่) การเรียกใช้สิ่งนี้จากข้อมูลอ้างอิงแบบ null จะทำให้ NullPointerException
James P.

38
หรือถ้า (str! = null &&! str.trim (). isEmpty ()) เพื่อละเว้นช่องว่าง
PapaFreud

if ((txt.getText (). length ()) == 0) // รับอิลิเมนต์จาก layout
jruzafa

32
ฉันขอแนะนำให้ใช้TextUtils.isEmpty(String)เพื่อตรวจสอบว่าสตริงว่างหรือโมฆะ ดีและสั้น คลาส TextUtils เป็นส่วนหนึ่งของ Android SDK
George Maisuradze

1
@ user1154390: บางครั้งมันมีค่าอย่างชัดเจนโดยใช้จริงและเท็จเพื่อความชัดเจน แต่เมื่อเงื่อนไขส่งกลับค่าจริงสำหรับจริงและเท็จสำหรับเท็จความซับซ้อนที่ไม่จำเป็นของมัน พูดง่าย(str != null && str.length() > 0)
ToolmakerSteve

213

ใช้org.apache.commons.lang.StringUtils

ฉันชอบใช้ Apache Commons-langสำหรับสิ่งต่าง ๆ เหล่านี้และโดยเฉพาะอย่างยิ่งคลาสยูทิลิตี้StringUtils :

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 

17
ไม่ใช่ Apache คอมมอนส์ - lang overkill ถ้าคุณสามารถใช้ isEmpty ได้หรือไม่ แค่สงสัย.
zengr

17
@zengr - ไม่เพราะแน่นอนที่สุดคุณจะใช้สิ่งอื่นด้วย :)
Bozho

2
@zengr แน่นอนถ้าคุณใช้isEmptyหรือisBlankอาจจะไม่เป็นประโยชน์ที่จะรวมห้องสมุดบุคคลที่สาม คุณสามารถสร้างคลาสยูทิลิตี้ของคุณเองเพื่อให้วิธีการดังกล่าว อย่างไรก็ตามดังที่ Bozho อธิบายว่าcommons-langโครงการนี้มีวิธีการที่มีประโยชน์มากมาย!
Romain Linsolas

13
เพราะStringUtils.isNotBlank(str)จะตรวจสอบโมฆะเช่นกัน
sdesciencelover

1
หากคุณใช้ Spring Framework สิ่งนี้อาจรวมอยู่ในไหของเฟรมเวิร์กแล้ว
linuxunil

103

เพียงเพิ่ม Android ในที่นี่:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

1
@staticx วิธี StringUtils เปลี่ยนเป็น Lang เวอร์ชั่น 2.0 มันไม่ทำให้ CharSequence จดจ้องอีกต่อไป ฟังก์ชั่นนั้นมีอยู่ใน isBlank ()
Nick

50

ในการเพิ่ม @BJorn และ @SeanPatrickFloyd The Guava ให้ทำดังนี้:

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

คอมมอนส์หรั่งสามารถอ่านได้มากขึ้นในบางครั้ง แต่ฉันได้ค่อยๆพึ่งพาฝรั่งมากขึ้นและบางครั้งคอมมอนส์หรั่งก็สับสนเมื่อมันมาถึงisBlank()(ในสิ่งที่เป็นช่องว่างหรือไม่)

คอมมอนส์ Lang เวอร์ชั่นของ Guava isBlankจะเป็น:

Strings.nullToEmpty(str).trim().isEmpty()

ฉันจะบอกว่ารหัสที่ไม่อนุญาต""(ว่าง) และ nullน่าสงสัยและอาจมีข้อผิดพลาดในการที่มันอาจไม่จัดการทุกกรณีที่ไม่อนุญาตให้nullเหมาะสม (แม้ว่าสำหรับ SQL ฉันสามารถเข้าใจเป็น SQL / HQL เป็นเรื่องแปลก'')


ฝรั่งที่สองเช่นกัน ฝรั่งตามแบบแผนของคลาสคงที่พหูพจน์ สำหรับ String ลอง Strings สำหรับวิธีการคงที่เช่น isNullOrEmpty (str)
Thupten

34
str != null && str.length() != 0

อีกทางเลือกหนึ่ง

str != null && !str.equals("")

หรือ

str != null && !"".equals(str)

หมายเหตุ: การตรวจสอบครั้งที่สอง (ตัวเลือกแรกและตัวเลือกที่สอง) ถือว่า str ไม่ใช่ค่า null ไม่เป็นไรเพราะการตรวจสอบครั้งแรกทำเช่นนั้น (และ Java ไม่ได้ทำการตรวจสอบครั้งที่สองหากการตรวจสอบครั้งแรกเป็นเท็จ)!

สำคัญ: อย่าใช้ == เพื่อความเท่าเทียมกันของสตริง == ตรวจสอบตัวชี้ว่าเท่ากันไม่ใช่ค่า สองสายสามารถอยู่ในที่อยู่หน่วยความจำที่แตกต่างกัน (สองกรณี) แต่มีค่าเท่ากัน!


ขอบคุณ ... str.length () ใช้ได้กับฉัน กรณีของฉันคือฉันได้รับค่าจากอาร์เรย์หลังจากสอบถามจากฐานข้อมูล แม้ว่าข้อมูลนั้นจะว่างเปล่า แต่เมื่อฉันได้ความยาวมันก็ให้ความยาว "1" แปลกมาก แต่ขอบคุณที่แสดงสิ่งนี้ให้ฉัน
arn-arn

ที่เกี่ยวข้องกับ internals ของฐานข้อมูล อาจเป็นฟิลด์ถ่านแทนเขตข้อมูล varchar (ดังนั้นจึงมีช่องว่าง) หรือฐานข้อมูลไม่ชอบสตริงว่าง ฉันเดาที่ดีที่สุดคือการประมวลผลค่าเหล่านั้นหลังจาก / ในขณะที่ทำการสอบถาม (ในการเข้าถึงข้อมูลในภายหลังของแอป)
helios

ฉันคิดว่าการตรวจสอบความยาวนั้นดีกว่า 'เท่ากับ' เพราะเป็นการดำเนินการ O (1) เนื่องจากความยาวถูกแคชในกรณีของ String
bluelurker

26

เกือบห้องสมุดฉันรู้ว่าทุกกำหนดระดับยูทิลิตี้ที่เรียกว่าStringUtils, StringUtilหรือStringHelper , และพวกเขามักจะมีวิธีการที่คุณกำลังมองหา

รายการโปรดส่วนตัวของฉันคือApache Commons / Langซึ่งในคลาสStringUtilsคุณจะได้รับทั้งคู่

  1. StringUtils.isEmpty (String)และ
  2. StringUtils.isBlank (String)วิธีการ

(ครั้งแรกตรวจสอบว่าสตริงเป็นโมฆะหรือว่างเปล่าที่สองตรวจสอบว่ามันเป็นโมฆะว่างเปล่าหรือช่องว่างเท่านั้น)

มีคลาสยูทิลิตี้ที่คล้ายกันใน Spring, Wicket และ libs อื่น ๆ มากมาย หากคุณไม่ใช้ไลบรารีภายนอกคุณอาจต้องการแนะนำคลาส StringUtils ในโครงการของคุณเอง


ปรับปรุง: หลายปีที่ผ่านมาและวันนี้ผมขอแนะนำให้ใช้ฝรั่ง 's Strings.isNullOrEmpty(string)วิธี


ฉันอยากจะถามว่าทำไมคุณถึงแนะนำตอนนี้? ฉันต้องการทราบว่ามีความแตกต่างระหว่าง Strings.isNullOrEmpty (string) และ StringUtils.isEmpty (String)
vicangel

@vicangel วิธี Apache Commons เต็มไปด้วยสมมติฐานและสิ่งที่ฉันไม่ได้ถาม ด้วย Guava ฉันได้สิ่งที่ฉันขออย่างแน่นอนและไม่มีอะไรมากไปกว่านี้
ฌอนแพทริคฟลอยด์

24

สิ่งนี้ใช้ได้กับฉัน:

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

ผลตอบแทนจริงถ้าสตริงที่กำหนดเป็นโมฆะหรือเป็นสตริงว่าง

พิจารณา normalizing การอ้างอิงสตริงของคุณด้วย nullToEmpty ถ้าคุณทำคุณสามารถใช้ String.isEmpty () แทนวิธีนี้และคุณไม่จำเป็นต้องใช้วิธีการพิเศษที่ปลอดภัยแบบ null เช่น String.toUpperCase หรือหากคุณต้องการทำให้ปกติ "ไปในทิศทางอื่น" การแปลงสตริงว่างเป็นโมฆะคุณสามารถใช้ emptyToNull


2
<dependency> <groupId> com.google.guava </groupId> <artifactId> ฝรั่ง </artifactId> <version> 12.0 </version> </
dersionency

11

เกี่ยวกับ:

if(str!= null && str.length() != 0 )

โยน NullPointerException ถ้า str เป็น NULL
Mindwin

13
@Mindwin ไม่เป็นความจริงเลย มันจะไม่เรียกใช้งานโค้ดทางด้านขวาของ&&if str == null ดังนั้นการป้องกัน NullPointerException (ที่มา: ฉันเพิ่งลอง)
Zach Lysobey

ฉันยืนแก้ไขแล้ว จะไม่ลบความคิดเห็นออกด้วยความอับอายดังนั้น Zach และ GI Joe จะไม่ถูกทิ้งให้อยู่กับการตอบสนองที่ไม่มีที่ไหนเลย lolz แต่ยินดีที่ได้ทราบว่าการข้ามไปนี้อาจทำให้เกิดความล้มเหลวเชิงตรรกะหากคุณทำอย่างอื่นนอกเหนือจากการทดสอบเนื้อหาและส่งคืนบูลีนบนการเรียกเมธอดที่ข้าม
Mindwin

2
@Mindwin ยินดีที่ได้ทราบว่าภาษาที่คุณใช้นั้นใช้งานได้จริงอย่างไร หากคุณไม่เข้าใจการประเมินการลัดวงจรไม่ควรใช้หรือเรียนรู้ได้ดีกว่า
มาร์ควิสแห่ง Lorne

7

ใช้วิธีการของ Apache StringUtils 'isNotBlank เช่น

StringUtils.isNotBlank(str)

มันจะกลับมาจริงถ้า str ไม่เป็นโมฆะและไม่ว่างเปล่า


ที่จริงถ้า str เป็นโมฆะที่นี่คำสั่งจะคืนค่าจริง
Alexandr

นั่นเป็นความจริง แทนที่จะใช้ StringUtils.isNotEmpty (str) ของ apache-commons แทน
ตัวชี้ Null

6

คุณควรใช้หรือorg.apache.commons.lang3.StringUtils.isNotBlank() org.apache.commons.lang3.StringUtils.isNotEmptyการตัดสินใจระหว่างสองสิ่งนี้ขึ้นอยู่กับสิ่งที่คุณต้องการตรวจสอบ

isNotBlank ()ตรวจสอบว่าพารามิเตอร์สำหรับการป้อนคือ:

  • ไม่เป็นโมฆะ,
  • ไม่ใช่สตริงว่าง ("")
  • ไม่ใช่ลำดับอักขระช่องว่าง ("")

isNotEmpty ()การตรวจสอบเพียงว่าพารามิเตอร์เข้าเป็น

  • ไม่เป็นโมฆะ
  • ไม่ใช่สตริงว่าง ("")


5

หากคุณไม่ต้องการรวมทั้งห้องสมุด เพียงแค่ใส่รหัสที่คุณต้องการ คุณจะต้องรักษามันด้วยตัวเอง แต่มันเป็นฟังก์ชั่นที่ค่อนข้างตรงไปตรงมา นี่คัดลอกมาจากcommons.apache.org

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}

5

มันช้าไปหน่อย แต่นี่เป็นรูปแบบการตรวจสอบที่ใช้งานได้:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

1
ฉันอยากจะแนะนำให้ใช้แผนที่สำหรับการตัดแต่งเช่น: ไม่จำเป็น. (ตัวเลือก) .map (String :: trim). ตัวกรอง (String :: isEmpty) .ifPresent (นี้ :: setStringMethod);
bachph

5

มีวิธีการใหม่ใน : String#isBlank

ผลตอบแทนจริงถ้าสตริงว่างหรือมี codepoint ช่องว่างเท่านั้นมิฉะนั้นเท็จ

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

อาจรวมกับOptionalการตรวจสอบว่าสตริงเป็นโมฆะหรือว่างเปล่า

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

String # ISBLANK


3

ทดสอบเท่ากับสตริงว่างและโมฆะในเงื่อนไขเดียวกัน:

if(!"".equals(str) && str != null) {
    // do stuff.
}

ไม่โยนNullPointerExceptionถ้า STR เป็นโมฆะเนื่องจากผลตอบแทนที่เป็นเท็จถ้าหาเรื่องคือObject.equals()null

สร้างอื่น ๆจะโยนหวั่นstr.equals("") NullPointerExceptionบางคนอาจพิจารณารูปแบบที่ไม่ดีโดยใช้ String ตามตัวอักษรเป็นวัตถุเมื่อซึ่งequals()ถูกเรียก แต่มันทำงาน

ตรวจสอบคำตอบนี้ด้วย: https://stackoverflow.com/a/531825/1532705


1
str != nullดังนั้นทำไมเพิ่มไม่ถึงรหัส !"".equals(str)ทำงานได้แล้ว
amdev


2

ดังที่ seanizer กล่าวไว้ข้างต้น Apache StringUtils ยอดเยี่ยมสำหรับเรื่องนี้หากคุณรวมฝรั่งคุณควรทำดังต่อไปนี้

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

ฉันขอแนะนำให้คุณอ้างอิงคอลัมน์ในผลลัพธ์ของคุณตามชื่อแทนที่จะเป็นดัชนีซึ่งจะทำให้รหัสของคุณง่ายต่อการบำรุงรักษามากขึ้น


ไม่จำเป็นต้องใช้ apache คอมมอนส์จากฝรั่งแม้ว่าจะมีคลาส Strings ในฝรั่งด้วยเช่นกัน: guava
Sean Patrick Floyd

ฉันเพิ่มตัวอย่างฝรั่งสำหรับผู้ใช้มือใหม่ Java ที่ที่ดินในคำถามนี้: stackoverflow.com/a/13146903/318174
Adam Gent

2

if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty)ผมได้ทำฟังก์ชั่นยูทิลิตี้ของตัวเองในการตรวจสอบหลายสายในครั้งเดียวแทนที่จะต้องถ้างบเต็มรูปแบบของ นี่คือฟังก์ชั่น:

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

ดังนั้นฉันสามารถเขียน:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

2
จะดีกว่าที่จะใช้ลายเซ็น: areSet(String... strings)จากนั้นจะสามารถเรียกโดยไม่สร้างอาร์เรย์:if(!StringUtils.areSet(firstName, lastName, address))
เวสตัน

2

ในกรณีที่คุณใช้ Java 8 และต้องการมีวิธีการเขียนโปรแกรมที่ใช้งานได้มากขึ้นคุณสามารถกำหนดคำสั่งFunctionที่จัดการการควบคุมจากนั้นคุณสามารถนำมาใช้ซ้ำได้apply()ทุกเมื่อที่ต้องการ

มาฝึกคุณสามารถกำหนดFunctionเป็น

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

จากนั้นคุณสามารถใช้งานได้โดยเพียงเรียกapply()วิธีดังต่อไปนี้:

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

ถ้าคุณต้องการคุณสามารถกำหนดFunctionว่าการตรวจสอบถ้าเป็นที่ว่างเปล่าแล้วลบล้างมันด้วยString!

ในกรณีนี้Functionจะมีลักษณะดังนี้:

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

จากนั้นคุณสามารถใช้งานได้โดยเพียงเรียกapply()วิธีดังต่อไปนี้:

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true

นี่คือวิธีที่ฉันชอบเมื่อฉันกังวลเกี่ยวกับต้นทุนหรือผลข้างเคียงและไม่มีการนำเข้าพร้อมส่ง
david.pfx

2

ด้วยJava 8 ทางเลือกคุณสามารถทำได้:

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

ในนิพจน์นี้คุณจะจัดการกับStrings ที่ประกอบด้วยช่องว่างเช่นกัน


1

คุณสามารถใช้ StringUtils.isEmpty () มันจะส่งผลจริงถ้าสตริงเป็นโมฆะหรือว่างเปล่า

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

จะส่งผลให้

str1 เป็นค่าว่างหรือว่างเปล่า

STR2 เป็นโมฆะหรือว่างเปล่า


หรือเพียงใช้isNotBlank
Brian

1

ฉันจะแนะนำ Guava หรือ Apache Commons ตามความต้องการที่แท้จริงของคุณ ตรวจสอบพฤติกรรมที่แตกต่างในรหัสตัวอย่างของฉัน:

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

ผลลัพธ์:
Apache:
a ว่างเปล่า
b ว่างเปล่า
c ว่างเปล่า
Google:
b คือ NullOrEmpty
c คือ NullOrEmpty



0

เพื่อความสมบูรณ์: ถ้าคุณกำลังอยู่แล้วโดยใช้กรอบฤดูใบไม้ผลิที่StringUtilsให้วิธีการ

org.springframework.util.StringUtils.hasLength(String str)

คืนค่า: จริงถ้าสตริงไม่ใช่โมฆะและมีความยาว

เช่นเดียวกับวิธีการ

org.springframework.util.StringUtils.hasText(String str)

คืนค่า: เป็นจริงถ้าสตริงไม่ใช่โมฆะความยาวของมันจะมากกว่า 0 และไม่มีช่องว่างเท่านั้น


เราสามารถใช้วิธีการ StringUtils.isEmpty (param)
Supun Dharmarathne

0

เพียงเพื่อละเว้นพื้นที่สีขาวเช่นกัน:

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}

0

หากคุณใช้ Spring Framework จากนั้นคุณสามารถใช้เมธอด:

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

วิธีนี้ยอมรับวัตถุใด ๆ ที่เป็นข้อโต้แย้งเปรียบเทียบกับ null และสตริงที่ว่างเปล่า เป็นผลให้วิธีการนี้จะไม่กลับจริงสำหรับวัตถุที่ไม่ใช่โมฆะไม่ใช่สตริง


1
โปรดทราบว่าเอกสารประกอบสำหรับการStringUtilsระบุอย่างชัดเจน "ส่วนใหญ่ใช้ภายในภายในกรอบงานให้พิจารณา Apache's Commons Lang สำหรับชุดโปรแกรมอรรถประโยชน์ของสตริงที่ครอบคลุมมากขึ้น"
Fredrik Jonsén

0

วิธีที่ดีกว่าในการจัดการ null ในสตริงคือ

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

ในระยะสั้น

str.length()>0 && !str.equalsIgnoreCase("null")

0

ในการตรวจสอบว่าแอตทริบิวต์สตริงทั้งหมดในวัตถุนั้นว่างเปล่าหรือไม่ (แทนที่จะใช้! = null ในชื่อเขตข้อมูลทั้งหมดต่อไปนี้วิธี Java reflection api

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

เมธอดนี้จะส่งคืนค่าจริงหากค่าฟิลด์สตริงทั้งหมดว่างเปล่าซึ่งจะส่งคืนค่าเท็จหากมีค่าใดค่าหนึ่งอยู่ในแอตทริบิวต์ String


0

ฉันพบสถานการณ์ที่ต้องตรวจสอบว่า "null" (เป็นสตริง) ต้องถือว่าว่างเปล่า white space และnull ที่แท้จริงต้องส่งคืนจริง ในที่สุดฉันก็ตัดสินตามฟังก์ชั่นต่อไปนี้ ...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

0

ในกรณีที่คุณจำเป็นต้องตรวจสอบความถูกต้องของพารามิเตอร์วิธีการของคุณคุณสามารถใช้วิธีการที่เรียบง่าย

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

ตัวอย่าง:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.