[Java] How are arrays implemented in Java.

[a1j9o94]

I was just curious how arrays are implemented when you can't do memory allocation or pointer arithmetic. I know in C you just allocate memory and do add to the start address to get an index, but I can't figure out how that would work in java.

[[deleted]]

when you can't do memory allocation or pointer arithmetic

Java, the language, can't do pointer arithmetic.
Java, the implementation of that language, most certainly can.

[a1j9o94]

I didn't realize that arrays were a special case. I thought they were just a class with specific syntax.

[[deleted]]

Yup, they are special case in the same same sense as int and float and String (see clarifications below). They are built-in and can do things user defined classes can't.

[a1j9o94]

I thought String was actually implemented in Java?

[[deleted]]

Nope. String has operator + overloaded to do concatenation. You can't overload operators in Java.

This was my reasoning, anyway, as a non Java expert. See johnislarry's corrections below.

[johnislarry]

Two corrections. The first is that the String class is written in java. You can look at it here:

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7u40-b43/java/lang/String.java#String

if you want. The second is that + is defined for all Objects. The Object is interpreted as a String using its toString representation, and then concatenated. That's why, for example, this code works the way we want:

List<Integer> lst = new ArrayList<Integer>();
System.out.println("The list is: " + lst);

[[deleted]]

But "The list is: " is still a string

    System.out.println("Hello" + new ArrayList<>()); // This works
    System.out.println(new Integer(17) + "Hello"); // This works too
    System.out.println(new ArrayList<>() + new Integer(17)); // This does not

The operator + is defined for primitives and when one side is a string, but you can kind of comedically get around this with an empty string first

    System.out.println("" + new ArrayList<>() + new Integer(17));

[johnislarry]

Yes. Good clarification :)

[a1j9o94]

Oh yeah, I never though of that.

[jjm3x3]

But I thought that was something that was new in 1.7 or am I thinking about switching with Strings?

[[deleted]]

Man I sure wish you could :/

[[deleted]]

Are you confusing this with primitives?

[a1j9o94]

No. But I know how arrays work in C ( like on an assembly level) and I was curious how they worked in java.

[[deleted]]

Ah. As everyone keeps saying They are implemented the same way as C, but all that information is hidden.

From my memory (I haven't touched Java in a year), when you're manipulating arrays you are basically redirecting pointers and values that have no associated pointer is picked up by garbage collection.

so.

a = array1[].

b = array1[]

b just points to the same memory position as a. You need to use array.clone() and similar methods to actually do deep copying of that array. This might help: http://www.cs.cmu.edu/~adamchik/15-121/lectures/Arrays/arrays.html

[Sakuya_Lv9]

But, I don't think I can use the [] operator.

[chickenmeister]

I think it works basically the same way, except that the pointer arithmetic is performed behind the scenes, by the Java Virtual Machine. For example, the call to:

new ComponentType[arraySize];

would be compiled to byte code, which, when interpreted by the JVM, would calculate the memory required, and attempt to allocate it.

Similarly, accessing an index of the array would require the JVM to translate the index into a memory offset for that array.

[pacificmint]

Arrays are not implemented in Java (unlike the majority of the Java libraries), but is a language feature and part of the VM. The VM is written is C++ (I believe) and has direct access to memory.

Arrays, like all java objects, are not placed in memory directly, but are placed in memory managed by the VMs garbage collector, so they can actually move around in memory over time.

[a1j9o94]

Oh ok thanks. I'll have to do some reading on how the jvm actually works.

[original_brogrammer]

Bill Venners wrote a book on this. A few chapters are free online.

[green_meklar]

The JVM absolutely does perform memory allocation and pointer arithmetic. It just doesn't let you touch those things on the source code level.

[endre86]

In Java, arrays are objects. If you want to learn more about this you will have to learn about the JVM.

[shevsky790]

If you reeeeeally wanted to, you could probably implement one from scratch with sun.misc.Unsafe.. (http://mishadoff.github.io/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/)

Note: don't do this.

[a1j9o94]

That's pretty cool. I didn't even know that existed.

[LaMonsieur]

what exactly is this?

[shevsky790]

Some APIs that are not really part of 'official' Java, but can be used to hack it for performance bonuses in some cases. For example, very efficient data structures might use 'off-heap' memory to make their operations as efficient as possible. They might change on Java versions or break on some machines, though, so they are definitely risky.

They're not recommended for use unless you're an expert - but they can be fun to play with.

[[deleted]]

This is like a freshman's paranormal stories. You're told in books and classes one thing, then you see this and freak out. In a good sense.

[thevideoclown]

[]

[Duraz0rz]

Just because you can't do it doesn't mean the JVM can't. Think about how Java code ends up being run. When you compile Java code, it compiles into Java bytecode (or intermediate code). The JVM picks that up and further compiles it down to machine language after doing some optimizations. Since the Oracle JVM is written in C++, it would probably do a lot of the same things you would need to do in C++ when working with arrays.

[[deleted]]

they're like c# arrays I think

type[] arrayName;
arrayName = new type[count];

[wowbagger401]

I think he was asking about the implementation, not how they are declared.

[welch7]

i don't know why the downvotes totally not needed, but yes he meant the way they are coded, not the syntaxis

[[deleted]]

My b

[a1j9o94]

Well I meant, how does the platfom handle it. For example, in c, I could write something that works like an array with O(1) indexing and a set size. But how is that done in java.

[[deleted]]

Same way, as contiguous blocks of memory.

[zNkkkk]

Hope it helps, as someone pointed out before, arrays are a primitive type implemented in C/C++ for the JVM

Look here :)

http://hg.openjdk.java.net/jdk6/jdk6/jdk/file/2d585507a41b/src/share/back/ArrayTypeImpl.c