Redundancy in programming Java

As I learned Java over the years, my goal (and my carrying point) in programming has been, "Use the most efficient, non-lengthy way" to code. I have found that enough to keep me going, and my projects result in beautiful, small applications. Although, there is a lot of redundancy. I am actually wanting to create a compiler which does these things. By the end, I want to show you guys a few ways Java can change in Java 9 and minimalism the number of characters you have to type, using different examples. Thanks for reading! :)

Point 1: Parameter Declarations
Example:
void example(int a, int b, int c, int d, String e, String f, boolean g) {}
Reason:
Look at all those integers! Too bad we can't do... It is of everyone's best interest to do this.
void example(int a, b, c, d, String e, f, boolean g) {}


Point 2: Field declarations
Example:
public static final String s = null, d = "asd", e = "foo";
public static final int a = 1, b = 2, c = 3;
Reason:
Do we really need to type public static final again and again when we are making fields, especially Enumeration-like classes?
public static final (
String s = null, d = "asd", e = "foo";
int a = 1, b = 2, c = 3;
)

Point 3: Imports
Example:
import java.lang.whatever.classa;
import com.somesite.wasd.classb;
import java.sun.dontusethis.time;
etc.
Reason:
We don't need to declare import thousands of times just to get classes we need. It would be an added bonus if we could take portions of paths to the classes and cut it down.
Example:
import
java.lang.whatever.classa;
com.somesite.wasd.classb;
sun.dontusethis.time;
Example 2:
import
/java.lang
whatever.classa;
somesite.wasd.classb;
/sun.dontusethis.time;
To be more descriptive here, the '/' would represent a change in area of import. Since java.lang points to a package, rather than a class, it would be logical to indentify this change. Since / is on a class called time, it would not be redundant to utilize this, as it would break the scope of java.lang packages and classes.

I hope you guys see the added bonus in these 3 points. They reduce the effort you have to type. Since imports are automated, it could help the IDE you are using somewhat by adding implied logical sorting of key-value pairs when iterating. When declaring fields, it would be much simpler just typing some text out that means what the rest of fields will be. We don't need to type int thousands of times in a function, especially when we can't tuple that.