Isn't there a simple way to "include" in Java?

Question

When logically something seems as if it would be dead simple, then it turns out to be completely convoluted.

I have not used Java much, so please forgive my ignorance. Here is what I am trying to do:

I have a nice clean algorithm in one .java file, and I want to feed it from an initialized array. The array contains over 40,000 elements, so I want it in a separate file all by itself. How do I do this? Isn't there a quick way to just say {insert contents of filename.txt here}?

Answer 1

File1.java:

class File1 {
    static int[] bigArray = {1,2,3};
}

File2.java:

class File2 {
    static int main(String[] args) {
        doSomeThingWith(File1.bigArray);
    }
}

You may also use static import to be able to use bigArray without prepending File1..

Answer 2

The basic units of code in Java are classes, not files. Importing files simply makes no sense; it's the wrong level of abstraction. Stop thinking about files; think about code in different classes and how you can call that code. What file the class is defined in (and it doesn't have to be a file at all!) does not matter.

BTW, with 40,000 elements, you may run into limitations on the size of a method if you define them directly in code. It would be better to put the data into a text file and parse that. That way, you also don't have to recompile anything when you change the data.

An alternative to writing a parser for the file would be to calculate the data once, put it into an appropriate Java data structure (array, List, Map, whatever) and then serialize that into a file using ObjectOutputStream. Note that this will cause problems if the data is stored in classes that later change their signature.

Answer 3

Make the algorithm method static. That way you can call it by Object whateverItReturns = NameOfClass.nameOfStaticMethod(args);

Content import can generally be done in multiple ways, depending on exactly what kind of content you want to export. How you want to update it is the key to selecting the correct way.

Answer 4

No, there isn't any #include facility in Java. The preprocessor known from the C world was not included, which—after a while—turns out to make more robust programs (in my opinion).

You need to create a new class containing what you want, and then refer to it. Java 6 allows for static imports which makes this almost transparent.

Note, that you may risk reaching the maximum byte code size of a single class. I believe it is 64 KB.

Answer 5

Please read Michael Borgwardt's answer first. It’s like all I wanted to say anyhow.

If you need some prime numbers, you can just calculate them on the fly:

/** Sieve of Eratosthenes. Return prime numbers <= max */
static Integer[] getSoE(int max) {
    if (max < 1)
        return new Integer[0];

    BitSet sieve = new BitSet(max / 2);
    ArrayList<Integer> list = new ArrayList<Integer>();
    if (max > 1)
        list.add(2);
    if (max > 2)
        list.add(3);

    for (int i = 5, f = 1; i <= max; i += 3 - f, f = -f)
        if (sieve.get(i >> 1) == false) {
            for (int add, j = i + (add = i << 1); j < max; j += add)
                sieve.set(j >> 1, true);
            list.add(i);
        }

    return list.toArray(new Integer[0]);
}

Assuming you want to read them in from a file:

static Integer[] getPrimeFromFile(String Filename) throws FileNotFoundException {
    ArrayList<Integer> list = new ArrayList<Integer>();

    Scanner sc = new Scanner(new File(Filename));
    while (sc.hasNext())
        list.add(sc.nextInt());
    sc.close();

    return list.toArray(new Integer[0]);
}

Answer 6

It is a deliberate design decision in the Java platform to not preprocess .java files. This keeps things simple, and simple is what Java is all about.

As others have suggested, use a static import. Sometimes it feels limiting, but it is wonderful not having to debug a C-style macro hell.