Java - Check for empty String without if statement

More efficient? No.

More readable? Yep–efficiency of a different sort.

Create something like an isValid() method for each field, or field type. These will contain simple validations like blank checks, regexes, etc., and occasionally other domain-specific logic.

There are a ton of ways to break up and/or abstract this functionality, most roughly equivalent to:

private void addPersonButtonActionPerformed(java.awt.event.ActionEvent evt) {
    String firstName = firstNameTextField.getText();
    String lastName = lastNameTextField.getText();
    String emailAddress = emailTextField.getText();

    if (   isNameValid(firstName, "First name")
        && isNameValid(lastName, "Last name")
        && isEmailValid(emailAddress, "Email address")) {
        personArrayList.add(new Person(firstName, lastName, emailAddress));
        System.out.println("Person added!");
    }
}

The idea is to keep the mainline code clean and concise, in a way that fits with your personal style, the libraries you're using, etc. In addition to rolling your own, there are existing libraries to wrap this up.

If you have many "forms" like this it might make sense to abstract the form itself, and its validation; if it's just the one, there might not be a compelling reason to take it any further than something resembling the above.

Just a little change that might help:

private void addPersonButtonActionPerformed(java.awt.event.ActionEvent evt) {
    String firstName = firstNameTextField.getText();
    String lastName = lastNameTextField.getText();
    String emailAddress = emailTextField.getText();
    boolean valid = true;

    if (firstName.equals("")) {
        System.out.println("First Name is missing");
        valid = false;
    }  
    if (lastName.equals("")) {
        System.out.println("Last Name is missing");
        valid = false;
    } 
    if (emailAddress.equals("")) {
        System.out.println("E-Mail address is missing");
        valid = false;
    } 
    if (!Email.isValid(emailAddress)) {
        System.out.println("E-Mail address is invalid");
        valid = false;
    } 
    if(valid) {
        personArrayList.add(new Person(firstName, lastName, emailAddress));
        System.out.println("Person added!");
    }
}

You could create a class called Validations (or such), which internally has a List of error messages. Each Validations method does a check and returns the same Validations object, for easy chaining. The last method returns the List. Something like:

public class Validations {
    private List<String> errors = new ArrayList<String>();

    Validations notEmpty(String fieldDescription, String value) {
        if (value.length() == 0)
            errors.add(fieldDescription + " can't be empty");
        return this;
    }

    List<String> errors() {
        return errors;
    }
}

And then in usage:

List<String> errors = new Validations()
    .notEmpty("first name", firstNameTextField.value())
    .notEmpty("last name", lastNameTextField.value())
    .errors();
if (!errors.isEmpty()) {
    System.out.println(errors);
}

This approach lets you handle multiple errors pretty easily.

As @Dave Newton noted: it's only for readability reasons. Performance is not affected.

Make an utility method:

private boolean checkNotEmpty(String value, String messageIfEmpty) {
   if (value.equals(""))
      System.out.println(messageIfEmpty);
}

so you can write this:

checkNotEmpty(firstNameTextField.getText(), "First name is missing");
checkNotEmpty(lastNameTextField.getText(), "Last name is missing");

and so on...

Even you can write some other methods à la JUnit like:

checkTrue(boolean value, String messageIfNotTrue) {...}

so you can write weird conditions like:

checkTrue(textbox.getValue().length() % 2 == 0, "The number of chars is not even!!")

Create a couple of sub-classes that extend InputVerifier that implement basic verification rules, and attach the to your text fields. A second constructor of the verifier can take the warning text and you're ready to go.

You can also create a composite verifier, that has several instances of your rules and requires for all of them to be true for the field to pass. e.g. combine something like not-empty and only-alpha-numerics. In this case, the composite constructor can take the warning text, and initialize the sub rules' text when they're added.

Completely agree with Binyamin Sharet and Dave.

If you want to reduce the no of "if" statements in your code , you can use ternary operator instead.

    String firstName= "";
    String b;
    b = firstName.equals("") ? "First Name is missing" : "Present" ;
    System.out.println(b);

That will increase the readability of your code if you want.

I like many of the answers. Please allow me to throw my tidbit in.

I like to use the strategy pattern with a default case.

You can default your implementation to look for empty strings and whatever else you may fancy.

You could call it "MyStringUtils". You can pass it objects that extend the behavior that way you could use "MyStringUtils" in other places.

I'd take the code snips from above and embed them in this code util.

Happy coding mate.

public String validate(JTextField... fields) {
    StringBuilder builder = new StringBuilder();
    for (JTextField s : fields) {
        if (s.getText() == null || "".equals(s.getText())) {
            builder.append(s.getName() + " is missing\n");
        }
    }
    return builder.toString();
}


private void addPersonButtonActionPerformed(java.awt.event.ActionEvent evt) {
    String message = validate(firstNameTextField,lastNameTextField,emailTextField);
    if(message.isEmpty()) // addperson...
    else // print message .. 
}

You can try use isEmpty

private void addPersonButtonActionPerformed(java.awt.event.ActionEvent evt) {
String firstName = firstNameTextField.getText();
String lastName = lastNameTextField.getText();
String emailAddress = emailTextField.getText();

if (firstName.isEmpty()) {
    System.out.println("First Name is missing");
} else if (lastName.equals()) {
    System.out.println("Last Name is missing");
} else if (emailAddress.isEmpty("")) {
    System.out.println("E-Mail address is missing");
} else if (!Email.isValid(emailAddress)) {
    System.out.println("E-Mail address is invalid");
} else {
    personArrayList.add(new Person(firstName, lastName, emailAddress));
    System.out.println("Person added!");
}
}