Q:

Lambda can only be used with functional interface?

I did this:
public class LambdaConflict
{
    public static void main(String args[]){
        //*
        System.out.println(LambdaConflict.get(
            (str) -> "Hello World!! By ME?"
        ));
        /*/
        System.out.println(LambdaConflict.get(new Intf<String> (){
            @Override public String get1(String str){
                return "Hello World!! By get1 " + str;
            }
        }));
        /*****/
    }

    public static String get(Intf<String> i, boolean b){
        return i.get1("from 1");
    }
}

interface Intf<T>
{
    public T get1(T arg1);

    public T get2(T arg1);
}

and get this exception:

incompatible types: Intf is not a functional interface
          multiple non-overriding abstract methods found in interface Intf
      Note: Some messages have been simplified; recompile with -Xdiags:verbose to get
      full output
      1 error

Is there any condition that I can't use lambda to replace anonymous class?

A:

No. There is no way to "overcome" this. A functional interface must have only one abstract method. Your interface has two:
interface Intf<T> {
    public T get1(T arg1);
    public T get2(T arg1);
}

Note: You don't need to annotate your interface as mentioned in comments. But you can use the @FunctionalInterface annotation to get compile time errors if your interface is not a valid functional interface. So it brings you a little bit more security in your code.
For more see e.g. http://java.dzone.com/articles/introduction-functional-1

A:

Just for reference and to enrich the answers already given: 
As per JSR-335: Lambda Expressions for the Java Programming Language, in section Lambda Specification, Part A: Functional Interfaces it says:

A functional interface is an interface that has just one abstract
  method (aside from the methods of Object), and thus represents a
  single function contract. (In some cases, this "single" method may
  take the form of multiple abstract methods with override-equivalent
  signatures inherited from superinterfaces; in this case, the inherited
  methods logically represent a single method.)

So, what you need is to either provide a default implementation for one of your methods or put one of your methods in a different interface.

A:

Think about it:

How should the compiler know if you want to override get1 or get2?
If you only override get1, what will be get2's implementation? Even the code you commented out won't work because you don't implement get2...

There are reasons for this limitation...

