What is inside code for array.length() in Java?

What is stored in 10th location of array say ... my basic question is how will JVM determine end of array, is it when a null is encountered parsing array or when a garbage value is encountered? what is inbuilt code of array.length() function?

Welcome C/C++ programmer :-)

Java uses a different paradigm than C/C++ for arrays. C/C++ uses the terminator/sentinel a.k.a. "garbage") value like NULL to indicate the end of the array. In Java, arrays are more like objects with a special "instance variable"-like variable length that indicates how many slots there are in the array. This special "instance variable" is set at the array's creation and is read-only. Its accessible by saying array.length.

Java expects the code to know when to stop at the end of the array by making sure they don't specify an index greater than length - 1. However, the JVM checks every access to the array for security reasons just in case. If the JVM finds an array index that is less than 0 or greater than length - 1, then the JVM throws an IndexOutOfBoundsException.

What is stored in 10th location of array

Since we can always check the length, there is no need for a marker at the end of the array in Java. There isn't anything special after the last item in the array (it likely will be some other variable's memory).

if I were to print elements without using array.length()

for(int a: array) {
    // code of loop body here
}

This code is magically transformed by the compiler to:

for (int i = 0; i < array.length; i++) {
    int a = array[i];
    // code of loop body here
}

However, the i index variable isn't accessible to the user's code. This code still uses array.length implicitly.

Arrays are objects with a length field. While looping, Java loads the length field and compares the iterator against it.

See 10.7 Array Members in the JLS

Internally, the JVM can track the length of an array however it sees fit. There's actually a bytecode instruction called arraylength that the Java compiler emits whenever you try to get the length of an array, indicating that it's up to the JVM to determine the best way to track the length of an array.

Most implementations probably store arrays as a block of memory whose first entry is the length of the array and whose remaining elements are the actual array values. This allows the implementation to query the length of the array, along with any value in the array, in O(1). If the implementation wanted to, though, it could store the elements followed by a sentinel value (as you've suggested), but I don't believe that any implementations do this because the cost of looking up the length would be linear in the size of the array.

As for how the foreach loop works, the compiler translates that code into something like this:

for (int i = 0; i < arr.length; ++i) {
    T arrayElem = arr[i];
    /* ... do work here ... */
}

And finally, with regards as to what the 10th element of a 10-element array is, there's no guarantee that there's even an object at that location. The JVM could easily allocate space for the array in a way where there is no tenth element. Since you can't ever actually get this value in Java (it would throw an exception if you tried), there's no requirement that the JVM even have something meaningful there.

Hope this helps!

Define what a "garbage value" is. (Hint: since everything is binary, there is no such thing unless you use a sentinel value, and that's just bad practice).

The length of the array is stored inside the Array instance as a member variable. It's nothing complex.

In a comment on another, the OP writes:

I agree array.length is the conventional method, I was looking for any other option if available.

There is no other reasonable implementation option open to the JVM implementer ... on any mainstream hardware architecture.

In particular, the sentinel approach ONLY detects the case where an application fetches an array element one index beyond the end.

• If it fetches 2 or more indexes beyond, then it misses the sentinel and proceeds to access memory whose contents are unknown.
• If it stores, then the sentinel is not consulted.
• If it needs to directly access the array size as part of the application algorithm, searching for a sentinel is a very inefficient way of doing it. (Not to mention unreliable; e.g. if null is a valid array element.)
• Sentinels don't work for (most) primitive arrays because there is no value that can be used as a sentinel. (The idea of a primitive array holding a null is nonsensical from the JLS perspective, since null is not type compatible with any Java primitive type.)
• The garbage collector needs an array length in all cases.

In short, the length has to be stored in the array to deal with the other cases. Storing a sentinel as well means you are wasting space storing redundant information, and CPU cycles creating the sentinel and copying it (in the GC).

Okay, here I go :-)

Ways to deal with "arrays" in C

In C there are numerous ways to deal with array. For the remainder I will talk about string* (and use the variable strings which has a type of string*). This is because t[] "effectively decomposes" into t* and char* is the type of a "C string". Thus string* represents a pointer to "C string". This glosses over a number of pedantic issues in C w.r.t. "arrays" and "pointers". (Remember: just because a pointer can be accessed as p[i] doesn't make the type an array in C parlance.)

Now, strings (of type string*) has no way to know it's size -- it only represents a pointer to some string, or NULL perhaps. Now, let's look at some of the ways we can "know" the size:

Use a sentinel value. In this I am assuming the use NULL as the sentinel value (or it might be -1 for an "array" of integers, etc.). Remember that C has no such requirement that arrays have a sentinel value so this approach, like the following two, is just convention.

string* p;
for (p = strings; p != NULL; p++) {
   doStuff(*p);
}

Track the array size externally.

void display(int count, string* strings) {
  for (int i = 0; i < count; i++) {
    doStuff(strings[i]);
  }
}

Bundle the "array" and the length together.

struct mystrarray_t {
  int size;
  string* strings;
}

void display(struct mystrarray_t arr) {
  for (int i = 0; i < arr.size i++) {
    doStuff(arr.strings[i]);
  }
}

Java uses this last approach.

Every array object in Java has a fixed sized which can be accessed as arr.length. There is special byte-code magic to make this work (arrays are very magical in Java), but at the language level this is exposed as just a read-only integer field that never changes (remember, each array object has a fixed size). Compilers and the JVM/JIT can take advantage of this fact to optimize the loop.

Unlike C, Java guarantees that trying to access an index out of bounds will result in an Exception (for performance reasons, even if it were not exposed, this would require the JVM kept track of the length of each array). In C this is just undefined behavior. For instance, if the sentinel value wasn't within the object (read "the desired accessibly memory") then example #1 would have lead to a buffer-overflow.

However, there is nothing to prevent one from using sentinel values in Java. Unlike the C form with a sentinel value, this is also safe from IndexOutOfBoundExceptions (IOOB) because the length-guard is the ultimate limit. The sentinel is just a break-early.

// So we can add up to 2 extra names later
String names[] = { "Fred", "Barney", null, null };
// This uses a sentinel *and* is free of an over-run or IOB Exception
for (String n : names) {
  if (n == null) {
    break;
  }
  doStuff(n);
}

Or possibly allowing an IOOB Exception because we do something silly like ignore the fact that arrays know their length: (See comments wrt "performance").

// -- THERE IS NO EFFECTIVE PERFORMANCE GAIN --
// Can ONLY add 1 more name since sentinel now required to
// cleanly detect termination condition.
// Unlike C the behavior is still well-defined, just ill-behaving.
String names[] = { "Fred", "Barney", null, null };
for (int i = 0;; i++) {
  String n = strings[i];
  if (n == null) {
    break;
  }
  doStuff(n);
}

On the other hand, I would discourage the use of such primitive code -- better to just use a suitable data-type such as a List in almost all cases.

Happy coding.

In terms of how you'd print all the elements in the array without using either a for each loop or the length field, well in all honesty you just wouldn't. You could potentially just have a for loop like the following:

try {
    for(int i=0 ; ; i++) {
        System.out.println(arr[i]);
    }
}
catch(IndexOutOfBoundsException ex) {}

But that's an awful way to do things!

how will you print elements without using array.length or foreach loop

You could of course loop through the array without bounds checking and then catch (and swallow) the ArrayIndexOutOfBoundsException in the end:

try {
  int i = 0;
  while (true) {
    System.out.println(arr[i++]);
  }
catch (ArrayIndexOutOfBoundsException e) {
  // so we are past the last array element...
}

This technically works, but it is bad practice. You should not use exceptions for flow control.

All array access outside the interval [0, 9] gives an ArrayIndexOutOfBoundsException, not only position 10. So, conceptually you could say that your whole memory (reaching with indexes from Integer.MIN_VALUE to Integer.MAX_VALUE) is filled with sentinel values, apart from the space of the array itself, and when reading or writing to a position filled with a sentinel, you get your exception. (And each array has its own whole memory to spend). Of course, in reality no one has a whole memory for each array to spend, so the VM implements the array accesses a bit smarter. You can imagine something like this:

class Array<X> {

   private final int length;
   private final Class<X> componentType;

   /**
    * invoked on   new X[len] .
    */
   public Array<X>(int len, Class<X> type) {
      if(len < 0) {
          throw new NegativeArraySizeException("too small: " + len);
      }
      this.componentType = type;
      this.len = len;
      // TODO: allocate the memory

      // initialize elements:
      for (int i = 0; i < len; i++) {
          setElement(i, null);
      }
   }


   /**
    *  invoked on   a.length
    */
   public int length() {
       return length;
   }


   /**
    * invoked on   a[i]
    */
   public X getElement(int index) {
      if(index < 0 || length <= index)
         throw new ArrayIndexOutOfBoundsException("out of bounds: " + index);
      // TODO: do the real memory access
      return ...;
   }

   /**
    * invoked on   a[i] = x
    */
   public X setElement(int index, X value) {
      if(index < 0 || length <= index) {
         throw new ArrayIndexOutOfBoundsException("out of bounds: " + index);
      }
      if(!componentType.isInstance(value)) {
         throw new ArrayStoreException("value " + value + " is of type " +
                                       value.getClass().getName() + ", but should be of type "
                                       + componentType.getName() + "!");
      }
      // TODO: do the real memory access
      return value;
   }

}

Of course, for primitive values the component type check is a bit simpler, since already the compiler (and then the VM bytecode verifier) checks that there are the right types, sometimes doing a type conversion, too. (And the initialization would be with the default value of the type, not null.)