Lambda expressions are only usable with functional interface as said by Eran but if you really need multiple methods within the interfaces, you may change the modifiers to default or static and override them within the classes that implement them if necessary.

public class Test {
    public static void main(String[] args) {
        I1 i1 = () -> System.out.println(); // NOT LEGAL
        I2 i2 = () -> System.out.println(); // TOTALLY LEGAL
        I3 i3 = () -> System.out.println(); // TOTALLY LEGAL
    }
}

interface I1 {
    void show1();
    void show2();
}

interface I2 {
    void show1();
    default void show2() {}
}

interface I3 {
    void show1();
    static void show2 () {}
}

Inheritance

You shouldn't forget the inherited methods.

Here, I2 inherits show1 and show2 and thus can not be a functional interface.

public class Test {
    public static void main(String[] args) {
        I1 i1 = () -> System.out.println(); // NOT LEGAL BUT WE SAW IT EARLIER
        I2 i2 = () -> System.out.println(); // NOT LEGAL
    }
}

interface I1 {
    void show1();
    void show2();
}

interface I2 extends I1 {
    void show3();
}

Annotation

To make sure your interface is a functional interface, you may add the following annotation @FunctionalInterface

@FunctionalInterface <------- COMPILATION ERROR : Invalid '@FunctionalInterface' annotation; I1 is not a functional interface
interface I1 {
    void show1();
    void show2();
}

@FunctionalInterface
interface I2 {
    void show3();
}

The Java Lang. Spec. states that the "restriction to effectively final variables prohibits access to dynamically-changing local variables, whose capture would likely introduce concurrency problems".

In order to address this problem you can use atomic references or atomic types, e.g., AtomicBoolean.

BTW: It would have been helpful for others to provide an executable example of the problem and the solution. Something like this makes it easier to help:

import org.junit.jupiter.api.Test;

import java.util.concurrent.atomic.AtomicBoolean;

import static org.junit.jupiter.api.Assertions.*;

public class FunctionalInterfaceProblem {
    public static String EXCEPTION_MESSAGE = "Value not 0 or 1";

    @java.lang.FunctionalInterface
    interface SomeInterfaceWithBoolean<T> {
        boolean calculate(T i) throws IllegalArgumentException;
    }

    @Test
    public void testWihArray() {
        boolean[] outcome = new boolean[1];

        SomeInterfaceWithBoolean<Integer> result = i -> {
            if(i == 1){
                outcome[0] = true;
            } else if (i == 0){
                outcome[0] = false;
            } else {
                throw new IllegalArgumentException(EXCEPTION_MESSAGE);
            }
            return outcome[0];
        };

        assertFalse(result.calculate(0));
        assertTrue(result.calculate(1));
        Throwable exception = assertThrows(IllegalArgumentException.class, ()->{result.calculate(2);} );
        assertEquals(EXCEPTION_MESSAGE, exception.getMessage());
    }

    @java.lang.FunctionalInterface
    interface SomeInterfaceWithAtomicBoolean<T> {
        AtomicBoolean calculate(T i) throws IllegalArgumentException;
    }

    @Test
    public void testWihAtomicBoolean() {
        AtomicBoolean outcome = new AtomicBoolean(false);

        SomeInterfaceWithAtomicBoolean<Integer> result = i -> {
            if(i == 1){
                outcome.set(true);
            } else if (i == 0){
                outcome.set(false);
            } else {
                throw new IllegalArgumentException(EXCEPTION_MESSAGE);
            }
            return outcome;
        };

        assertFalse(result.calculate(0).get());
        assertTrue(result.calculate(1).get());
        Throwable exception = assertThrows(IllegalArgumentException.class, ()->{result.calculate(2);} );
        assertEquals(EXCEPTION_MESSAGE, exception.getMessage());
    }

}