Java 如何在arraylist中搜索字符串

我想在arraylist中搜索字符串。 我的ArrayList包含：

ArrayList <String> list = new ArrayList(); 
list.add("behold");
list.add("bend");
list.add("bet");
list.add("bear");
list.add("beat");
list.add("become");
list.add("begin");

ArrayList list=new ArrayList（）；
列表。添加（“注意”）；
列表。添加（“弯曲”）；
列表。添加（“下注”）；
列表。添加（“熊”）；
列表。添加（“节拍”）；
列表。添加（“成为”）；
列表。添加（“开始”）；

现在我想搜索

“bea”

，它应该返回一个包含

“bear”

和

“beat”

的列表。

---

如何实现它？

在列表中循环并执行包含或启动操作

ArrayList<String> resList = new ArrayList<String>();
String searchString = "bea";

for (String curVal : list){
  if (curVal.contains(searchString)){
    resList.add(curVal);
  }
}

ArrayList resList=new ArrayList（）；
String searchString=“bea”；
用于（字符串曲线：列表）{
if（曲线包含（搜索字符串））{
resList.add（曲线）；
}
}

---

您可以将其包装在一个方法中。包含检查其是否在列表中。您还可以选择StartWith。

因为您的列表似乎没有排序，所以您必须迭代它的元素。将或应用于每个元素，并将匹配项存储在辅助列表中。完成后返回辅助列表。

更好的方法是对数组的每个字符串元素使用matches（）方法。这将帮助您通过正则表达式搜索任何模式。

List=new ArrayList（）；
ArrayList<String> resList = new ArrayList<String>();
String searchString = "bea";

for (String curVal : list){
  if (curVal.contains(searchString)){
    resList.add(curVal);
  }
}

 List <String> list = new ArrayList();  
           list.add("behold"); 
           list.add("bend"); 
           list.add("bet"); 
           list.add("bear"); 
           list.add("beat"); 
           list.add("become"); 
           list.add("begin");

           List <String> listClone = new ArrayList<String>(); 
           for (String string : list) {
               if(string.matches("(?i)(bea).*")){
                   listClone.add(string);
               }
           }
        System.out.println(listClone);

列表。添加（“注意”）；
列表。添加（“弯曲”）；
列表。添加（“下注”）；
列表。添加（“熊”）；
列表。添加（“节拍”）；
列表。添加（“成为”）；
列表。添加（“开始”）；
List listClone=new ArrayList（）；
用于（字符串：列表）{
if（字符串匹配（“（？i）（bea）。*”）{
添加（字符串）；
}
}
System.out.println（listClone）；

导入java.util.*；
类阵列
{
公共静态void main（字符串参数[]）
{
ArrayList ar=新的ArrayList（）；
ar.add（“普拉克”）；
ar.add（“sangeeta”）；
ar.add（“sumit”）；
System.out.println（“输入名称：”）；
扫描仪扫描=新扫描仪（System.in）；
字符串st=scan.nextLine（）；
用于（字符串lst:ar）
{
如果（st.contains（lst））
{
System.out.println（st+“在这里！”）；
打破
}
其他的
{
System.out.println（“OOps搜索无法找到！”）；
打破
}
}
}
}

我见过的最好的订单：

// SearchList is your List  
// TEXT is your Search Text
// SubList is your result

                    ArrayList<String> TempList = new ArrayList<String>(
                            (SearchList));
                    int temp = 0;
                    int num = 0;
                    ArrayList<String> SubList = new ArrayList<String>();
                    while (temp > -1) {
                        temp = TempList.indexOf(new Object() {
                            @Override
                            public boolean equals(Object obj) {
                                return obj.toString().startsWith(TEXT);
                            }
                        });
                        if (temp > -1) {
                         SubList.add(SearchList.get(temp + num++));
                         TempList.remove(temp);
                        }
                    }

//SearchList是您的列表
//文本是您的搜索文本
//子列表是您的结果
ArrayList TempList=新的ArrayList(
（搜索列表）；
内部温度=0；
int num=0；
ArrayList子列表=新的ArrayList（）；
而（温度>-1）{
temp=templast.indexOf（新对象（）{
@凌驾
公共布尔等于（对象obj）{
返回obj.toString（）.startsWith（文本）；
}
});
如果（温度>-1）{
添加（SearchList.get（temp+num++））；
圣堂武士。移除（临时）；
}
}

使用java.util.HashSet可能更容易。例如：

  List <String> list = new ArrayList<String>(); 
  list.add("behold");
  list.add("bend");
  list.add("bet");

  //Load the list into a hashSet
  Set<String> set = new HashSet<String>(list);
  if (set.contains("bend"))
  {
    System.out.println("String found!");
  }

List List=new ArrayList（）；
列表。添加（“注意”）；
列表。添加（“弯曲”）；
列表。添加（“下注”）；
//将列表加载到哈希集中
Set Set=新哈希集（列表）；
if（设置包含（“折弯”））
{
System.out.println（“找到字符串！”）；
}

如今，Java 8支持一种比公认的解决方案更干净、更快、更简单的单线功能解决方案：

List<String> list = new ArrayList<>();
list.add("behold");
list.add("bend");
list.add("bet");
list.add("bear");
list.add("beat");
list.add("become");
list.add("begin");

List<String> matches = list.stream().filter(it -> it.contains("bea")).collect(Collectors.toList());

System.out.println(matches); // [bear, beat]

---

首先，必须将AdapterArrayList复制到tempsearchnewArrayList（将ListView项添加到tempsearchnewArrayList），因为只有这样才能比较搜索文本是否显示在Arraylist中

创建临时arraylist后，添加以下代码

    searchEditTextBox.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
        }
        @Override
        public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
            String txt = charSequence.toString().trim();
            int txtlength = txt.length();
            if (txtlength > 0) {
                AdapterArrayList = new ArrayList<HashMap<String, String>>();
                for (int j = 0; j< tempsearchnewArrayList.size(); j++) {
                    if (tempsearchnewArrayList.get(j).get("type").toLowerCase().contains(txt)) {
                        AdapterArrayList.add(tempsearchnewArrayList.get(j));
                    }
                }
            } else {
                AdapterArrayList = new ArrayList<HashMap<String, String>>();
                AdapterArrayList.addAll(tempsearchnewArrayList);
            }
            adapter1.notifyDataSetChanged();
            if (AdapterArrayList.size() > 0) {
                mainactivitylistview.setAdapter(adapter1);
            } else {
                mainactivitylistview.setAdapter(null);
            }

        }
        @Override
        public void afterTextChanged(Editable editable) {

        }
    });

searchEditTextBox.addTextChangedListener（新的TextWatcher（）{
@凌驾
更改前的公共无效（CharSequence CharSequence，int i，int i1，int i2）{
}
@凌驾
public void onTextChanged（CharSequence CharSequence，int i，int i1，int i2）{
字符串txt=charSequence.toString（）.trim（）；
int txtlength=txt.length（）；
如果（txtlength>0）{
AdapterArrayList=新的ArrayList（）；
对于（int j=0；j0）{
mainactivitylistview.setAdapter（适配器1）；
}否则{
mainactivitylistview.setAdapter（null）；
}
}
@凌驾
public void PostTextChanged（可编辑）{
}
});

List List=new ArrayList（）；
列表。添加（“注意”）；
列表。添加（“弯曲”）；
列表。添加（“下注”）；
列表。添加（“熊”）；
列表。添加（“节拍”）；
列表。添加（“成为”）；
列表。添加（“开始”）；
List listClone=new ArrayList（）；
Pattern=Pattern.compile（“bea”，Pattern.CASE\u不区分大小写）//如果您不关心大写/小写
用于（字符串：列表）{
if（pattern.matcher（string.find（））{
添加（字符串）；
继续；
}
}
System.out.println（listClone）；

它可以工作，但如果列表中包含Bear，那么它就不匹配了。只需更改正则表达式，假设您希望匹配smal'b'和大写字母'b'，然后relace“（bea）。*”（b | b）（ea）。*”。还有另一种方法可以使上述表达式不区分大小写，使用“（？i）（bea）。*”。您可以使用代替.StartsW

    searchEditTextBox.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
        }
        @Override
        public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
            String txt = charSequence.toString().trim();
            int txtlength = txt.length();
            if (txtlength > 0) {
                AdapterArrayList = new ArrayList<HashMap<String, String>>();
                for (int j = 0; j< tempsearchnewArrayList.size(); j++) {
                    if (tempsearchnewArrayList.get(j).get("type").toLowerCase().contains(txt)) {
                        AdapterArrayList.add(tempsearchnewArrayList.get(j));
                    }
                }
            } else {
                AdapterArrayList = new ArrayList<HashMap<String, String>>();
                AdapterArrayList.addAll(tempsearchnewArrayList);
            }
            adapter1.notifyDataSetChanged();
            if (AdapterArrayList.size() > 0) {
                mainactivitylistview.setAdapter(adapter1);
            } else {
                mainactivitylistview.setAdapter(null);
            }

        }
        @Override
        public void afterTextChanged(Editable editable) {

        }
    });

List <String> list = new ArrayList();  
           list.add("behold"); 
           list.add("bend"); 
           list.add("bet"); 
           list.add("bear"); 
           list.add("beat"); 
           list.add("become"); 
           list.add("begin");

           List <String> listClone = new ArrayList<String>(); 
           Pattern pattern = Pattern.compile("bea",Pattern.CASE_INSENSITIVE); //incase u r not concerned about upper/lower case
           for (String string : list) {
               if(pattern.matcher(string).find()) {
                   listClone.add(string);
                   continue;
               }
           }
        System.out.println(listClone);