Reading about the Google v Oracle case, I came across these questions (apparently from the presiding Judge)


  ...
  Is it agreed that the following is true, at least as of 1996?
  
  The following were the core Java Application Programming Interface: java.lang, java.util and java.io.
  
  Does the Java programming language refer to or require any method, class or package outside the above three?
  ...  


source: Groklaw

There are obviously lots of legal ramifications, Google and Oracle probably disagree on some points, and I don't care.  Leave law to the lawyers.

However, I suspect there's an interesting bit of history in here.

My question is (as someone who first did any Java coding around 2001 in version 1.3), in version 1.0 of Java was anything required outside of java.lang, java.util, and java.io to compile a valid Java program?

As an example (using C# 5.0), the await keyword is dependent upon Task<T> GetAwaiter() (amongst other things).  The compiler couldn't function to spec without that class.

Equivalently, were there any core runtime features (like ClassLoader*) that were dependent on other packages?

I'll admit I ask out of curiosity, exactly what is necessary for minimum-viable Java (the language, ignoring all the legal bits around it) is interesting.

*I am assuming that ClassLoader was even a feature in Java 1.0, it's part of the spec in 7.0 and presumably many earlier versions.

Per Wikipedia, the first formally released version of Java was 1.0.2, on Jan 23 1996.


  The first stable version was the JDK 1.0.2. is called Java 1


There's an archive of Java 1.0.2 and all related documentation here:


  
  JDK 1.0.2 API reference (book format)
  JDK 1.0.2 API reference (javadoc format)
  Java tutorial
  Java language specification (link broken, wayback'd here)
  Java virtual machine specification
  


There appears to be a download of the JDK 1.0.2 bits here

http://www.pascal-man.com/download/download-jdk.shtml

It works for me at the time of writing.



BEHOLD THE RAW UNMITIGATED POWER OF JAVA 1.0.2



In the language spec, the following classes are referred to (single citation, not exhaustive citations):


Class (section 4.3.1)
String (section 4.3.1)
Object (section 4.3.2)
Random (section 4.4)
Thread (section 17.2)
ThreadGroup (section 17.2)
Throwable (section 11)
Error (section 11.2)
loads and loads of errors, all under java.lang (section 11.5.2.1 - 11.5.2.2)
RuntimeException (section 11.2.1)
the "Array classes", [I, and so on (section 10.8)


... at which point I stopped looking because, technically, [I, et. al. aren't in the java.lang, java.util, or java.io packages.

Example:

class Test {
  // Compare namespaces of built-ins object and int[]
  public static void main(String[] args){
    int[] arr = new int[0];
    Object obj = new Object();

    Class arrClass = arr.getClass();
    Class objClass = obj.getClass();

    Class arrSuper = arrClass.getSuperclass();

    System.out.println("plain jane Object - " + objClass.getName());
    System.out.println();
    System.out.println("int[] - "+arrClass.getName());
    System.out.println("super of int[] - "+arrSuper.getName());
  }
}


Outputs



Behavior is consistent between modern and 1.0.2


