Filter contents of list with entries matching entire contents of another list Java streams

I may be not able to search properly but this is a query in theory is simple. I have list of arrays containing numbers. I want to filter list which match all entries from another list.

Say following is my list
{1,2,3},{1,2},{1},{2},{3}, {2,3}

Now If my criteria list is {1,2} I should get following result
{1,2,3},{1,2}

Basically I am looking for all match for criteria list. I tried using contains in predicate but its returns like or condition

//internally it creates array 
products.add(new ProdData(344, 766));
products.add(new ProdData(344,123));
products.add(new ProdData(344,766,123));

List<Integer> matchingVolumes = new ArrayList<>();
    matchingVolumes.add(344);
    matchingVolumes.add(766);
    
products.stream()
   	.map(ProdData::getChemVolume)
   	.filter(p -> {return matchingVolumes.contains(p);})
   	.collect(Collectors.toList());

I want to match records # 1 and 3

products is list of ProdData objects from which chemVolume is the field I am trying to match the criteria. Order of entries does not matter.

if you mean that you want a code that compares each time your criteria list with the parameter from the other list (and print it if it doesn't match).
I suggest you use Streams(for Java 8)

static Boolean x = false ;
public static void main(String[] args) {
	
	List<List<Integer>> list1 = new ArrayList<>(Arrays.asList(Arrays.asList(1,2,3),Arrays.asList(1),Arrays.asList(1,2),Arrays.asList(2),Arrays.asList(3),Arrays.asList(3,2)));
	List<Integer> list2 = new ArrayList<>(Arrays.asList(1,2));
	 
	
	Consumer<List<Integer>> check = list->{if(list.equals(list2)) x = true ;};
	Consumer<List<Integer>> printList =  ListPrinted ->{if(x==false){ System.out.print(ListPrinted); }} ;

	list1.stream().peek(check).forEach(printList);
	
	 
}

it works, I compiled it

you may ask, why the Boolean x !!? you can just consider it as a condition to stop typing !!
why I make it static and a global variable ?? :
because in lambda-expression, all local variables must be final(and we don't want that !), and we are working under one class (we don't have several objects to work with ) so I use static ( a variable is static: it is a class-variable ).

I hope you understand.

I think you want something like this. It is easiest if your underlying arrays are objects, so that you can create Lists out of them. If they are primitives, you might want to use Arrays.binarySearch in the filter, but then you will have to do a Arrays.sort in your stream before the filter:

Integer[][] values = {{1,5,3},{1,3},{5,1},{3,5}};
Integer[] filter = {3,5};

Arrays.stream(values)
      .map (x -> List.of(x))
      .filter( x -> Arrays.stream(filter)
                          .allMatch(y -> x.indexOf(y)>=0))
      .forEach(System.out::println);

// output:
// [1, 5, 3]
// [3, 5]

You can create List<List<Integer>> and try to iterate your main list and check if all element from filter list is matched with mainList's subList.

class Sample {
    public static void main(String[] args) {
        List<List<Integer>> mainList = List.of(List.of(1, 2, 3), List.of(1, 2), List.of(2));
        List<Integer> filter = List.of(1, 2);
        System.out.println("  " + mainList.stream().filter(integerList -> isListContains(filter, integerList)).collect(Collectors.toList()));
    }

    public static boolean isListContains(List<Integer> filter, List<Integer> mainList) {
        return filter.stream()
                .allMatch(
                        mainList.stream()
                                .collect(Collectors.toSet())
                                ::contains);
    }

}

You can implement same by using Stream and filter criteria as above.
And for filter out you can use filter.stream()allMatch( You can get more idea about allMatch from here.

What you seem to be looking for is:

.filter(p -> p.getAllChemVolumes().containsAll(matchingVolumes))

where you would need to define the getAllChemVolumes method within ProductData to return a Collection<Integer> based on the efficiency you seek.