Any way to make this stream more efficient?

How would one optimise this without adding value into the new ArrayList instead just having the original list updated?

 String filterval = filter.toLowerCase();
 ArrayList<String> filtredArr = new ArrayList<String>();

                        listArray.forEach(
                                valueText -> {
                                        String val = valueText.toLowerCase();
                                    if (val.startsWith(filterval) || val.contains(filterval))
                                        filtredArr.add(valueText);
                                    else {
                                        Arrays.stream(valueText.split(" ")).forEach(
                                                singleWord -> {
                                                    String word = singleWord.toLowerCase();
                                                    if(word.startsWith(filterval) || word.contains(filterval))
                                                        filtredArr.add(valueText);
                                                }
                                        );
                                    }
                                });

When using streams, it is best not to modify the source of the stream while the latter iterates over the former. (See this for instance.)

Regarding readability and making idiomatic use of stream operations, your code is almost indistinguishable from a plain old for loop (and I would advise you to change it to that if you only use streams to do a forEach, but you could modify it to use a chain of shorter and more "atomic" stream operations, as in the following examples.

• To get the list of strings in which at least one word contains filterval:

  List<String> filtered = listArray.stream()
                                 .filter(str -> str.toLowerCase().contains(filterval))
                                 .collect(Collectors.toList());
  

• To get the list of strings in which at least one word starts with filterval:

  List<String> filtered =
        listArray.stream()
                 .filter(str -> Arrays.stream(str.split(" "))
                                      .map(String::toLowerCase)
                                      .anyMatch(word -> word.startsWith(filterval)))
                 .collect(Collectors.toList());
  

• To get the list of words (in any of the strings) that contain the filter value:

  List<String> filteredWords = listArray.stream()
                                      .map(String::toLowerCase)
                                      .flatMap(str -> Arrays.stream(str.split(" ")))
                                      .filter(word -> word.contains(filterval))
                                      .collect(Collectors.toList());
  

(I'm assuming listArray, which you don't show in your code snippet, is a List<String>.)

Notes

• The condition val.startsWith(filterval) || val.contains(filterval) is completely equivalent to val.contains(filterval). The reason is, if a string starts with filterval, it must also mean that it contains it; one implies the other.
• There's no need to compute the lowercase versions of single words since you've already lowercased the whole string (so any words within it will also be lowercase).
• Instead of treating single words and space-separated strings separately, we can apply split to all of them and then "concatenate" the sequences of words by using filterMap.

Minimal, complete, verifiable example

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


public class Main {
    public static void main(String[] args) {
        String filterval = "ba";
        List<String> listArray = List.of("foo", "BAR", "spam EGGS ham bAt", "xxbazz");


        List<String> filtered1 = listArray.stream()
                                          .filter(str -> str.toLowerCase().contains(filterval))
                                          .collect(Collectors.toList());

        List<String> filtered2 =
                listArray.stream()
                         .filter(str -> Arrays.stream(str.split(" "))
                                              .map(String::toLowerCase)
                                              .anyMatch(word -> word.startsWith(filterval)))
                         .collect(Collectors.toList());

        List<String> filtered3 = listArray.stream()
                                          .map(String::toLowerCase)
                                          .flatMap(str -> Arrays.stream(str.split(" ")))
                                          .filter(word -> word.contains(filterval))
                                          .collect(Collectors.toList());

        System.out.println(Arrays.toString(filtered1.toArray()));
        System.out.println(Arrays.toString(filtered2.toArray()));
        System.out.println(Arrays.toString(filtered3.toArray()));
    }
}

Output:

[BAR, spam EGGS ham bAt, xxbazz]
[BAR, spam EGGS ham bAt]
[bar, bat, xxbazz]