You want intersection of the list while saving of first list type.

Get the common field values in the Set.

valuesToCheck=secondList.stream().map(SecondListObject::commonFiled).collect(Collectors.toList);

'''

Apply a stream on the first while filtering based on the matching common field value in the set built in the previous step.

firstList.stream().filter(x->valuesToCheck.contains(x.getCommonFiled)).collect(toList)

You got the gist.

Supposing that the class is named Foo and that the field to change is String valueToReplace with getter/setter, you could use listOne.replaceAll() in this way :

list1.replaceAll(one ->  list2.stream()
                              .filter(other -> other.getCode().equals(one.getCode())
                              .findAny()
                              .map(Foo::getValueToReplace)
                              .ifPresent( newValue -> one.setValueToReplace(newValue));
                        return one;
                )

The idea is for each elements of list1 you replace the valueToReplace field of it by the value of the first match of list2. Otherwise you do nothing.
This code is not as efficient as it could but for small lists it is perfect.
For bigger lists, using a Map to store code/valueToReplace is very welcome.

// supposing that the code are unique in each list
Map<Integer, String>  mapOfValueToReplaceByCode =
    list2.stream()
         .collect(toMap(Foo::getCode, Foo::getValueToReplace));

list1.replaceAll(one -> {
                 String newValue = mapOfValueToReplaceByCode.get(one.getCode());
                 if (newValue != null){ 
                     one.setValueToReplace(newValue);
                 }
                  return one;
                )

You need to implement the equals() and hashCode() in Faq.java

• Faq.java

    import java.util.Objects;
    import java.util.StringJoiner;
    
    public class Faq {
        private String questions;
        private String answer;
    
        public Faq(final String questions, final String answer) {
            this.questions = questions;
            this.answer = answer;
        }
    
    
        @Override
        public boolean equals(final Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            final Faq faq = (Faq) o;
            return questions.equals(faq.questions);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(questions);
        }
    
        @Override
        public String toString() {
            return new StringJoiner(", ", Faq.class.getSimpleName() + "[", "]")
                    .add("questions='" + questions + "'")
                    .toString();
        }
    }

• Main.java

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Faq> one = new ArrayList<>();
        one.add(new Faq("question 1", "answer 1"));
        one.add(new Faq("question 2", "answer 2"));
        one.add(new Faq("question 3", "answer 3"));

        List<Faq> two = new ArrayList<>();
        two.add(new Faq("question 4", "answer 4"));
        two.add(new Faq("question 5", "answer 5"));
        two.add(new Faq("question 1", "answer 6"));
        two.add(new Faq("question 7", "answer 7"));
        two.add(new Faq("question 8", "answer 8"));

        one.removeAll(two);
        System.out.println(one);
    }
}

• Output

    [Faq[questions='question 2'], Faq[questions='question 3']]

You can check listA's all element exists in listB

boolean isSame = listA.stream()
                      .allMatch(a -> listB.stream()
                                          .anyMatch(b -> b.getCode().equals(a.getCode())));

You can create a set of code from a list and check contains in O(1)

Set<String> set = listB.stream().map(e -> e.getCode()).collect(Collectors.toSet());

Then you can find in set for every list element

boolean isSame = listA.stream().allMatch(a -> set.contains(a.getCode()));

Let listOne.size() is N and listTwo.size() is M. Then 2-for-loops solution has complexity of O(M*N).

We can reduce it to O(M+N) by indexing listTwo by ids.

Case 1 - assuming listTwo has no objects with the same id

// pair each id with its marks
Map<String, String> marksIndex = listTwo.stream().collect(Collectors.toMap(ObjectTwo::getId, ObjectTwo::getMarks));
// go through list of `ObjectOne`s and lookup marks in the index
listOne.forEach(o1 -> o1.setScore(marksIndex.get(o1.getId())));

Case 2 - assuming listTwo has objects with the same id

    final Map<String, List<ObjectTwo>> marksIndex = listTwo.stream()
            .collect(Collectors.groupingBy(ObjectTwo::getId, Collectors.toList()));

    final List<ObjectOne> result = listOne.stream()
            .flatMap(o1 -> marksIndex.get(o1.getId()).stream().map(o2 -> {
                // make a copy of ObjectOne instance to avoid overwriting scores
                ObjectOne copy = copy(o1);
                copy.setScore(o2.getMarks());
                return copy;
            }))
            .collect(Collectors.toList());

To implement copy method you either need to create a new object and copy fields one by one, but in such cases I prefer to follow the Builder pattern. It also results in more "functional" code.

It is not a good idea to have side effects like setting of properties in the middle of a Stream. A better solution is to just create a Map of your User instances:

Map<Long, User> usersById =
    users.stream().collect(Collectors.toMap(User::getUserId, u -> u));

Now you can simply loop through your WorkflowStatus objects:

for (WorkflowStatus status : workflowStatuses) {
    Long userId = status.getUserId();
    Long statusId = status.getWorkflowStatusId();
    usersById.get(userId).setWorkflowStatusId(statusId);
}

You could write the following code:

products.forEach(p -> {
    ProductWebElement productElement = productElements.stream().filter(
        pe -> pe.getProductCode().equals(p.getCode())
    ).findAny().orElseThrow(() -> new AssertionError("Product: " + p.getCode() + " not found!"));
    Assert.assertEquals(p.getQuantity(), productElement.getQuantity());
}); 

For each of your products, we try to find any matching ProductElement (having the same product code).

If none is found, we throw a AssertionError. If we found one, we can assert that the quantities are the same.

If I understand correctly, this is the example scenario:

• listOne [datab] items: [A, B, C, D]
• listTwo [front] items: [B, C, D, E, F]

and what you need to get as an effect is:

• added: [E, F]
• deleted: [A]

First thing first, I would use some type adapter or extend the different types from one common class and override the equals method so you can match them by id and name

Secondly, this is very easy operations on sets (you could use set's but list are fine too). I recommend using a library: https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/CollectionUtils.html

And now basically:

• added is listTwo - listOne
• deleted is listOne - listTwo

and using java code:

• added: CollectionUtils.removeAll(listTwo, listOne)
• deleted: CollectionUtils.removeAll(listOne, listTwo)

Otherwise, all collections implementing Collection (Java Docs) also has removeAll method, which you can use.

You can make the code shorter with filter and count, but using loops is cleaner here. Streams are not always the solution.

return Arrays.asList(
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) > b.get(i)).count(),
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) < b.get(i)).count()
);

While Deadpool's answer is great, I'd be more inclined to avoid using Optional here, as there is no use for the actual value to be used.

Also, creating a Stream for each element traversing the Stream is not a good idea in terms of performance.

Set<String> products = arrayList1.stream()
                                 .map(Action::getProductSku)
                                 .map(String::toUpperCase)
                                 .collect(toSet());

boolean shouldThrowAnException = arrayList2.stream()
                                           .filter(type -> "EQUIPMENT".equals(type.getItemType()))
                                           .map(Action::getProductSku)
                                           .map(String::toUpperCase)
                                           .noneMatch(products::contains);

if (shouldThrowAnException) {
    // throw exception
}

Let's run through each part of the code. First, createSharedListViaStream:

public static List<SchoolObj> createSharedListViaStream(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
    // We create a stream of elements from the first list.
    List<SchoolObj> listOneList = listOne.stream()
    // We select any elements such that in the stream of elements from the second list
    .filter(two -> listTwo.stream()
    // there is an element that has the same name and school as this element,
        .anyMatch(one -> one.getName().equals(two.getName()) 
            && two.getSchool().equals(one.getSchool())))
    // and collect all matching elements from the first list into a new list.
    .collect(Collectors.toList());
    // We return the collected list.
    return listOneList;
}

After running through the code, it does exactly what you want it to do. Now, let's run through createSharedListViaLoop:

public static List<SchoolObj> createSharedListViaLoop(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
    // We build up a result by...
    List<SchoolObj> result = new ArrayList<SchoolObj>();
    // going through each element in the first list,
    for (SchoolObj one : listOne)
    {
    // going through each element in the second list,
        for (SchoolObj two : listTwo)
        {
    // and collecting the first list's element if it matches the second list's element.
            if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
            {
                result.add(one);
            }
        }
    }
    // We return the collected list
    return result;
}

So far, so good... right? In fact, your code in createSharedListViaStream is fundamentally correct; instead, it is your createSharedListViaLoop that may be causing discrepancies in output.

Think about the following set of inputs:
List1 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameC","SchoolZ")]
List2 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameA","SchoolX"), SchoolObj("nameB","SchoolY")]

Here, createSharedListViaStream will return the only element of the first list that appears in both lists: SchoolObj("nameA","SchoolX"). However, createSharedListViaLoop will return the following list: [SchoolObj("nameA","SchoolX"),SchoolObj("nameA","SchoolX")]. More precisely, createSharedListViaLoop will collect the correct object, but it will do so twice. I suspect this to be the reason for the output of createSharedListViaStream to be "incorrect" based on comparison to the output of createSharedListViaLoop.

The reason that createSharedListViaLoop does this duplication is based on the lack of termination of its inner for loop. Although we iterate over all elements of the first list to check if they are present in the second, finding a single match will suffice to add the element to the result. We can avoid redundant element addition by changing the inner loop to the following:

for (SchoolObj one : listOne)
    {
    for (SchoolObj two : listTwo)
    {
        if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
        {
            result.add(one);
            break;
        }
    }
}

Additionally, if you don't want duplicate Objects in your list (by location in memory), you can use distinct like so:

List<SchoolObj> result = ...;
result = result.stream().distinct().collect(Collectors.toList());

As a final caution, the above will keep the results distinct in the following scenario:

List<SchoolObj> list = new ArrayList<>();
SchoolObj duplicate = new SchoolObj("nameC", "schoolD");
listOne.add(duplicate);
listOne.add(duplicate);
list.stream().distinct().forEach(System.out::println); 
// prints:
// nameC schoolD

However, it will not work in the following scenario, unless you override the equals method for SchoolObj:

List<SchoolObj> list = new ArrayList<>();
listOne.add(new SchoolObj("nameC", "schoolD"));
listOne.add(new SchoolObj("nameC", "schoolD"));
list.stream().distinct().forEach(System.out::println); 
// prints (unless Object::equals overridden)
// nameC schoolD
// nameC schoolD

I find the current algorithm of "adding and removing" to be a streamed implementation of non-functional thinking. Rather than adding and removing, I encourage you to think in terms of joining (akin to SQL outer-joining) and filtration, which are more functional concepts. In this interpretation, your "local" collection is on the left-hand side of a left outer join, and your "remote" collection is on the right. This reduces the number of iterations from your six down to two, and produces the same output:

Customer.java

package com.stackexchange.ConsentExample;

import java.util.Collection;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public record Customer(
    Long id,
    String name,
    Integer consent
) {
    @Override
    public String toString() {
        return String.format(
            "Customer{id=%d, name='%s', consent=%d}",
            id, name, consent);
    }

    public static Stream<Customer> join(
        Collection<Customer> locals,
        Collection<Customer> remotes
    ) {
        /* Take local consent if there is no matching remote consent.
           Take remote consent if there is a match. */
        Map<Integer, Customer> remoteByConsent =
            remotes.stream()
            .collect(Collectors.toMap(
                Customer::consent, Function.identity()
            ));

        return locals.stream()
            .map(local ->
                remoteByConsent.getOrDefault(local.consent, local)
            );
    }
}

JoinTest.java

import com.stackexchange.ConsentExample.Customer;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class JoinTest {
    @Test
    public void testJoin() {
        final List<Customer>
        remotes = List.of(
            new Customer(10L, "name1", 12),
            new Customer(11L, "name2", 11),
            new Customer(12L, "name3", 14),
            new Customer(13L, "name4", 16)
        ),
        locals = List.of(
            new Customer(1L, "name1", 12),
            new Customer(2L, "name2", 13),
            new Customer(3L, "name3", 14),
            new Customer(4L, "name4", 15)
        );
        Map<Long, Customer> result =
            Customer.join(locals, remotes)
            .collect(Collectors.toMap(
                Customer::id, Function.identity()
            ));

        assertEquals(4, result.size());

        assertEquals("name1", result.get(10L).name());
        assertEquals(12, result.get(10L).consent());
        assertEquals("name2", result.get(2L).name());
        assertEquals(13, result.get(2L).consent());
        assertEquals("name3", result.get(12L).name());
        assertEquals(14, result.get(12L).consent());
        assertEquals("name4", result.get(4L).name());
        assertEquals(15, result.get(4L).consent());
    }
}

You can map from A --> String , apply the distinct intermediate operation, utilise limit(2) to enable optimisation where possible and then check if count is less than or equal to 1 in which case all objects have the same name and if not then they do not all have the same name.

boolean result = myList.stream()
                       .map(A::getName)
                       .distinct()
                       .limit(2)
                       .count() <= 1;

With the example shown above, we leverage the limit(2) operation so that we stop as soon as we find two distinct object names.