How does using a new keyword in constructor parameter works in java?

I was learning spring security and came across this class:

   org.springframework.security.core.userdetails.User$UserBuilder

here I was confused about two things:

1. what is the use of the $ sign, is it just a naming convention or does it signifies something functionally?

2. In the same class there is a constructor like this:

   User$UserBuilder(new org.springframework.security.core.userdetails.User(){} x0) {
}

   here we are using the new keyword for the parameter. what does it mean?

I tried to search for it on the web but no luck

You're looking at decompiled code and trying to learn.

That is a very bad idea; decompilers aren't maintained particularly well, and as a result produce some weird constructs, often straight up illegal (such as this - it wouldn't compile). If you know the details about the java class file format you can figure it out, but, that's... fairly complicated to learn and rarely useful, so, not something you should be learning as a newbie or even a medium-level programmer.

Given:

package com.foo;

class Bar {
  class Baz {
    public Baz() {}
  }
}

turns into 2 classfiles when you compile it, because at the class file level, inner classes simply aren't a thing. javac makes it work by generating lots of sugar to make it look like they exist. It boils down to having 2 separate classes:

package com.foo;

class Bar {
}

and

package com.foo;

class Bar$Baz {
  private final Bar this$Bar;
  public Bar$Baz(Bar this$Bar) {
    this.this$Bar = this$Bar;
  }
}

After all, from a non-static inner class, you can refer to instance methods from your outer class. You have to call those on something, so you need an instance of your containing class, that's what that this$Bar field is all about.

What you're looking at, is the result of a crappy decompiler that decompiled:

new User().new User.UserBuilder();

Which is valid java but very rarely used - it's constructing a new non-static inner class (User.UserBuilder) and explicitly passing along the instance of the outer class (User) that should serve as its container. Normally, you'd be inside some non-static context within User and just invoke new UserBuilder() which is equivalent to just this.new UserBuilder().

spring is open source, thus, there is very much no point in your approach. Just.. check the source: source of User.java.

Note that the UserBuilder class is in fact static so evidently the decompiler got thoroughly confused. Given that it is static, there is no 'instance of the outer' to refer to, and hence no need for the very strange instanceOfOuter.new Inner() syntax, and yet the decompiler thought, evidently, that was happening (there is no constructor of UserBuilder that accepts a User object; not in the java code, and not in the class file either).

It might be that you're looking at the decompiled code or something (why would anyone in spring security team use a parameter called x0)
I believd you refer to the User class source code

The dollar sign basically means that the class UserDetails is defined inside the class User (line 326 in the source file)
In general a dollar character is a valid symbol to name something in Java (for instance one can name the variable a$b
But java compiler uses this to show that one class is defined under another.