ฉันจะตรวจสอบได้อย่างไรว่าสตริงไม่เป็นโมฆะและไม่ว่างเปล่า?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
ฉันจะตรวจสอบได้อย่างไรว่าสตริงไม่เป็นโมฆะและไม่ว่างเปล่า?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
คำตอบ:
สิ่งที่เกี่ยวกับ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 ) )
isEmpty()
ดูเหมือนจะต้องการอินสแตนซ์ของสตริง (ไม่คงที่) การเรียกใช้สิ่งนี้จากข้อมูลอ้างอิงแบบ null จะทำให้ NullPointerException
TextUtils.isEmpty(String)
เพื่อตรวจสอบว่าสตริงว่างหรือโมฆะ ดีและสั้น คลาส TextUtils เป็นส่วนหนึ่งของ Android SDK
(str != null && str.length() > 0)
ๆ
ฉันชอบใช้ Apache Commons-langสำหรับสิ่งต่าง ๆ เหล่านี้และโดยเฉพาะอย่างยิ่งคลาสยูทิลิตี้StringUtils :
import org.apache.commons.lang.StringUtils;
if (StringUtils.isNotBlank(str)) {
...
}
if (StringUtils.isBlank(str)) {
...
}
isEmpty
หรือisBlank
อาจจะไม่เป็นประโยชน์ที่จะรวมห้องสมุดบุคคลที่สาม คุณสามารถสร้างคลาสยูทิลิตี้ของคุณเองเพื่อให้วิธีการดังกล่าว อย่างไรก็ตามดังที่ Bozho อธิบายว่าcommons-lang
โครงการนี้มีวิธีการที่มีประโยชน์มากมาย!
StringUtils.isNotBlank(str)
จะตรวจสอบโมฆะเช่นกัน
เพียงเพิ่ม Android ในที่นี่:
import android.text.TextUtils;
if (!TextUtils.isEmpty(str)) {
...
}
ในการเพิ่ม @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 เป็นเรื่องแปลก''
)
str != null && str.length() != 0
อีกทางเลือกหนึ่ง
str != null && !str.equals("")
หรือ
str != null && !"".equals(str)
หมายเหตุ: การตรวจสอบครั้งที่สอง (ตัวเลือกแรกและตัวเลือกที่สอง) ถือว่า str ไม่ใช่ค่า null ไม่เป็นไรเพราะการตรวจสอบครั้งแรกทำเช่นนั้น (และ Java ไม่ได้ทำการตรวจสอบครั้งที่สองหากการตรวจสอบครั้งแรกเป็นเท็จ)!
สำคัญ: อย่าใช้ == เพื่อความเท่าเทียมกันของสตริง == ตรวจสอบตัวชี้ว่าเท่ากันไม่ใช่ค่า สองสายสามารถอยู่ในที่อยู่หน่วยความจำที่แตกต่างกัน (สองกรณี) แต่มีค่าเท่ากัน!
เกือบห้องสมุดฉันรู้ว่าทุกกำหนดระดับยูทิลิตี้ที่เรียกว่าStringUtils
, StringUtil
หรือStringHelper
, และพวกเขามักจะมีวิธีการที่คุณกำลังมองหา
รายการโปรดส่วนตัวของฉันคือApache Commons / Langซึ่งในคลาสStringUtilsคุณจะได้รับทั้งคู่
(ครั้งแรกตรวจสอบว่าสตริงเป็นโมฆะหรือว่างเปล่าที่สองตรวจสอบว่ามันเป็นโมฆะว่างเปล่าหรือช่องว่างเท่านั้น)
มีคลาสยูทิลิตี้ที่คล้ายกันใน Spring, Wicket และ libs อื่น ๆ มากมาย หากคุณไม่ใช้ไลบรารีภายนอกคุณอาจต้องการแนะนำคลาส StringUtils ในโครงการของคุณเอง
ปรับปรุง: หลายปีที่ผ่านมาและวันนี้ผมขอแนะนำให้ใช้ฝรั่ง 's Strings.isNullOrEmpty(string)
วิธี
สิ่งนี้ใช้ได้กับฉัน:
import com.google.common.base.Strings;
if (!Strings.isNullOrEmpty(myString)) {
return myString;
}
ผลตอบแทนจริงถ้าสตริงที่กำหนดเป็นโมฆะหรือเป็นสตริงว่าง
พิจารณา normalizing การอ้างอิงสตริงของคุณด้วย nullToEmpty ถ้าคุณทำคุณสามารถใช้ String.isEmpty () แทนวิธีนี้และคุณไม่จำเป็นต้องใช้วิธีการพิเศษที่ปลอดภัยแบบ null เช่น String.toUpperCase หรือหากคุณต้องการทำให้ปกติ "ไปในทิศทางอื่น" การแปลงสตริงว่างเป็นโมฆะคุณสามารถใช้ emptyToNull
เกี่ยวกับ:
if(str!= null && str.length() != 0 )
&&
if str == null ดังนั้นการป้องกัน NullPointerException (ที่มา: ฉันเพิ่งลอง)
ใช้วิธีการของ Apache StringUtils 'isNotBlank เช่น
StringUtils.isNotBlank(str)
มันจะกลับมาจริงถ้า str ไม่เป็นโมฆะและไม่ว่างเปล่า
คุณควรใช้หรือorg.apache.commons.lang3.StringUtils.isNotBlank()
org.apache.commons.lang3.StringUtils.isNotEmpty
การตัดสินใจระหว่างสองสิ่งนี้ขึ้นอยู่กับสิ่งที่คุณต้องการตรวจสอบ
isNotBlank ()ตรวจสอบว่าพารามิเตอร์สำหรับการป้อนคือ:
isNotEmpty ()การตรวจสอบเพียงว่าพารามิเตอร์เข้าเป็น
ส่งคืนจริงหรือเท็จตามอินพุต
Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);
หากคุณไม่ต้องการรวมทั้งห้องสมุด เพียงแค่ใส่รหัสที่คุณต้องการ คุณจะต้องรักษามันด้วยตัวเอง แต่มันเป็นฟังก์ชั่นที่ค่อนข้างตรงไปตรงมา นี่คัดลอกมาจาก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;
}
มันช้าไปหน่อย แต่นี่เป็นรูปแบบการตรวจสอบที่ใช้งานได้:
Optional.ofNullable(str)
.filter(s -> !(s.trim().isEmpty()))
.ifPresent(result -> {
// your query setup goes here
});
มีวิธีการใหม่ใน Java-11: 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);
ทดสอบเท่ากับสตริงว่างและโมฆะในเงื่อนไขเดียวกัน:
if(!"".equals(str) && str != null) {
// do stuff.
}
ไม่โยนNullPointerException
ถ้า STR เป็นโมฆะเนื่องจากผลตอบแทนที่เป็นเท็จถ้าหาเรื่องคือObject.equals()
null
สร้างอื่น ๆจะโยนหวั่นstr.equals("")
NullPointerException
บางคนอาจพิจารณารูปแบบที่ไม่ดีโดยใช้ String ตามตัวอักษรเป็นวัตถุเมื่อซึ่งequals()
ถูกเรียก แต่มันทำงาน
ตรวจสอบคำตอบนี้ด้วย: https://stackoverflow.com/a/531825/1532705
str != null
ดังนั้นทำไมเพิ่มไม่ถึงรหัส !"".equals(str)
ทำงานได้แล้ว
วิธีแก้ปัญหาง่าย ๆ :
private boolean stringNotEmptyOrNull(String st) {
return st != null && !st.isEmpty();
}
ดังที่ 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 **/
}
ฉันขอแนะนำให้คุณอ้างอิงคอลัมน์ในผลลัพธ์ของคุณตามชื่อแทนที่จะเป็นดัชนีซึ่งจะทำให้รหัสของคุณง่ายต่อการบำรุงรักษามากขึ้น
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
}
areSet(String... strings)
จากนั้นจะสามารถเรียกโดยไม่สร้างอาร์เรย์:if(!StringUtils.areSet(firstName, lastName, address))
ในกรณีที่คุณใช้ 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
ด้วยJava 8 ทางเลือกคุณสามารถทำได้:
public Boolean isStringCorrect(String str) {
return Optional.ofNullable(str)
.map(String::trim)
.map(string -> !str.isEmpty())
.orElse(false);
}
ในนิพจน์นี้คุณจะจัดการกับString
s ที่ประกอบด้วยช่องว่างเช่นกัน
คุณสามารถใช้ 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
ฉันจะแนะนำ 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
หากคุณใช้ Spring Boot โค้ดด้านล่างจะทำงาน
StringUtils.hasLength(str)
เพื่อความสมบูรณ์: ถ้าคุณกำลังอยู่แล้วโดยใช้กรอบฤดูใบไม้ผลิที่StringUtilsให้วิธีการ
org.springframework.util.StringUtils.hasLength(String str)
คืนค่า: จริงถ้าสตริงไม่ใช่โมฆะและมีความยาว
เช่นเดียวกับวิธีการ
org.springframework.util.StringUtils.hasText(String str)
คืนค่า: เป็นจริงถ้าสตริงไม่ใช่โมฆะความยาวของมันจะมากกว่า 0 และไม่มีช่องว่างเท่านั้น
เพียงเพื่อละเว้นพื้นที่สีขาวเช่นกัน:
if (str == null || str.trim().length() == 0) {
// str is empty
} else {
// str is not empty
}
หากคุณใช้ Spring Framework จากนั้นคุณสามารถใช้เมธอด:
org.springframework.util.StringUtils.isEmpty(@Nullable Object str);
วิธีนี้ยอมรับวัตถุใด ๆ ที่เป็นข้อโต้แย้งเปรียบเทียบกับ null และสตริงที่ว่างเปล่า เป็นผลให้วิธีการนี้จะไม่กลับจริงสำหรับวัตถุที่ไม่ใช่โมฆะไม่ใช่สตริง
StringUtils
ระบุอย่างชัดเจน "ส่วนใหญ่ใช้ภายในภายในกรอบงานให้พิจารณา Apache's Commons Lang สำหรับชุดโปรแกรมอรรถประโยชน์ของสตริงที่ครอบคลุมมากขึ้น"
วิธีที่ดีกว่าในการจัดการ null ในสตริงคือ
str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()
ในระยะสั้น
str.length()>0 && !str.equalsIgnoreCase("null")
ในการตรวจสอบว่าแอตทริบิวต์สตริงทั้งหมดในวัตถุนั้นว่างเปล่าหรือไม่ (แทนที่จะใช้! = 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
ฉันพบสถานการณ์ที่ต้องตรวจสอบว่า "null" (เป็นสตริง) ต้องถือว่าว่างเปล่า white space และnull ที่แท้จริงต้องส่งคืนจริง ในที่สุดฉันก็ตัดสินตามฟังก์ชั่นต่อไปนี้ ...
public boolean isEmpty(String testString) {
return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}
ในกรณีที่คุณจำเป็นต้องตรวจสอบความถูกต้องของพารามิเตอร์วิธีการของคุณคุณสามารถใช้วิธีการที่เรียบง่าย
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;
}
PreparedStatement
และแทนที่จะสร้างเคียวรี SQL โดยการต่อสายอักขระเข้าด้วยกัน หลีกเลี่ยงทุกชนิดของช่องโหว่ฉีดอ่านได้มากขึ้น ฯลฯ