Arrays.stream(values)
      .mapToObj(i -> Integer.toUnsignedString(i, 16))
      .forEach(System.out::println);

You must assign the lambda expressions to variables of the functional interface types first.

Otherwise the compiler cannot infer the types of these lambda expressions.

I0 i0 = (int a, int b) -> a + b;
I1 i1 = (double d) -> (int) (d * 2);
List<Object> test = Arrays.asList(
    i0,
    i1
);

That said, I'm not sure what's the point of storing these lambda expressions in a List<Object>. You can't use them without casting them back to the individual functional interface types.

Yes, you can do this by creating a DoubleStream from the array, filtering out the negatives, and converting the stream back to an array. Here is an example:

double[] d = {8, 7, -6, 5, -4};
d = Arrays.stream(d).filter(x -> x > 0).toArray();
//d => [8, 7, 5]

If you want to filter a reference array that is not an Object[] you will need to use the toArray method which takes an IntFunction to get an array of the original type as the result:

String[] a = { "s", "", "1", "", "" };
a = Arrays.stream(a).filter(s -> !s.isEmpty()).toArray(String[]::new);

Sure - I don't know how useful it is, but it's certainly doable:

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class Test
{
    public static void main(String[] args)
    {
        Supplier<Test> supplier = () -> new Test();
        List<Test> list = Stream
            .generate(supplier)
            .limit(10)
            .collect(Collectors.toList());
        System.out.println(list.size()); // 10
        // Prints false, showing it really is calling the supplier
        // once per iteration.
        System.out.println(list.get(0) == list.get(1));
    }
}

You can do it like this,

Optional<Preset> optional = Arrays.stream(presets)
                                  .filter(x -> "MyString".equals(x.getName()))
                                  .findFirst();

// Check whether optional has element you are looking for
if (optional.isPresent()) {
    Preset p = optional.get(); // Get it from optional
}

You can read more about Optional here.

I see no problem with using a loop for this. That's how I'd likely do it.

You can do it with a stream using reduce:

str = Arrays.stream(FORMAT)
    .reduce(
        str,
        (s, country) -> s.replaceAll(country + "\\s", Matcher.quoteReplacement(simbol)));

Or, easier:

str = str.replaceAll(
    Arrays.stream(FORMAT).collect(joining("|", "(", ")")) + "\\s",
    Matcher.quoteReplacement(simbol));