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

Java Language Arrays Finding an element in an array

There are many ways find the location of a value in an array. The following example snippets all assume that the array is one of the following:

 String[] strings = new String[] < "A", "B", "C" >; int[] ints = new int[] < 1, 2, 3, 4 >; 

In addition, each one sets index or index2 to either the index of required element, or -1 if the element is not present.

Using Arrays.binarySearch (for sorted arrays only)

 int index = Arrays.binarySearch(strings, "A"); int index2 = Arrays.binarySearch(ints, 1); 

Using a Arrays.asList (for non-primitive arrays only)

 int index = Arrays.asList(strings).indexOf("A"); int index2 = Arrays.asList(ints).indexOf(1); // compilation error 

Using a Stream

 int index = IntStream.range(0, strings.length) .filter(i -> "A".equals(strings[i])) .findFirst() .orElse(-1); // If not present, gives us -1. // Similar for an array of primitives 

Linear search using a loop

 int index = -1; for (int i = 0; i < array.length; i++) < if ("A".equals(array[i])) < index = i; break; >> // Similar for an array of primitives 

Linear search using 3rd-party libraries such as org.apache.commons

 int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A"); int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1); 

Note: Using a direct linear search is more efficient than wrapping in a list.

Testing if an array contains an element

The examples above can be adapted to test if the array contains an element by simply testing to see if the index computed is greater or equal to zero.

Alternatively, there are also some more concise variations:

boolean isPresent = Arrays.asList(strings).contains("A"); 

boolean isPresent = Stream.of(strings).anyMatch(x -> "A".equals(x)); 

boolean isPresent = false; for (String s : strings) < if ("A".equals(s)) < isPresent = true; break; >> boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4); 

PDF — Download Java Language for free

Источник

Кофе-брейк #221. Три способа, как найти элемент в массиве Java. Что такое Java Thread Local и как его использовать

Источник: Asyncq Эта публикация поможет вам лучше узнать, какие существуют способы поиска элемента в массиве в Java. Поиск определенного элемента в наборе значений — очень распространенная и часто используемая операция в разработке программного обеспечения. Существуют разные подходы к решению этой проблемы, от простых до оптимизированных. Давайте их рассмотрим.

Вводные данные

Вводный массив содержит примитивные данные идентификаторов, и нам нужно узнать, содержится ли в нем id->3.

Способ 1 (простой)

1. Посещаем все элементы массива, поочередно по одному элементу.
2. Дополнительно отслеживаем состояние целевого элемента, если он существует в массиве.
3. Как только мы находим этот элемент, то переключаем статус с false на true .
4. После завершения цикла возвращаем флаг состояния.

 boolean valExist = false; for (int id : ids) < if (inputId == id) < valExist = true; >> return valExist; 

Это решение работает, но оно не очень эффективно. Если вы посмотрите на условие if , то поймете, что мы проверяем это условие для всех элементов. Допустим, элемент, который мы ищем, является первым элементом, но наш цикл все равно продолжит выполняться для всех элементов. Здесь разумнее было бы выйти из цикла, как только мы найдем элемент. Сделав это, мы бы сэкономили на вычислениях, когда искомый элемент находится не в последней позиции.

 boolean valExist = false; for (int id : ids) < if (inputId == id) < valExist = true; break; >> return valExist; 

Можно сделать код еще более кратким, используя return . Мы можем вернуть true , как только увидим искомый элемент, в противном случае возвращаем false , как только цикл завершится. И нам не нужно создавать и поддерживать переменную состояния.

 for (int id : ids) < if (inputId == id) < return true; >> return false; 

Способ 2

1. Мы можем использовать ArrayList , содержащий метод, который по умолчанию ищет целевой элемент в списке.
2. Поскольку этот метод предоставляется List , нам нужно преобразовать наш примитивный массив в список.
3. Мы можем использовать одну лямбда-строку, которая преобразует примитив в тип объекта и создает из него список (list).

 return Arrays.asList(Arrays.stream(ids).boxed().toArray()) .contains(inputId); 

 return Arrays.stream(ids) .anyMatch(id -> inputId); 

Способ 3 (оптимизированный)

1. Если с памятью нет проблем и мы хотим оптимизировать вычисления, то одна из вещей, которые мы можем здесь сделать, — это создать набор из вводного массива.
2. Мы снова можем использовать код функционального стиля для преобразования примитивного массива в Set .
3. Теперь, когда у нас есть Set , мы можем искать элемент в течение постоянного время.

 et idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet()); return idsSet.contains(inputId); 

Бонус

Поиск одного элемента можно считать обычной операцией, но более распространенным все же является поиск нескольких элементов в массиве. В данном случае, если мы не используем Set , у нас будет два цикла, а временная сложность увеличится до умножения длины двух коллекций. Ниже приведен пример, в котором мы преобразуем один из массивов как набор (set), а затем перебираем другой массив и выполняем поиск в операции набора. Делая это, мы увеличиваем память и при этом экономим на вычислениях.

 int[] targetIds = < 1, 3, 6, 88, 999, 34, 44, 55>; int[] ids = < 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 >; Set idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet()); return Arrays.stream(targetIds) .boxed() .filter(id -> !idsSet.contains(id)) .mapToInt(a -> a) .toArray(); 

Что такое Java Thread Local и как его использовать

Источник: Medium В данной статье мы рассмотрим Java Thread Local и способы его эффективного использования в ваших Java-приложениях. Java Thread Local — это мощная функция, которая позволяет разработчикам создавать переменные только для определенного потока. Это означает, что у каждого потока может быть своя копия переменной, и изменения, внесенные в переменную в одном потоке, не повлияют на ее значение в другом потоке.

Что такое Thread Local

Thread Local — это класс в API Java, который позволяет создавать переменные, локальные для определенного потока. То есть, каждый поток имеет свою собственную копию переменной, и изменения, внесенные в переменную в одном потоке, не влияют на ее значение в другом потоке. Это делает Thread Local идеальным решением для хранения данных, специфичных для потока, таких как информация об аутентификации пользователя, соединения с базой данных или любая другая информация, относящаяся к потоку.

Как работает Thread Local в Java

Чтобы использовать Thread Local в вашем Java-приложении, сначала нужно создать экземпляр класса Thread Local . Это можно сделать, вызвав конструктор ThreadLocal , который и создаст новый экземпляр этого класса. Далее, создав объект Thread Local , вы можете использовать его для хранения и извлечения данных, специфичных для каждого потока. Вот пример того, как использовать Thread Local в вашем Java-приложении:

 public class MyThreadLocalClass < private static final ThreadLocalthreadLocal = new ThreadLocal<>(); public static void set(String value) < threadLocal.set(value); >public static String get() < return threadLocal.get(); >> 

В этом примере мы создали объект Thread Local по имени threadLocal типа String . Мы также создали два метода: set() и get() , которые позволяют нам сохранять и извлекать значение переменной Thread Local . Чтобы сохранить значение в переменной Thread Local , мы просто вызываем метод set() и передаем значение, которое хотим сохранить. Например, мы можем вызвать MyThreadLocalClass.set(«Hello, World!») для сохранения строки “Hello, World!” в переменной Thread Local . Чтобы получить значение переменной Thread Local , мы просто вызываем метод get() . Например, мы можем вызвать String value = MyThreadLocalClass.get() для получения значения переменной Thread Local .

Рекомендации по работе с Thread Local

1. Используйте Thread Local только при необходимости: лишь для данных, относящихся к потоку. Если данные не относятся к конкретному потоку, они должны храниться другим способом.
2. Избегайте чрезмерного использования памяти: Thread Local может потреблять значительный объем памяти, если не использовать его осторожно. Обязательно очищайте переменные Thread Local , когда они больше не нужны, чтобы избежать чрезмерного использования памяти.
3. Используйте Thread Local с осторожностью в многопоточных средах: важно понимать потенциальные риски и ограничения. Обязательно тщательно протестируйте свой код, чтобы убедиться, что Thread Local работает должным образом в вашей конкретной среде.

Заключение

Java Thread Local — отличный инструмент, позволяющий разработчикам создавать переменные только для определенного потока. Используя Thread Local , вы можете хранить данные, относящиеся к потоку, например информацию об аутентификации пользователя, подключения к базе данных или другую информацию, относящуюся к потоку. Хотя Thread Local может быть мощным инструментом, важно использовать его правильно, чтобы избежать потенциальных проблем. Следуя рекомендациям и тестируя свой код, вы сможете эффективно его использовать для повышения производительности и надежности ваших Java-приложений.

Источник

Поиск элемента в массиве

Достаточно частая задача — это поиск элемента в массиве. Допустим у нас есть массив 1,5,8,10,16,20. 100 и нам нужно найти позицию элемента 10 в нем. Или вообще выяснить есть ли такой элемент в массиве.

Существуют следующие алгоритмы решающие эту задачу —

• Линейный поиск — О(n)
• Двоичный поиск — O(log (N))
• Поиск прыжками — O(sqrt (N))
• Интерполяционный поиск — O(log log N)
• Экспоненциальный поиск — O(log (N))

Рассмотрим некоторые из них.

1. Линейный поиск

Самый простой, но и самый долгий алгоритм. Перебираем элементы массива и сравниваем с elementToSearch, который мы должны найти.

 public static int linearSearch(int[] array, int elementToSearch) < for (int i = 0; i < array.length; i++) < if (array[i] == elementToSearch) < return i; >> return -1; >

2. Двоичный поиск, итеративный подход

Для использования алгоритма, массив должен быть отсортирован. Идея метода состоит в том, что мы делим массив пополам, берем «средний элемент» с индексом middleIndex, и сравниваем с искомым. Если они равны, мы заканчиваем поиск. Если искомый элемент меньше «среднего элемента» мы отбрасываем правую часть массива, иначе — левую. После чего повторяем эти операции снова и снова, пока искомый элемент не будет найден, или пока новый отрезок не станет пустым. Если элемент не нашелся возвращаем значение -1.

public static int binarySearch(int[] array, int elementToSearch) < int firstIndex = 0; int lastIndex = array.length - 1; // условие прекращения (элемент не представлен) while (firstIndex // если средний элемент меньше // направляем наш индекс в middle+1, убирая первую часть из рассмотрения else if (array[middleIndex] < elementToSearch) < firstIndex = middleIndex + 1; >// если средний элемент больше // направляем наш индекс в middle-1, убирая вторую часть из рассмотрения else if (array[middleIndex] > elementToSearch) < lastIndex = middleIndex - 1; >> return -1; >

3. Двоичный поиск, рекурсивный подход

 public static int recursiveBinarySearch(int[] array, int firstElement, int lastElement, int elementToSearch) < // условие прекращения if (lastElement >= firstElement) < int middle = (lastElement + firstElement) / 2; // если средний элемент - целевой элемент, вернуть его индекс if (array[middle] == elementToSearch) < return middle; >// если средний элемент больше целевого // вызываем метод рекурсивно по суженным данным if (array[middle] > elementToSearch) < return recursiveBinarySearch(array, firstElement, middle - 1, elementToSearch); >// также, вызываем метод рекурсивно по суженным данным return recursiveBinarySearch(array, middle + 1, lastElement, elementToSearch); > return -1; >

4. Поиск прыжками

 public static int jumpSearch(int[] array, int elementToSearch) < int arrayLength = array.length; int jumpStep = (int) Math.sqrt(array.length); int previousStep = 0; while (array[Math.min(jumpStep, arrayLength) - 1] < elementToSearch) < previousStep = jumpStep; jumpStep += (int) (Math.sqrt(arrayLength)); if (previousStep >= arrayLength) < return -1; >> while (array[previousStep] < elementToSearch) < previousStep++; if (previousStep == Math.min(jumpStep, arrayLength)) < return -1; >> if (array[previousStep] == elementToSearch) < return previousStep; >return -1; >

Источник

Поиск элемента в массиве

Достаточно частая задача — это поиск элемента в массиве. Допустим у нас есть массив 1,5,8,10,16,20. 100 и нам нужно найти позицию элемента 10 в нем. Или вообще выяснить есть ли такой элемент в массиве.

Существуют следующие алгоритмы решающие эту задачу —

• Линейный поиск — О(n)
• Двоичный поиск — O(log (N))
• Поиск прыжками — O(sqrt (N))
• Интерполяционный поиск — O(log log N)
• Экспоненциальный поиск — O(log (N))

Рассмотрим некоторые из них.

1. Линейный поиск

Самый простой, но и самый долгий алгоритм. Перебираем элементы массива и сравниваем с elementToSearch, который мы должны найти.

 public static int linearSearch(int[] array, int elementToSearch) < for (int i = 0; i < array.length; i++) < if (array[i] == elementToSearch) < return i; >> return -1; >

2. Двоичный поиск, итеративный подход

Для использования алгоритма, массив должен быть отсортирован. Идея метода состоит в том, что мы делим массив пополам, берем «средний элемент» с индексом middleIndex, и сравниваем с искомым. Если они равны, мы заканчиваем поиск. Если искомый элемент меньше «среднего элемента» мы отбрасываем правую часть массива, иначе — левую. После чего повторяем эти операции снова и снова, пока искомый элемент не будет найден, или пока новый отрезок не станет пустым. Если элемент не нашелся возвращаем значение -1.

public static int binarySearch(int[] array, int elementToSearch) < int firstIndex = 0; int lastIndex = array.length - 1; // условие прекращения (элемент не представлен) while (firstIndex // если средний элемент меньше // направляем наш индекс в middle+1, убирая первую часть из рассмотрения else if (array[middleIndex] < elementToSearch) < firstIndex = middleIndex + 1; >// если средний элемент больше // направляем наш индекс в middle-1, убирая вторую часть из рассмотрения else if (array[middleIndex] > elementToSearch) < lastIndex = middleIndex - 1; >> return -1; >

3. Двоичный поиск, рекурсивный подход

 public static int recursiveBinarySearch(int[] array, int firstElement, int lastElement, int elementToSearch) < // условие прекращения if (lastElement >= firstElement) < int middle = (lastElement + firstElement) / 2; // если средний элемент - целевой элемент, вернуть его индекс if (array[middle] == elementToSearch) < return middle; >// если средний элемент больше целевого // вызываем метод рекурсивно по суженным данным if (array[middle] > elementToSearch) < return recursiveBinarySearch(array, firstElement, middle - 1, elementToSearch); >// также, вызываем метод рекурсивно по суженным данным return recursiveBinarySearch(array, middle + 1, lastElement, elementToSearch); > return -1; >

4. Поиск прыжками

 public static int jumpSearch(int[] array, int elementToSearch) < int arrayLength = array.length; int jumpStep = (int) Math.sqrt(array.length); int previousStep = 0; while (array[Math.min(jumpStep, arrayLength) - 1] < elementToSearch) < previousStep = jumpStep; jumpStep += (int) (Math.sqrt(arrayLength)); if (previousStep >= arrayLength) < return -1; >> while (array[previousStep] < elementToSearch) < previousStep++; if (previousStep == Math.min(jumpStep, arrayLength)) < return -1; >> if (array[previousStep] == elementToSearch) < return previousStep; >return -1; >

Источник