How to use generics to simplify my Search Method?

In my program, I am trying to create a method that will Search through an ArrayList of BaseContact. BaseContact is an abstract class that is extended within a PersonContact and BusinessContact Classes. I want to create a Search method that asks the user what property they want to search by (Name, address, ID number etc.) and then what they want to search (ex. "John", "123 Oak", 2). Currently, my code is using a Scanner and switch case to ask the user what they want to search by and then runs a for loop to check if their input is equal to any of the contacts with that property. I was wondering if there is any way to utilize Generics or something else to make the code less repetitive.

public void search() {
Boolean active = true;
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
// While Statement for Search
while (active) {
System.out.println("--- Search ---");
System.out.println(
"\n1. Id\n2. Name\n3. Phone Number\n4. Date of Birth\n5. Hobby\n6. Website URL\n7. Street\n8. City\n9. State\n10. Zip Code");
String choice = sc.nextLine();
// Switch statement
switch (choice) {
case "1":
case "Id":
System.out.println("What is the Id number?");
int id = sc.nextInt();
sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getId() == id) {
System.out.println("Contact with the Id of " + id);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "2":
case "Name":
System.out.println("What is the Name?");
String name = sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getName().equals(name)) {
System.out.println("Contact with the Name of " + name);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "3":
case "Phone Number":
System.out.println("What is the Phone Number?");
String phoneNum = sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getPhoneNum().equals(phoneNum)) {
System.out.println("Contact with the Phone Number of " + phoneNum);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "4":
case "Date of Birth":
System.out.println("What is the Date of Birth? (Month Day, Year)");
String dob = sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getType() == "personContact") {
PersonContact temp = (PersonContact) contact;
if (dob.equals(temp.getDob())) {
System.out.println("Contact with the Date of Birth of " + dob);
System.out.println("Contact- " + contact.toString() + ":\n");
}
}
}
break;
case "5":
case "Hobby":
System.out.println("What is the Hobby?");
String hobby = sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getType() == "personContact") {
PersonContact temp = (PersonContact) contact;
if (hobby.equals(temp.getHobby())) {
System.out.println("Contact with the Hobby of " + hobby);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
}
break;
case "6":
case "Website URL":
System.out.println("What is the Website URL?");
String url = sc.nextLine();
for (BaseContact contact : contacts) {
if (contact.getType() == "businessContact") {
BusinessContact temp = (BusinessContact) contact;
if (url.equals(temp.getWebsite())) {
System.out.println("Contact with the Website URL of " + url);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
}
break;
case "7":
case "Street":
System.out.println("What is the Street?");
String street = sc.nextLine();
for (BaseContact contact : contacts) {
if (street.equals(contact.getLocation().getStreet())) {
System.out.println("Contact with the Street of " + street);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "8":
case "City":
System.out.println("What is the City?");
String city = sc.nextLine();
for (BaseContact contact : contacts) {
if (city.equals(contact.getLocation().getCity())) {
System.out.println("Contact with the City of " + city);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "9":
case "State":
System.out.println("What is the State?");
String state = sc.nextLine();
for (BaseContact contact : contacts) {
if (state.equals(contact.getLocation().getState())) {
System.out.println("Contact with the State of " + state);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
case "10":
case "Zip Code":
System.out.println("What is the Zip Code?");
String zip = sc.nextLine();
for (BaseContact contact : contacts) {
if (zip.equals(contact.getLocation().getZipCode())) {
System.out.println("Contact with the Zip Code of " + zip);
System.out.println("Contact- " + contact.toString() + "\n");
}
}
break;
// case "5":
case "Exit":
System.out.println("--- EXIT Search ---");
active = false;
break;
default:
boolean exit = true;
while (exit) {
System.out.println("INVALID INPUT\nWould you like to Exit? Y/N");
String Cexit = sc.nextLine();
if (Cexit.equalsIgnoreCase("Y")) {
System.out.println("--- EXIT ---");
exit = false;
active = false;
}
if (Cexit.equalsIgnoreCase("N")) {
exit = false;
}
}
break;
} // End Switch Statement
} // End while loop
}

So, if your user has to add almost every piece of information of a contact
why don't you scan everything and then create a QueryContact that extends a BaseContact?

If you implement the equals() method you could use the contains() method of the Arraylist.

In anycase you could use streams and do something like this:

contacts.stream()
.filter(con-> con.getAddress().equals(queryContact.getAddress())
.filter(con-> con.getName().equals(queryContact.getName())
...//etc
.collect(Collectors.toList());

It can get of course tricky if you need to implement a 'like' search.

By looking at the code I came up with a refactor that might help you.

Since in every case of the switch statement you are repeating the structure. I would recommend extracting that chunk of code and converting it into a method.

    private void dataQuery(String requestMessage, String logMessage, Function<BaseContact, String> expressionProvider) {
     System.out.println(requestMessage);
     String input = sc.nextLine();
     for (BaseContact contact : contacts) {
       if (input.equals(expressionProvider.apply(contact))) {
         System.out.println(logMessage + zip);
         System.out.println("Contact" + contact.toString() + "\n");
      }
    }
  }

I hope you can visualize the same structure that you were using in each case.

The parameter called expressionProvider is a Function that follows the principle of functions (making a transformation). This function will receive a BaseContact and then returning a String. In the middle, you can work with that contact as your desired.

Here are some calls of the method dataQuery:

        case "6":
        case "Website URL":
          dataQuery("What is the Website URL?", "Contact with the Website URL of ",
              baseContact -> {
                if (baseContact.getType().equals("buisnessContact")) {
                  return ((BusinessContact) baseContact).getWebsite();
                }
                return null;//can return null without throwing a NPE(Null pointer exception)
              });
          break;

        case "7":
        case "Street":
          dataQuery("What is the Street?", "Contact with the Street of ",
              baseContact -> baseContact.getLocation().getStreet());
          break;

        case "8":
        case "City":
          dataQuery("What is the City?", "Contact with the City of ",
              (baseContact -> baseContact.getLocation().getCity()));
          break;

        case "9":
        case "State":
          dataQuery("What is the State?", "Contact with the State of ",
              (baseContact -> baseContact.getLocation().getState()));
          break;

Note: In order to use this implementation, you should declare the list of contacts as a global variable, as well as the scanner. If you can not do that, then you have to pass them via parameters of the method.

UPDATE:
It is also possible to improve a little bit that switch case statement by creating an enum like this:

  public enum Option {
    NONE("", ""),
    ID("Id", "1"),
    NAME("Name", "2"),
    STREET("Street", "3"),
    CITY("City", "4");// you can keep adding options here!

    String firstIdentifier;
    String secondIdentifier;

    Option(String firstIdentifier, String secondIdentifier) {
      this.firstIdentifier = firstIdentifier;
      this.secondIdentifier = secondIdentifier;
    }

    public static Option getOptionByIdentifier(String identifier) {
      return Arrays.stream(Option.values())
          .filter(option -> option.secondIdentifier.equals(identifier) || option.firstIdentifier
              .equals(identifier))
          .findAny()
          .orElse(NONE);
    }
  }

Then the switch statement will look something like:

    Option option = Option.getOptionByIdentifier(choice);
    switch (option) {
      case ID:
        //your code when ID is selected
        break;
      case NAME:
        //your code when NAME is selected
        break;
      case STREET:
        //your code when STREET is selected
        break;
      case NONE:
        //default case, basically when the input is trash
        break;
    }

Personally, I think it just looks cleaner using enums. Also, for your specific case, double case calls are avoided