Java 搜索对象数组列表混乱

我编写了一个在arralist中搜索对象的方法，但是我需要这个搜索来获取两个参数，并将它们与对象的描述进行比较。让我困惑的是，我不知道如何使我的方法采用两个参数，而这两个参数与一个描述进行比较。 e、 g对象描述：蓝色野马

现在搜索方法必须有两个参数，一个是“蓝色”，一个是“野马”，我不知道怎么做。我找到了一种方法，只需将完整的描述作为一个参数来编写，就可以完美地工作。我离开了我试图改变的方法，寻找两个参数，以及一个参数的方法，并且工作良好。值得一提的是，该方法还需要寻找未租借的汽车，这就是为什么还需要与租赁日期进行比较，因为如果汽车是租借的，将有一辆，如果不是，则不会

尝试将其更改为查找两个参数：

public Car searchCar(String description, String description2)
{
    for (Car car : cars) {
        if (car.getDescription().equals(description) && car.getDescription().equals(description2) && car.getHireDate().equals("")) {

            System.out.println( ": " + car.getDescription() + " rate: £" + car.getDailyRate() + " Down payment: £"+ car.getDownPayment());
            return car;

        }
        else if (car.getHireDate() != ("")) {
            System.out.println("This car is rented!!");
        }
        else {

        }
    }
    return null;
}

这是一个只接受一个参数且工作正常的参数：

public Car searchCar(String description)
{
    for (Car car : cars) {
        if (car.getDescription().equals(description) && car.getHireDate().equals("")) {

            System.out.println( ": " + car.getDescription() + " rate: £" + car.getDailyRate() + " Down payment: £"+ car.getDownPayment());
            return car;

        }
        else if (car.getHireDate() != ("")) {
            System.out.println("This car is rented!!");
        }
        else {

        }
    }
    return null;
}

---

描述不太可能完全等于这两个参数。也许你只是想匹配描述的一部分

像这样的事情可能会引起兴趣

还要注意这一行：

else if (car.getHireDate() != ("")) {

---

不会像你期望的那样工作；您可以正确比较上一条语句中的字符串（使用

equals

），但在此处无法进行比较。

首先，您应该定义是否需要精确匹配，或者是否应该包含参数，并且说明中可能有其他文本

精确匹配

对于精确匹配，可以使用或条件：

if ( (car.getDescription().equals(description) | car.getDescription().equals(description2) ) && car.getHireDate().equals("") ) {
   ... 
}

这意味着，如果描述与

description

或

description2

完全匹配，您将获得成功

或者，如果您知道顺序，您也可以连接参数：

if ( car.getDescription().equals(description + " " + description2) && car.getHireDate().equals("") ) {
   ... 
}

这将匹配“蓝色野马”，但不匹配“蓝色野马”

或者，您可以将连接的字符串设置为正则表达式，以允许任意空白：

if ( car.getDescription().matches("\\s*\\b" + description + "\\b\\s*\\b" + description2 + "\\b\\s*") && car.getHireDate().equals("") ) {
   ... 
}

由于单词边界要求（

“\\b”

），这将与“蓝色野马”等匹配，但与“蓝色野马”不匹配

请注意，还有更多的可能性，因此您应该首先定义要如何匹配

包含的参数

如果要获取包含这两个参数的所有描述，请改用

contains（…）

：

if ( car.getDescription().contains(description) && car.getDescription().contains(description2) && car.getHireDate().equals("") ) {
   ... 
}

---

请注意，这也将与“蓝色福特野马”匹配（“蓝色”和“野马”是参数）。

为了测试子字符串的出现情况，您可以使用：

---

您可能还希望使比较不区分大小写。

说明需要与说明2相同 你可以做：

String fulldescription=description+" "+description2;

然后

if (car.getDescription().equals(fulldescription)...

可以采用不同的方法

 if (car.getDescription().indexOf(description)>0 && car.getDescription().indexOf(description2)>0 )...

---

我建议使用

contains

和

toLowerCase

进行字符串搜索。还可以考虑一个<强>变量变量搜索< /强>方法：

public Car searchCar(String...descriptions) {
    for (Car car : cars) {
        if (car.getHireDate().equals("")) {
            for (String d : descriptions) {
               // assuming car.getDescription() != null
               if (car.getDescription().toLowerCase().contains(d.toLowerCase())) {
                  System.out.println( ": " + car.getDescription() + " rate: £" + car.getDailyRate() + " Down payment: £"+ car.getDownPayment());
                  return car;
               }
            }
        }
        else
            System.out.println("This car is rented!!");
    }
    return null;
}

然后您可以调用此方法，如下所示：

Car c1 = searchCar("blue");

或

或

---

考虑将您的搜索/匹配封装在一个类中，您可以对该类进行扩充，以包含您需要的任何搜索条件

下面是一个满足您当前需求的示例

 class CarSearch {

    private boolean isIncludeHired;
    private String[] descriptionWords;
    private boolean isCaseInsensitive;

    public void setIncludeHired(boolean b) {
        isIncludeHired = b;
    }

    public void setCaseInsensitive(boolean b) {
        this.isCaseInsensitive = b;
    }

    public void setDescriptionWords(String[] words) {
        this.descriptionWords = words;
    }

    public boolean matches(Car car) {

        boolean matches = true;

        if (!isIncludeHired) {
            if (car.getHireDate() != null) {
                matches = false;
            }
        }

        if (matches && descriptionWords != null) {
            String description = car.getDescription();
            if (isCaseInsensitive) {
                description = description.toLowerCase();
            }
            boolean allMatch = true;
            for (String word: descriptionWords) {
                if (isCaseInsensitive) {
                    word = word.toLowerCase();
                }
                if (!description.contains(word)) {
                    allMatch = false;
                    break;
                }
            }
            matches = allMatch;
        }

        return matches;
    }

    public List<Car> search(List<Car> cars) {
        List<Car> matched = new ArrayList<Car>();

        for (Car car: cars) {
            if (matches(car)) {
                matched.add(car);
            }
        }
        return matched;
    }
}

类搜索{
私有布尔值包括：；
私有字符串[]描述词；
私有布尔不敏感；
公共void集合includehired（布尔b）{
i包括=b；
}
public void setCaseSensitive（布尔b）{
this.iscase=b；
}
public void setDescriptionWords（字符串[]个字）{
this.descriptionWords=单词；
}
公共布尔匹配（汽车）{
布尔匹配=真；
如果（！包括已雇用）{
if（car.getHireDate（）！=null）{
匹配=假；
}
}
if（匹配&&descriptionWords！=null）{
字符串description=car.getDescription（）；
如果（不敏感）{
description=description.toLowerCase（）；
}
布尔allMatch=true；
for（字符串字：描述字）{
如果（不敏感）{
word=word.toLowerCase（）；
}
如果（！description.contains（word））{
allMatch=false；
打破
}
}
匹配=所有匹配；
}
返回比赛；
}
公共列表搜索（列出车辆）{
列表匹配=新的ArrayList（）；
用于（汽车：汽车）{
如果（匹配（汽车））{
匹配。添加（汽车）；
}
}
返回匹配；
}
}

现在你可以这样做：

    CarSearch search = new CarSearch();
    search.setCaseInsensitive(true);
    search.setIncludeHired(false);
    search.setDescriptionWords(new String[]{"blue", "mustang"});

    List<Car> matches = search.search(cars);

CarSearch search=newcarsearch（）；
search.setCaseSensitive（true）；
search.setIncludeHired（false）；
search.setDescriptionWords（新字符串[]{“蓝色”、“野马”}）；
列表匹配项=搜索。搜索（汽车）；

您还可以轻松更改

CarSearch

类以允许其他内容，例如精确匹配、按租用日期搜索、按注册搜索等。

您想要精确匹配还是所有包含参数的对象？

Car c1 = searchCar("blue", "red", "toyota", "mustang", "honda");

 class CarSearch {

    private boolean isIncludeHired;
    private String[] descriptionWords;
    private boolean isCaseInsensitive;

    public void setIncludeHired(boolean b) {
        isIncludeHired = b;
    }

    public void setCaseInsensitive(boolean b) {
        this.isCaseInsensitive = b;
    }

    public void setDescriptionWords(String[] words) {
        this.descriptionWords = words;
    }

    public boolean matches(Car car) {

        boolean matches = true;

        if (!isIncludeHired) {
            if (car.getHireDate() != null) {
                matches = false;
            }
        }

        if (matches && descriptionWords != null) {
            String description = car.getDescription();
            if (isCaseInsensitive) {
                description = description.toLowerCase();
            }
            boolean allMatch = true;
            for (String word: descriptionWords) {
                if (isCaseInsensitive) {
                    word = word.toLowerCase();
                }
                if (!description.contains(word)) {
                    allMatch = false;
                    break;
                }
            }
            matches = allMatch;
        }

        return matches;
    }

    public List<Car> search(List<Car> cars) {
        List<Car> matched = new ArrayList<Car>();

        for (Car car: cars) {
            if (matches(car)) {
                matched.add(car);
            }
        }
        return matched;
    }
}

    CarSearch search = new CarSearch();
    search.setCaseInsensitive(true);
    search.setIncludeHired(false);
    search.setDescriptionWords(new String[]{"blue", "mustang"});

    List<Car> matches = search.search(cars);