Как найти элемент в коллекции java

Сама Java предоставляет несколько способов поиска элемента в списке:

boolean contains(Object element)

Customer james = new Customer(2, "James");
if (customers.contains(james)) {
    // ...
}

int indexOf(Object element)

if(customers.indexOf(james) != -1) {
    // ...
}

public Customer findUsingEnhancedForLoop(
  String name, List customers) {

    for (Customer customer : customers) {
        if (customer.getName().equals(name)) {
            return customer;
        }
    }
    return null;
}

public Customer findUsingIterator(
  String name, List customers) {
    Iterator iterator = customers.iterator();
    while (iterator.hasNext()) {
        Customer customer = iterator.next();
        if (customer.getName().equals(name)) {
            return customer;
        }
    }
    return null;
}

Customer james = customers.stream()
  .filter(customer -> "James".equals(customer.getName()))
  .findAny()
  .orElse(null);

В этом посте будет обсуждаться, как проверить, присутствует ли элемент в наборе в Java.

1. Использование Set.contains() метод

Стандартное решение для проверки наличия элемента в наборе — использование contains(o) метод. Возвращает true, если набор содержит элемент e такой, что Objects.equals(o, e) держит.

Скачать  Выполнить код

 
Обратите внимание, что если класс не переопределяет equals() а также hashCode() методы, реализация этих методов по умолчанию проверяет только ссылочное равенство. Другими словами, если объект такого класса вставлен в набор, contains() метод вернет false. Например, рассмотрим следующий код, который возвращает false:

Скачать  Выполнить код

 
Чтобы исправить это, просто переопределить методы equals и hashCode. Оба эти метода могут быть автоматически сгенерированы IDE (Eclipse, IntelliJ IDEA и т. д.).

Скачать  Выполнить код

2. Использование Stream.anyMatch() метод

В Java 8 и выше вы можете использовать Stream.anyMatch() метод, который возвращает true, если какой-либо элемент потока соответствует указанному предикату.

Скачать  Выполнить код

3. Использование коллекций Apache Commons

Если в вашем проекте используется библиотека Apache Commons Collections, вы можете использовать CollectionUtils.containsAny() метод, который возвращает true, если какой-либо элемент коллекции совпадает с любым из указанных элементов.

Скачать код

4. Использование Collections.disjoint() метод

Наконец, вы можете использовать Collections.disjoint() метод в Java, который возвращает true, если две указанные коллекции не имеют общих элементов. Однако этот метод может страдать от накладных расходов, вызванных созданием коллекции, содержащей искомое значение.

Скачать  Выполнить код

Это все о проверке наличия элемента в наборе в Java.

Интерфейс Java List, java.util.List, представляет упорядоченную последовательность объектов. Элементы, содержащиеся в списке Java, вставлять и удалять в соответствии с порядком их появления в списке.

Каждый элемент в списке Java имеет индекс. Первый элемент в имеет индекс 0, второй элемент имеет индекс 1 и т.д.

Вы можете добавить любой объект в список. Если список не типизирован с использованием Java Generics, то вы можете даже смешивать объекты разных типов (классов) в одном и том же списке.

Java List – это стандартный интерфейс, который является подтипом Java Collection, что означает, что означает, что List наследуется от Collection.

Если вы предпочитаете смотреть видео вместо чтения текста, вот видео версия этого учебника по Java List:

Java List и Set

Java List и Java Set очень похожи в том, что они оба представляют коллекцию элементов. Тем не менее, есть некоторые существенные различия.

Первое различие между Java List и Java Set состоит в том, что один и тот же элемент может встречаться в списке более одного раза. Это отличается от набора, где каждый элемент может встречаться только один раз.

Второе различие – элементы в List имеют порядок, и элементы могут повторяться в этом порядке. Набор не предполагает порядок элементов, хранящихся внутри.

Реализация List

Будучи подтипом Collection, все методы в интерфейсе Collection также доступны в Listinterface.

Поскольку List – это интерфейс, вам необходимо создать конкретную реализацию интерфейса, чтобы использовать его. Вы можете выбирать между следующими реализациями List в API коллекций Java:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

Также есть параллельные реализации List в пакете java.util.concurrent.

Вот несколько примеров того, как создать экземпляр List:

List listA = new ArrayList();
List listB = new LinkedList();
List listC = new Vector();
List listD = new Stack();

Как вставить элементы в список Java

Вставить элементы (объекты) в список Java можно методом add (). Вот пример добавления элементов в список Java:

List listA = new ArrayList();

listA.add("element 1");
listA.add("element 2");
listA.add("element 3");

Первые три вызова add () добавляют экземпляр String в конец списка.

Вставить нулевые значения

На самом деле возможно вставить даже нулевые значения в список.

Object element = null;

List list = new ArrayList();

list.add(element);

Добавить элементы по определенному индексу

Можно добавить элемент в список по определенному индексу. Интерфейс List имеет версию метода add(), которая принимает индекс в качестве первого параметра, и элемент для вставки в качестве второго параметра. Вот пример вставки элемента с индексом 0.

list.add(0, "element 4");

Если список уже содержит элементы, то теперь они будут перемещаться дальше во внутренней последовательности. Элемент, который имел индекс 0 до того, как новый элемент был вставлен в индекс 0, будет перемещен в индекс 1 и т.д.

Вставляем все элементы из одного списка в другой

Можно добавить все элементы из одного списка в другой. Сделаем это с помощью метода ListaddAll (). Результат представляет собой объединение двух списков.

List listSource = new ArrayList();

listSource.add("123");
listSource.add("456");

List listDest   = new ArrayList();

listDest.addAll(listSource);

Этот пример добавляет все элементы из listSource в listDest.

Метод addAll () принимает набор в качестве параметра, поэтому в качестве параметра можно передать список или набор.

Получить элементы из списка Java

Вы можете получить элементы из списка Java, используя индекс элементов. Методом get (int index). Вот пример доступа к элементам списка с использованием индексов элементов:

List listA = new ArrayList();

listA.add("element 0");
listA.add("element 1");
listA.add("element 2");

//access via index
String element0 = (String) listA.get(0);
String element1 = (String) listA.get(1);
String element3 = (String) listA.get(2);

Также возможно итерировать элементы списка в том порядке, в котором они хранятся внутри.

Как найти элементы в списке Java

Вы можете найти элементы в списке Java, используя один из этих двух методов:

1. index()
2. LastIndexOf ()Метод indexOf () находит индекс первого вхождения в списке заданного элемента.

List list = new ArrayList();

String element1 = "element 1";
String element2 = "element 2";

list.add(element1);
list.add(element2);

int index1 = list.indexOf(element1);
int index2 = list.indexOf(element2);

System.out.println("index1 = " + index1);
System.out.println("index2 = " + index2);

Запуск этого кода приведет к следующему результату:

index1 = 0
index2 = 1

Найти последнее вхождение элемента в списке

Метод lastIndexOf () находит индекс последнего вхождения в списке данного элемента.

List list = new ArrayList();

String element1 = "element 1";
String element2 = "element 2";

list.add(element1);
list.add(element2);
list.add(element1);

int lastIndex = list.lastIndexOf(element1);
System.out.println("lastIndex = " + lastIndex);

Результат, напечатанный при запуске приведенного выше примера будет таков:

lastIndex = 2

Элемент 1 встречается 2 раза. Индекс последнего равен 2.

Проверка: содержит ли список элемент?

Вы можете проверить, содержит ли Java List данный элемент, используя метод List contains ().

List list = new ArrayList();

String element1 = "element 1";

list.add(element1);

boolean containsElement =
    list.contains("element 1");

System.out.println(containsElement);

Результат:
true

Чтобы определить, содержит ли List этот элемент, List будет внутренне выполнять итерации своих элементов и сравнивать каждый элемент с объектом, переданным в качестве параметра.

Поскольку можно добавить нулевые значения в список, фактически можно проверить, содержит ли список нулевое значение.

list.add(null);

containsElement = list.contains(null);

System.out.println(containsElement);

Очевидно, что если входной параметр для contains () имеет значение null, метод contains () не будет использовать метод equals() для сравнения с каждым элементом, а вместо этого использует оператор ==.

Как удалить элементы из списка Java

Вы можете удалить элементы из списка Java с помощью этих двух методов:

• remove(Object element)
• remove(int index)

remove (Object element) удаляет элемент в списке, если он присутствует. Все последующие элементы, затем перемещаются вверх по списку. Таким образом, их индекс уменьшается на 1.

List list = new ArrayList();

String element = "first element";
list.add(element);

list.remove(element);

Этот пример сначала добавляет элемент, а затем снова удаляет его.

Метод List remove (int index) удаляет элемент по указанному индексу.

List list = new ArrayList();

list.add("element 0");
list.add("element 1");
list.add("element 2");

list.remove(0);

После выполнения этого примера кода список будет содержать элементы 1 и 2 с индексами 0 и 1.

Очистить список

Интерфейс Java List содержит метод clear (), который удаляет все элементы из списка при вызове. Удаление всех элементов также называется очисткой.

List list = new ArrayList();

list.add("object 1");
list.add("object 2");
//etc.

list.clear();

Как сохранить все элементы из одного списка в другом

Метод retainAll () способен сохранять все элементы из одного списка в другом. Другими словами, метод retain () удаляет все элементы, которые не найдены в другом списке.

Результатом является пересечение двух списков.

List list      = new ArrayList();
List otherList = new ArrayList();

String element1 = "element 1";
String element2 = "element 2";
String element3 = "element 3";
String element4 = "element 4";

list.add(element1);
list.add(element2);
list.add(element3);

otherList.add(element1);
otherList.add(element3);
otherList.add(element4);

list.retainAll(otherList);

Узнать количество элементов

Вы можете получить количество элементов вызвав метод size (). Вот пример:

List list = new ArrayList();

list.add("object 1");
list.add("object 2");

int size = list.size();

Подсписок списка

Метод subList () может создавать новый List с подмножеством элементов из исходного List.

Метод subList () принимает 2 параметра: начальный индекс и конечный индекс. Начальный индекс – это индекс первого элемента из исходного списка для включения в подсписок.

Конечный индекс является последним индексом подсписка, но элемент в последнем индексе не включается в подсписок. Это похоже на то, как работает метод подстроки Java String.

List list      = new ArrayList();

list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 4");

List sublist = list.subList(1, 3);

После выполнения list.subList (1,3) подсписок будет содержать элементы с индексами 1 и 2.

Помните, что исходный список содержит 4 элемента с индексами от 0 до 3. Вызов list.subList (1,3) будет включить индекс 1, но исключить индекс 3, сохраняя тем самым элементы с индексами 1 и 2.

Преобразовать list в set

Вы можете преобразовать список Java в набор(set), создав новый набор и добавив в него все элементы из списка. Набор удалит все дубликаты.

Таким образом, результирующий набор будет содержать все элементы списка, но только один раз.

List list = new ArrayList();

list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 3");

Set set = new HashSet();
set.addAll(list);

Обратите внимание, что список содержит элемент String 3 два раза. Набор будет содержать эту строку только один раз. Таким образом, результирующий набор будет содержать строки:  element 1, element 2 and element 3 .

Читайте как преобразовать список в массив Java.

Общие списки

По умолчанию вы можете поместить любой объект в список, но Java позволяет ограничить типы объектов, которые вы можете вставить в список.

List<MyObject> list = new ArrayList<MyObject>();

Этот список теперь может содержать только экземпляры MyObject. Затем вы можете получить доступ к итерации его элементов без их приведения.

MyObject myObject = list.get(0);

for(MyObject anObject : list){
   //do someting to anObject...
}

Сортировка

Вы можете отсортировать список с помощью метода Collections sort ().

Если Список содержит объекты, которые реализуют интерфейс Comparable (java.lang.Comparable), тогда эти объекты можно сравнивать. В этом случае вы можете отсортировать список следующим образом:

List<String> list = new ArrayList<String>();

list.add("c");
list.add("b");
list.add("a");

Collections.sort(list);

Класс Java String реализует интерфейс Comparable, вы можете отсортировать их в естественном порядке, используя метод Collections sort ().

Сортировка списка с помощью Comparatorimplementation

Если объекты не реализуют интерфейс Comparable или если вы хотите отсортировать объекты в порядке, отличном от их реализации compare (), вам необходимо использовать Comparatorimplementation (java.util.Comparator).

public class Car{
    public String brand;
    public String numberPlate;
    public int noOfDoors;

    public Car(String brand, String numberPlate, int noOfDoors) {
        this.brand = brand;
        this.numberPlate = numberPlate;
        this.noOfDoors = noOfDoors;
    }
}

Вот код сортировки:

List<Car> list = new ArrayList<>();

list.add(new Car("Volvo V40" , "XYZ 201845", 5));
list.add(new Car("Citroen C1", "ABC 164521", 4));
list.add(new Car("Dodge Ram" , "KLM 845990", 2));

Comparator<Car> carBrandComparator = new Comparator<Car>() {
    @Override
    public int compare(Car car1, Car car2) {
        return car1.brand.compareTo(car2.brand);
    }
};

Collections.sort(list, carBrandComparator);

Обратите внимание на реализацию Comparator в приведенном выше примере. Эта реализация сравнивает только поле марки автомобилей Car. Можно создать другую реализацию Comparator, которая сравнивает номерные знаки или даже количество дверей в автомобилях.

Возможно реализовать Comparator с использованием Java Lambda. Вот пример, который сортирует объекты List of Car с использованием трех различных реализаций интерфейса Comparator, каждая из которых сравнивает экземпляры Car по своему полю:

List<Car> list = new ArrayList<>();

list.add(new Car("Volvo V40" , "XYZ 201845", 5));
list.add(new Car("Citroen C1", "ABC 164521", 4));
list.add(new Car("Dodge Ram" , "KLM 845990", 2));


Comparator<Car> carBrandComparatorLambda      =
    (car1, car2) -> car1.brand.compareTo(car2.brand);

Comparator<Car> carNumberPlatComparatorLambda =
    (car1, car2) -> car1.numberPlate.compareTo(car2.numberPlate);

Comparator<Car> carNoOfDoorsComparatorLambda  =
    (car1, car2) -> car1.noOfDoors - car2.noOfDoors;

Collections.sort(list, carBrandComparatorLambda);
Collections.sort(list, carNumberPlatComparatorLambda);
Collections.sort(list, carNoOfDoorsComparatorLambda);

Итерации

Вы можете выполнить итерацию списка несколькими различными способами. Три наиболее распространенных способа:

• Использование итератора
• Использование цикла for-each
• Использование цикла for
• Использование API Java Stream

Итерация списка с помощью итератора

Первый способ итерации списка – использовать итератор Java.

List list = new ArrayList();

list.add("first");
list.add("second");
list.add("third");

Iterator iterator = list.iterator();
while(iterator.hasNext()) {
    Object next = iterator.next();
}

Вызывая метод iterator () интерфейса List.

Вызов hasNext () выполняется внутри цикла while.

Внутри цикла while вы вызываете метод Iterator next () для получения следующего элемента, на который указывает Iterator.

Если список задан с использованием Java Generics, вы можете сохранить некоторые объекты внутри цикла while.

List<String> list = new ArrayList<>();

list.add("first");
list.add("second");
list.add("third");
    
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
    String obj = iterator.next();
}

Итерация списка с использованием цикла For-Each

Второй способ итерации List – использовать цикл for.

List list = new ArrayList();

list.add("first");
list.add("second");
list.add("third");

for(Object element : list) {
    System.out.println(element);
}

Цикл for выполняется один раз для каждого элемента. Внутри цикла for каждый элемент, в свою очередь, связан с переменной obj.

Можно изменить тип переменной внутри цикла for.

List<String> list = new ArrayList<String>();

//add elements to list

for(String element : list) {
    System.out.println(element);
}

Итерация списка с помощью цикла For

Третий способ итерации List – использовать стандартный цикл for, подобный следующему:

List list = new ArrayList();

list.add("first");
list.add("second");
list.add("third");
    
for(int i=0; i < list.size(); i++) {
    Object element = list.get(i);
}

Цикл for создает переменную int и инициализирует ее 0. Затем она зацикливается, пока переменная int i меньше размера списка. Для каждой итерации переменная i увеличивается.

Внутри цикла for обращаемся к элементам List с помощью метода get (), передавая в качестве параметра переменную i.

Опять же, если список напечатан с использованием Java Generics, например, для для строки, то вы можете использовать универсальный тип списка в качестве типа для локальной переменной, которая присваивается каждому элементу списка во время итерации.

List<String> list = new ArrayList<String>();

list.add("first");
list.add("second");
list.add("third");
    
for(int i=0; i < list.size(); i++) {
    String element = list.get(i);
}

Тип локальной переменной внутри цикла for теперь String. Поскольку список обычно типизируется как String, он может содержать только объекты String.

Следовательно, компилятор знает, что только метод String может быть возвращен из метода get (). Поэтому вам не нужно приводить элемент, возвращенный get (), в String.

Перебор списка с использованием API Java Stream

Четвертый способ итерации через API Java Stream. Для итерации вы должны сначала получить поток из списка. Получение потока из списка в Java выполняется путем вызова метода Liststream ().

List<String> stringList = new ArrayList<String>();

stringList.add("abc");
stringList.add("def");

Stream<String> stream = stringList.stream();

Как только вы получили поток из списка, вы можете выполнить итерацию потока, вызвав его метод forEach ().

List<String> stringList = new ArrayList<String>();

stringList.add("one");
stringList.add("two");
stringList.add("three");

Stream<String> stream = stringList.stream();
stream
    .forEach( element -> { System.out.println(element); });

Вызов метода forEach () заставит Stream выполнить внутреннюю итерацию всех элементов потока.

In this Java tutorial, you will learn how to use the Collections utility class in the Java Collections framework to search for elements in a collection.

You know, the java.util.Collections class provides reusable functionalities that operation on collections such as finding extremes values in a collection and searching for specific values in a list. These are grouped into “generic algorithms” category. In this article, we help you understand how to use these functionalities with code examples.

• Collections.max() examples
• Collections.min() examples
• Collections.binarySearch() examples
• Collections.indexOfSubList() example
• Collections.lastIndexOfSubList() example

1. Finding extreme values in a collection

The methods in this group allow us to find the maximum and minimum elements in a collection, in terms of natural ordering or using a specified comparator.

Finding the maximum element:

The following method returns the maximum element in a given collection, according to the natural ordering of its elements, which must implement the Comparable interface:

public static T max(Collection<? extends T> collection)

Code example:

List<Integer> listNumbers = Arrays.asList(31, 87, 22, 45, 12, 98, 3, 6, 7);

Integer max = Collections.max(listNumbers);

System.out.println("Maximum number: " + max);

Output:

Maximum number: 98

The following overload method returns the maximum element of the given collection, according to the order determined by the specified comparator:

public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

The following code example finds in a list of Strings the String having the most number of letters:

List<String> listCities = Arrays.asList("London", "Paris", "New York",
	"Washington", "Tokyo", "Rio De Janero", "Bangalore");

Comparator<String> comparator = new Comparator<String>() {
	public int compare(String s1, String s2) {
		return s1.length() - s2.length();
	}
};

String max = Collections.max(listCities, comparator);

System.out.println("Most-letter city name: " + max);

Output:

Most-letter city name: Rio De Janero

Finding the minimum element:

The following method returns the minimum element in a given collection, according to the natural ordering of its elements, which must implement the Comparable interface:

public static T min(Collection<? extends T> collection)

Code example:

List<Integer> listNumbers = Arrays.asList(31, 87, 22, 45, 12, 98, 3, 6, 7);

Integer min = Collections.min(listNumbers);

System.out.println("Minimum number: " + min);

Output:

Minimum number: 3

The following overload method returns the minimum element of the given collection, according to the order determined by the specified comparator:

public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

Given the following entity class:

class Employee implements Comparable<Employee> {
	int salary;
	String name;

	public Employee(String name) {
		this.name = name;
	}

	public Employee(int salary) {
		this.salary = salary;
	}

	public Employee(String name, int salary) {
		this.name = name;
		this.salary = salary;
	}

	public String toString() {
		return this.name + " (salary: " + salary + ")";
	}

	public int compareTo(Employee another) {
		return this.name.compareTo(another.name);
	}
}

Here, the natural ordering of the Employeeclass is based on its name. Hence the following code finds the employee who gets paid the least:

List<Employee> listEmployees = new ArrayList<>();

listEmployees.add(new Employee("Tom", 40000));
listEmployees.add(new Employee("Adam", 60000));
listEmployees.add(new Employee("Jim", 70000));
listEmployees.add(new Employee("Dane", 35000));
listEmployees.add(new Employee("Jack", 56000));
listEmployees.add(new Employee("Carol", 67000));

Comparator<Employee> comparator = new Comparator<Employee>() {
	public int compare(Employee emp1, Employee emp2) {
		return this.name.compareTo(another.name);
	}
};

Employee min = Collections.min(listEmployees, comparator);

System.out.println("Least paid employee: " + min);

Output:

Least paid employee: Dane (salary: 35000)

2. Finding specific values in a list

The methods in this group allow us to search for a specific object in a list, or the position of a list contained within another list.

Binary search according to natural ordering:

The following method searches the specified list for the specified object using the binary search algorithm:

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

Note that the list must be sorted into ascending order according to the natural ordering of its elements before invoking this method. Otherwise the results are undefined.

This method returns the index of the search key if it is contained in the list (in case the list contains multiple elements equal to the specified key, there is no guarantee which one will be found). Also note that the return value always >=0 if and only if the key is found.

The following code example searches for an employee whose name is “Jim” in the list of employees above:

Employee jim = new Employee("Jim");

Collections.sort(listEmployees);

int index = Collections.binarySearch(listEmployees, jim);

if (index >= 0) {
	jim = listEmployees.get(index);
	System.out.println("Found employee: " + jim);
}

Output:

Found employee: Jim (salary: 70000)

Binary search using a comparator:

The Collectionsutility class also provides an overloaded method that searches the specified list for the specified object according to the order determined by the specified comparator:

public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

Note that the list must be sorted into ascending order according to the specified comparator. Otherwise the results are undefined.

For example, the following code searches for an employees who salary is 70,000:

Comparator<Employee> comparator = new Comparator<Employee>() {
	public int compare(Employee emp1, Employee emp2) {
		return emp1.salary - emp2.salary;
	}
};

Collections.sort(listEmployees, comparator);

Employee keyEmp = new Employee(70000);

int index = Collections.binarySearch(listEmployees, keyEmp, comparator);

if (index >= 0) {
	keyEmp = listEmployees.get(index);
	System.out.println("Found: " + keyEmp);
}

Output:

Found: Jim (salary: 70000)

Search where a list contained in another:

The following method returns the starting position of the first occurrence of the specified target list within the specified source list:

public static int indexOfSubList(List<?> source, List<?> target)

This method returns -1 if the target list is not contained in the source list. Here’s an example:

List<Integer> source = Arrays.asList(91, 92, 93, 92, 95, 96, 97, 98, 99);
List<Integer> target = Arrays.asList(95, 96, 97);

int startingIndex = Collections.indexOfSubList(source, target);

System.out.println("Starting position: " + startingIndex);

Output:

Starting position: 4

Search the last position of the target list within the source list:

The following method returns the starting position of the last occurrence of the specified target list within the specified source list (or return -1 if the is no such occurrence):

public static int lastIndexOfSubList(List<?> source, List<?> target)

Code example:

List<Integer> source = Arrays.asList(18, 33, 66, 99, 22, 33, 66, 11, 100);
List<Integer> target = Arrays.asList(33, 66);

int lastIndex = Collections.lastIndexOfSubList(source, target);

System.out.println("Last index : " + lastIndex);

Output:

Last index : 5

References:

• Collections Class Javadoc

Related Collection Utility Classes Tutorials:

• Java Arrays Utility Class Examples for List view, Sorting and Searching
• Java Collections Factory Method Examples
• Java Collections Utility Examples for Changing Order and Content of a List
• Java Collections Wrapper Methods Examples

Other Java Collections Tutorials:

• What is Java Collections Framework?
• Java Queue Tutorial
• Java List Tutorial
• Java Set Tutorial
• Java Map Tutorial
• Understand equals and hashCode
• Understand object ordering
• 18 Java Collections and Generics Best Practices