Why builder lost type?

When I try something like this

public class Example<T> {
private T value;
private Example() {
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public static <T> Builder<T> builder() {
return new Builder<>();
}
public static class Builder<T> {
public Example<T> build() {
return new Example<>();
}
}
public static void main(String[] args) {
Example<String> example = Example.builder().build();
example.setValue("test");
System.out.println(example.getValue().toUpperCase());
}
}

I get an error

Example.java:27: error: incompatible types: Example<Object> cannot be converted to Example<String>
Example<String> example = Example.builder().build();

But when I add type to arguments of builder method, everything works fine

public static <T> Builder<T> builder(T type) {
return new Builder<>();
}

Why? And how I can rid off this dummy type argument?

Bonus question: How to pass complex type to the method like this?

public static <T> Builder<T> builder(Class<T> type) {
return new Builder<>();
}
Example<Optional<String>> example = Example.builder(???).build();

UPDATE: It's only an example. The real-life application will have several builders creating each other on different stages of the building process and of course, they will have methods accepting generic type. I hope there is a way to help the compiler infer types. I even agree to tricks with reflection, if any exist and they can help me to get a beautiful DSL.

Example is a raw class, so implicitly T is Object. You can specify the generic type when calling the method by putting it in angle-brackets (<>) before the method call:

Example<String> example = Example.<String>builder().build();
// Here --------------------------^

The compiler can infer that the Example you are trying to create is an Example<String>, but it can't infer that the Builder returned by builder() method should be a Builder<String>.

You can help the compiler by breaking the statement into two statements:

Builder<String> builder = Example.builder();
Example<String> example = builder.build();

Or by specifying the type of Builder you expect from the builder() method:

Example<String> example = Example.<String>builder().build();

if you don't mind an Unchecked assignment warning you could add just the following change:

    public static Builder builder() {
return new Builder<>();
}

EDIT Start:

Additionally, if you want to omit the warning you can change the Builder class into:

    public static class Builder {
private <T> Example<T> build() {
return new Example<>();
}
}

and change the static Builder method to:

public static Builder builder() {
return new Builder();
}

EDIT End.

and then you can use it like this:

Example<String> example = Example.builder().build();