I want to search for a string in an arraylist.
My ArrayList contains:
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");
Now I want to search for "bea" and it should return a list containing "bear" and "beat".
How can I implement it?
PEHLAJ
9,9309 gold badges40 silver badges52 bronze badges
asked Nov 19, 2011 at 7:39
0
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);
answered Nov 19, 2011 at 8:41
AbhishekAbhishek
5753 silver badges5 bronze badges
3
Loop through your list and do a contains or startswith.
ArrayList<String> resList = new ArrayList<String>();
String searchString = "bea";
for (String curVal : list){
if (curVal.contains(searchString)){
resList.add(curVal);
}
}
You can wrap that in a method. The contains checks if its in the list. You could also go for startswith.
answered Nov 19, 2011 at 7:42
Udo HeldUdo Held
12.3k11 gold badges67 silver badges93 bronze badges
1
Nowadays, Java 8 allows for a one-line functional solution that is cleaner, faster, and a whole lot simpler than the accepted solution:
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]
And even easier in Kotlin:
val matches = list.filter { it.contains("bea") }
answered Aug 26, 2016 at 0:13
sebnukemsebnukem
8,0535 gold badges38 silver badges48 bronze badges
2
May be easier using a java.util.HashSet. For example:
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!");
}
answered Jul 10, 2015 at 21:07
MarquezMarquez
5,8413 gold badges30 silver badges40 bronze badges
Since your list doesn’t appear to be sorted, you have to iterate over its elements. Apply startsWith() or contains() to each element, and store matches in an auxiliary list. Return the auxiliary list when done.
answered Nov 19, 2011 at 7:43
NPENPE
483k108 gold badges943 silver badges1008 bronze badges
Better way is to use matches() method on every String element of the array. This will help you to search any pattern through regular expressions.
answered Nov 19, 2011 at 7:52
DronaDrona
6,7981 gold badge28 silver badges35 bronze badges
The Best Order I’ve seen :
// 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);
}
}
answered Jul 23, 2014 at 6:31
1
First you have to copy, from AdapterArrayList to tempsearchnewArrayList ( Add ListView items into tempsearchnewArrayList ) , because then only you can compare whether search text is appears in Arraylist or not.
After creating temporary arraylist, add below code.
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) {
}
});
answered Dec 16, 2016 at 12:41
Mani kandanMani kandan
3594 silver badges12 bronze badges
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);
answered Mar 16, 2017 at 13:56
RishabhRishabh
1,8271 gold badge12 silver badges9 bronze badges
2
TRY using Google guava library
FOR MORE INFO –> https://github.com/google/guava
Iterable<String> result = Iterables.filter(yourListContainStringsYouWantToSearch, Predicates.containsPattern(search));
Log.i("resultsInList", "performSearch:n"+ Lists.newArrayList(result.iterator()));
answered Oct 19, 2021 at 22:57
import java.util.*;
class ArrayLst
{
public static void main(String args[])
{
ArrayList<String> ar = new ArrayList<String>();
ar.add("pulak");
ar.add("sangeeta");
ar.add("sumit");
System.out.println("Enter the name:");
Scanner scan=new Scanner(System.in);
String st=scan.nextLine();
for(String lst: ar)
{
if(st.contains(lst))
{
System.out.println(st+"is here!");
break;
}
else
{
System.out.println("OOps search can't find!");
break;
}
}
}
}
answered May 12, 2014 at 8:38
PulakPulak
11 bronze badge
У меня есть массив строк, содержащий п количество элементов, желаемых пользователем.
Предположим, если есть 3 элемента String:
Hey,
Hello there,
Hell no
И я хочу найти слово Hell.
Программа должна выдавать только третье предложение, а не второе, так как hello содержит слово hell.
Другой пример – элементы:
10
50
110
Если я ищу 10, вывод должен быть первым предложением, а не третьим (поскольку 110 содержит 10).
Я создал массив линейного поиска для строки, но я не понимаю, как реализовать его в словах в предложениях.
Помощь будет оценена. Спасибо.
3 ответа
Лучший ответ
equals лучше подходит для ваших требований:
String strArray[] = { "Hey", "Hello there", "Hell no" };
String inputStr = "Hell";
for (int i = 0; i < strArray.length; i++) {
String[] contents = strArray[i].split(" ");
for (int j = 0; j < contents.length; j++) {
if (inputStr.equals(contents[j])) {
System.out.println(strArray[i]);
}
}
}
Здесь мы перебираем исходный массив, разбиваем каждое слово и затем циклически повторяем полученный массив, чтобы проверить, есть ли совпадение.
1
Nicholas K
17 Мар 2019 в 13:23
Попробуй это. Ключ должен использовать границу слова ( b) в регулярном выражении Java:
System.out.println(Arrays.stream("Hey, Hello there,Hell no".split(","))
.filter(s -> s.matches(".*\bHell\b.*"))
.collect(Collectors.joining(","))
);
0
Krzysztof Kaszkowiak
17 Мар 2019 в 15:52
Надеюсь на эту помощь:
package demo;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
enum SearchType {
EXACTWORD,
EXACT_NON_WORD,
IN_THE_BEGINNING,
IN_THE_END,
INSIDE
}
public class Main {
private final static Logger LOGGER =
Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
public static void main(String[] args) {
// Demo with Strings
String myText = "a,abc,abcd, abd def,abc, fgh,erf abc,Hey, Hello there, Hell no";
String separator = ",";
String toFind = "abc";
System.out.println("n------------------------------------------");
System.out.println("SEARCHING TO: " + toFind);
System.out.println("WITH : " + myText);
System.out.println("------------------------------------------");
for (SearchType searchType : SearchType.values()) {
//LOGGER.log(Level.INFO, "Search Type: " + searchType);
String result = filterInputByRegex(myText, separator, toFind, searchType);
System.out.println("tResults for "
+ searchType + " >t"
+ (!result.isEmpty() ? result : "There is no match"));
System.out.println("matches indexes: " + Arrays.toString(searchIndexes(myText, separator, toFind, searchType)));
//LOGGER.log(Level.INFO, "matches indexes: " + Arrays.toString(searchIndexes(myText, separator, toFind, searchType)));
}
// Demo with integers
myText = " 10 01 100 121 110 010 120 11";
separator = " ";
toFind = "10";
System.out.println("n------------------------------------------");
System.out.println("SEARCHING TO: " + toFind);
System.out.println("WITH : " + myText);
System.out.println("------------------------------------------");
for (SearchType searchType : SearchType.values()) {
//LOGGER.log(Level.INFO, "Search Type: " + searchType);
String result = filterInputByRegex(myText, separator, toFind, searchType);
System.out.println("tResults for "
+ searchType + " >t"
+ (!result.isEmpty() ? result : "There is no match"));
System.out.println("matches indexes: " + Arrays.toString(searchIndexes(myText, separator, toFind, searchType)));
//LOGGER.log(Level.INFO, "matches indexes: " + Arrays.toString(searchIndexes(myText, separator, toFind, searchType)));
}
}
/**
* test regex
* @param regex
* @param text
* @return
*/
public static boolean matches(String regex, String text) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
return matcher.find();
}
/**
* Prepare Regex by enum searchType (exact word, non exact word, in the beginning, etc.)
* @param search
* @param searchType
* @return
*/
public static String prepareRegex(String search, SearchType searchType) {
String text = "";
switch(searchType) {
case EXACTWORD:
text = ".*\b" + search + "\b.*";
break;
case EXACT_NON_WORD:
text = ".*\B" + search + "\B.*";
break;
case IN_THE_BEGINNING:
text = "\A" + search + ".*";
break;
case IN_THE_END:
text = ".*" + search + "\z";
break;
case INSIDE:
text = ".*" + search + ".*";
break;
}
return text;
}
/**
* Split String to List
* @param input
* @param separator "," for String or " " for integer list;
* @return
*/
public static List<String> splitToListString(String input, String separator){
return (List<String>) Stream.of(input.split(separator))
.filter(str -> !str.isEmpty())
.map(elem -> new String(elem))
.collect(Collectors.toList());
}
/**
* Join List to String (only for demo)
* @param input
* @param separator
* @return
*/
public static String joinStringListWithSeparator(List<String> input, String separator){
return input.stream().collect(Collectors.joining(separator));
}
/**
* Get Indexes of matching elements
* @param input
* @param separator
* @param search
* @param searchType
* @return
*/
public static int[] searchIndexes(String input, String separator, String search, SearchType searchType) {
final String toFind = prepareRegex(search, searchType);
List<String> sentences = splitToListString(input, separator);
int[] indexesOfResults = IntStream
.range(0, sentences.size())
.filter(index -> matches(toFind, sentences.get(index)))
.toArray();
return indexesOfResults;
}
/**
* Filter List (generated from String) by Regex
* @param input
* @param separator
* @param search
* @param searchType
* @return
*/
public static String filterInputByRegex(String input, String separator, String search, SearchType searchType) {
final String toFind = prepareRegex(search, searchType);
List<String> sentences = splitToListString(input, separator);
List<String> results = sentences
.stream()
.parallel()
.filter(elem -> matches(toFind, elem))
.collect(Collectors.toList());
return joinStringListWithSeparator(results, separator);
}
}
Это демо вернется для “abc” и “10” это:
------------------------------------------
SEARCHING TO: abc
WITH : a,abc,abcd, abd def,abc, fgh,erf abc,Hey, Hello there, Hell no
------------------------------------------
Results for EXACTWORD > abc,abc,erf abc
matches indexes: [1, 4, 6]
Results for EXACT_NON_WORD > There is no match
matches indexes: []
Results for IN_THE_BEGINNING > abc,abcd,abc
matches indexes: [1, 2, 4]
Results for IN_THE_END > abc,abc,erf abc
matches indexes: [1, 4, 6]
Results for INSIDE > abc,abcd,abc,erf abc
matches indexes: [1, 2, 4, 6]
------------------------------------------
SEARCHING TO: 10
WITH : 10 01 100 121 110 010 120 11
------------------------------------------
Results for EXACTWORD > 10
matches indexes: [0]
Results for EXACT_NON_WORD > There is no match
matches indexes: []
Results for IN_THE_BEGINNING > 10 100
matches indexes: [0, 2]
Results for IN_THE_END > 10 110 010
matches indexes: [0, 4, 5]
Results for INSIDE > 10 100 110 010
matches indexes: [0, 2, 4, 5]
0
Benfarhat
17 Мар 2019 в 15:23
Проверьте, содержит ли массив Java значение
1. обзор
В этой статье мы рассмотрим различные способы поиска в массиве указанного значения.
Мы также сравним их эффективность с помощьюJMH (Java Microbenchmark Harness), чтобы определить, какой метод работает лучше всего.
2. Настроить
В наших примерах мы будем использовать массив, содержащий случайно сгенерированныеStrings для каждого теста:
String[] seedArray(int length) {
String[] strings = new String[length];
Random value = new Random();
for (int i = 0; i < length; i++) {
strings[i] = String.valueOf(value.nextInt());
}
return strings;
}Чтобы повторно использовать массив в каждом тесте, мы объявим внутренний класс для хранения массива и счетчика, чтобы мы могли объявить его область действия для JMH:
@State(Scope.Benchmark)
public static class SearchData {
static int count = 1000;
static String[] strings = seedArray(1000);
}3. Базовый поиск
Three commonly used methods for searching an array are as a List, a Set, or with a loop, который исследует каждый член, пока не найдет совпадение.
Начнем с трех методов, реализующих каждый алгоритм:
boolean searchList(String[] strings, String searchString) {
return Arrays.asList(SearchData.strings)
.contains(searchString);
}
boolean searchSet(String[] strings, String searchString) {
Set stringSet = new HashSet<>(Arrays.asList(SearchData.strings));
return stringSet.contains(searchString);
}
boolean searchLoop(String[] strings, String searchString) {
for (String string : SearchData.strings) {
if (string.equals(searchString))
return true;
}
return false;
}Мы будем использовать эти аннотации классов, чтобы указать JMH вывести среднее время в микросекундах и выполнить пять итераций прогрева, чтобы убедиться, что наши тесты надежны:
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 5)
@OutputTimeUnit(TimeUnit.MICROSECONDS)И запустить каждый тест в цикле:
@Benchmark
public void searchArrayLoop() {
for (int i = 0; i < SearchData.count; i++) {
searchLoop(SearchData.strings, "T");
}
}
@Benchmark
public void searchArrayAllocNewList() {
for (int i = 0; i < SearchData.count; i++) {
searchList(SearchData.strings, "T");
}
}
@Benchmark
public void searchArrayAllocNewSet() {
for (int i = 0; i < SearchData.count; i++) {
searchSet(SearchData.strings, "S");
}
}Когда мы запускаем 1000 запросов для каждого метода, наши результаты выглядят примерно так:
SearchArrayTest.searchArrayAllocNewList avgt 20 937.851 ± 14.226 us/op
SearchArrayTest.searchArrayAllocNewSet avgt 20 14309.122 ± 193.844 us/op
SearchArrayTest.searchArrayLoop avgt 20 758.060 ± 9.433 us/opThe loop search is more efficient than others. Но это, по крайней мере, частично из-за того, как мы используем коллекции.
Мы создаем новый экземплярList с каждым вызовомsearchList() и новыйList и новыйHashSet с каждым вызовомsearchSet(). Создание этих объектов требует дополнительных затрат, которых нет при циклическом просмотре массива.
4. Более эффективный поиск
Что происходит, когда мы создаем отдельные экземплярыList иSet, а затем повторно используем их для каждого поиска?
Давайте попробуем:
public void searchArrayReuseList() {
List asList = Arrays.asList(SearchData.strings);
for (int i = 0; i < SearchData.count; i++) {
asList.contains("T");
}
}
public void searchArrayReuseSet() {
Set asSet = new HashSet<>(Arrays.asList(SearchData.strings));
for (int i = 0; i < SearchData.count; i++) {
asSet.contains("T");
}
}Мы запустим эти методы с теми же аннотациями JMH, что и выше, и включим результаты для простого цикла для сравнения.
Мы видим очень разные результаты:
SearchArrayTest.searchArrayLoop avgt 20 758.060 ± 9.433 us/op
SearchArrayTest.searchArrayReuseList avgt 20 837.265 ± 11.283 us/op
SearchArrayTest.searchArrayReuseSet avgt 20 14.030 ± 0.197 us/opВ то время как поискList немного быстрее, чем раньше,Set падает до менее 1 процента времени, необходимого для цикла!
Теперь, когда мы убрали время, необходимое для создания новых коллекций для каждого поиска, эти результаты имеют смысл.
При поиске в хэш-таблице структура, лежащая в основеHashSet, имеет временную сложность 0 (1), а массив, лежащий в основеArrayList, равен 0 (n).
5. Бинарный поиск
Другой метод поиска в массиве -binary search. Хотя бинарный поиск очень эффективен, он требует предварительной сортировки массива.
Давайте отсортируем массив и попробуем бинарный поиск:
@Benchmark
public void searchArrayBinarySearch() {
Arrays.sort(SearchData.strings);
for (int i = 0; i < SearchData.count; i++) {
Arrays.binarySearch(SearchData.strings, "T");
}
}SearchArrayTest.searchArrayBinarySearch avgt 20 26.527 ± 0.376 us/opДвоичный поиск очень быстр, хотя и менее эффективен, чемHashSet:. В худшем случае производительность двоичного поиска равна 0 (log n), что ставит его производительность между поиском по массиву и хэш-таблицей.
6. Заключение
Мы видели несколько методов поиска в массиве.
Согласно нашим результатам,HashSet лучше всего подходит для поиска по списку значений. Однако нам нужно создать их заранее и сохранить в папкеSet.
Как всегда, доступен полный исходный код примеровover on GitHub.
Задача
Как в Java найти в массиве элемент: число, строку или другое значение?
Решение
В следующем примере используется в Java метод Contains для поиска в массиве строки.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList objArray = new ArrayList();
ArrayList objArray2 = new ArrayList();
objArray2.add(0,"общий1");
objArray2.add(1,"общий2");
objArray2.add(2,"необщий");
objArray2.add(3,"необщий1");
objArray.add(0,"общий1");
objArray.add(1,"общий2");
System.out.println("Элементы массива массив1 "+objArray);
System.out.println("Элементы массива массив2 "+objArray2);
System.out.println("Массив1 содержит строку общий2? "
+objArray.contains("общий1"));
System.out.println("Массив2 содержит массив1? "
+objArray2.contains(objArray) );
}
}
Результат
Вышеприведенный пример кода даст следующий результат:
Элементы массива массив1 [общий1, общий2]
Элементы массива массив2 [общий1, общий2, необщий, необщий1]
Массив1 содержит строку общий2? true
Массив2 содержит массив1? false
В этом посте будет обсуждаться, как проверить, содержит ли примитив или массив объектов определенное значение или нет в Java.
1. Линейный поиск
Наивное решение состоит в том, чтобы выполнить линейный поиск в заданном массиве, чтобы проверить, присутствует ли конкретное значение в массиве или нет.
⮚ Для примитивных массивов
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean isPresent(int[] a, int target) { for (int i: a) { if (target == i) { return true; } } return false; } |
⮚ Для массивов объектов
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean isPresent(T[] a, T target) { for (T s: a) { if (target.equals(s)) { return true; } } return false; } |
2. Использование потока Java 8
Мы можем использовать Java 8 Stream, чтобы проверить, содержит ли массив определенное значение, как показано ниже:
⮚ Для примитивных массивов
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean isPresent(int[] a, int target) { return Arrays.stream(a) .anyMatch(x -> x == target); } |
Или с помощью фильтров:
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean isPresent(int[] a, int target) { return Arrays.stream(a) .filter(x -> x == target) .count() > 0; } |
⮚ Для массивов объектов
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean isPresent(T[] a, T target) { return Arrays.stream(a) .anyMatch(x -> target.equals(x)); // или используйте `target::equals` } |
Или с помощью фильтров:
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean isPresent(T[] a, T target) { return Arrays.stream(a) .filter(x -> target.equals(x)) // или используйте `target::equals` .count() > 0; } |
3. Преобразовать в набор или список
Идея состоит в том, чтобы обернуть данный массив в список и использовать List.contains() который возвращает true если этот список содержит указанный элемент. Мы также можем использовать set вместо List.
⮚ Для примитивных массивов
Проверьте, как преобразовать примитивный целочисленный массив в список?
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean isPresent(int[] a, int target) { return Arrays.stream(a) // IntStream .boxed() // Stream<Integer> .collect(Collectors.toList()) // List<Integer> .contains(target); } |
⮚ Для массивов объектов
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean isPresent(T[] a, T target) { return Arrays.asList(a).contains(target); } |
4. Алгоритм бинарного поиска
Для отсортированных массивов мы можем использовать бинарный поиск для поиска в массиве определенного значения. Алгоритм бинарного поиска возвращает индекс указанного элемента, присутствующего в массиве; в противном случае возвращается отрицательное значение. Мы можем определить, содержит ли массив элемент, просто проверив, больше ли вычисленный индекс или равен нулю.
⮚ Для примитивных массивов
|
// Метод проверки, содержит ли примитивный массив определенное значение public static int find(int[] a, int target) { return Arrays.binarySearch(a, target) >= 0; } |
⮚ Для массивов объектов
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> int find(T[] a, T target) { return Arrays.binarySearch(a, target) >= 0; } |
5. Использование Apache Commons Lang
Apache Commons Ланг ArrayUtils класс содержит несколько статических служебных методов, которые работают с массивами примитивов или объектов. Он обеспечивает contains() метод, который проверяет, присутствует ли заданное значение в массиве или нет.
⮚ Для примитивных массивов
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean isPresent(int[] a, int target) { return ArrayUtils.contains(a, target); } |
⮚ Для массивов объектов
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean isPresent(T[] a, T target) { return ArrayUtils.contains(a, target); } |
6. Использование библиотеки Guava
⮚ Для примитивных массивов
Библиотека Guava предоставляет несколько служебных классов, относящихся к примитивам, например Ints для инт, Longs надолго, Doubles на двоих, Floats для поплавка, Booleans для логического значения и так далее.
Каждый класс полезности имеет indexOf() метод, который возвращает индекс первого появления цели в массиве. Мы можем определить, содержит ли массив элемент, проверив, больше ли возвращаемый индекс или равен нулю.
|
// Метод проверки, содержит ли примитивный массив определенное значение public static boolean find(int[] a, int target) { return Ints.indexOf(a, target) >= 0; } |
⮚ Для массивов объектов
Guava’s Iterables класс содержит статический служебный метод indexOf(Iterator, Predicate) который возвращает индекс первого элемента, удовлетворяющего предоставленному предикату, или -1, если итератор не имеет таких элементов.
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean find(T[] a, T target) { int index = Iterators.indexOf(Iterators.forArray(a), Predicates.in(Collections.singleton(target))); return index >= 0; } |
Для Java 8 и выше мы можем использовать лямбда-выражения:
|
// Общий метод для проверки, содержит ли массив объектов определенное значение public static<T> boolean find(T[] a, T target) { return Iterators.indexOf(Iterators.forArray(a), x -> x.equals(target)) >= 0; } |
Это все, что касается определения того, содержит ли массив определенное значение в Java.
