Coffee break #221. Three ways to find an element in a Java array. What is Java Thread Local and how to use it

Three ways to find an element in a Java array

Source: Asyncq This post will help you better understand the different ways to search for an element in an array in Java. Finding a specific element in a set of values ​​is a very common and frequently used operation in software development. There are different approaches to solve this problem, from simple to optimized. Let's look at them.

Input data

The input array contains primitive id data and we need to know if it contains id->3.

int[] ids = { 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 };
int inputId = 3;

Method 1 (simple)

1. We visit all the elements of the array, one element at a time.
2. Additionally, we track the state of the target element if it exists in the array.
3. As soon as we find this element, we switch the status from false to true .
4. After the loop completes, we return the status flag.

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

This solution works, but it is not very efficient. If you look at the if condition , you will realize that we are testing this condition for all elements. Let's say the element we're looking for is the first element, but our loop will still continue to run for all elements. Here it would be wiser to exit the loop as soon as we find the element. By doing this, we would save on calculations when the element we are looking for is not in the last position.

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

You can make your code even more concise by using return . We can return true as soon as we see the element we're looking for, otherwise we return false as soon as the loop completes. And we don't need to create and maintain a state variable.

for (int id : ids) {
      if (inputId == id) {
                return true;
       }
  }
  return false;

Method 2

1. We can use an ArrayList containing a method that by default looks for the target element in the list.
2. Since this method is provided by List , we need to convert our primitive array to a list.
3. We can use a single lambda string that converts a primitive to an object type and creates a list from it.
   

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

4. We can use Java 8 Stream API to make our code functional and much shorter.
5. To understand how the Stream APIs work with streams, we need to convert our input array into a stream.
6. Arrays.stream takes the input array and converts it into streams.
7. Now that we have threads, we can use many useful methods, one of which is anyMatch . It returns the element matching the predicate (id == inputId) .
8. All this makes our code much shorter and easier to read.
   

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

Method 3 (optimized)

Yes, the code shown above works and is easy to read, but we still need to visit and compare each element in the stream.

1. If memory is not an issue and we want to optimize the calculations, then one of the things we can do here is to create a set from the input array.
2. We can again use functional style code to convert the primitive array to a Set .
3. Now that we have a Set , we can search for an element over a constant period of time.

S

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

Bonus

Searching for a single element can be considered a common operation, but more common is searching for multiple elements in an array. In this case, if we don't use Set , we will have two loops and the time complexity will increase to multiply the length of the two collections. Below is an example where we convert one of the arrays as a set and then iterate over the other array and perform a search in the set operation. By doing this, we increase memory and at the same time save on calculations.

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<Integer> idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet());
return Arrays.stream(targetIds)
            .boxed()
            .filter(id -> !idsSet.contains(id))
            .mapToInt(a -> a)
            .toArray();

What is Java Thread Local and how to use it

Source: Medium In this article, we will look at Java Thread Local and how to use it effectively in your Java applications. Java Thread Local is a powerful feature that allows developers to create variables only for a specific thread. This means that each thread can have its own copy of a variable, and changes made to a variable in one thread will not affect its value in another thread.

What is Thread Local

Thread Local is a class in the Java API that allows you to create variables that are local to a specific thread. That is, each thread has its own copy of the variable, and changes made to a variable in one thread do not affect its value in another thread. This makes Thread Local an ideal solution for storing thread-specific data such as user authentication information, database connections, or any other thread-specific information.

How Thread Local Works in Java

To use Thread Local in your Java application, you first need to create an instance of the Thread Local class . This can be done by calling the ThreadLocal constructor , which will create a new instance of this class. Next, by creating a Thread Local object , you can use it to store and retrieve thread-specific data. Here's an example of how to use Thread Local in your Java application:

public class MyThreadLocalClass {
  private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

  public static void set(String value) {
    threadLocal.set(value);
  }

  public static String get() {
    return threadLocal.get();
  }
}

In this example, we created a Thread Local object called threadLocal of type String . We also created two methods: set() and get() that allow us to store and retrieve the value of the Thread Local variable . To store a value in a Thread Local variable , we simply call the set() method and pass in the value we want to store. For example, we can call MyThreadLocalClass.set("Hello, World!") to store the string “Hello, World!” in the Thread Local variable . To get the value of the Thread Local variable , we simply call the get() method . For example, we can call String value = MyThreadLocalClass.get() to get the value of the Thread Local variable .

Recommendations for working with Thread Local

Although Thread Local can be a powerful tool in your Java applications, it is important to use it correctly to avoid potential problems. Here are some guidelines to keep in mind when using Thread Local :

1. Use Thread Local only when necessary: ​​only for thread-specific data. If the data is not thread-specific, it must be stored in another way.
2. Avoid excessive memory usage: Thread Local can consume a significant amount of memory if not used carefully. Be sure to clear Thread Local variables when they are no longer needed to avoid excessive memory usage.
3. Use Thread Local with caution in multi-threaded environments: it is important to understand the potential risks and limitations. Be sure to test your code thoroughly to ensure that Thread Local works as expected in your specific environment.

Conclusion

Java Thread Local is a great tool that allows developers to create variables only for a specific thread. Using Thread Local , you can store thread-specific data, such as user authentication information, database connections, or other thread-specific information. Although Thread Local can be a powerful tool, it is important to use it correctly to avoid potential problems. By following best practices and testing your code, you can use it effectively to improve the performance and reliability of your Java applications.