array index not incrementing (need to do casting in square brackets)

Question

I have some doubts as to why the value of index is not incrementing here.

The reason why I have declared my array like that is because I need to store n natural numbers where (1 ≤ n ≤ 10¹²), so numbers are large which is why I have taken an array of type long, but then I get an error that I cannot put any long value in the group, which is why I cast it to int. Is there any way to declare an array for this type of condition, as I want a large number of indexes, and I can not put a long number in the [ ].

hope you guys understand my problem

CODE:

import java.util.Scanner;

class Error{

public static void main(String[] args) {

    Scanner in = new Scanner(System.in);

    long n = in.nextLong();
    long array[] = new long[(int) n];
    long index = 0;


    for (int j = 1; j <= n; j++) {
            if (j % 2 != 0) {//odd
                array[(int) index++] = j;
                System.out.print(" " + array[(int) --index]);
                System.out.print(index);// index value  -> always 0  why??
                System.out.print(j);
            }
        }
    System.out.println();
    }
}

OUTPUT:

Unix-Box ~/Desktop$ javac Error.java 
Unix-Box ~/Desktop$ java Error
10
 101 303 505 707 909
Unix-Box ~/Desktop$ 

the middle value is of index and it is always 0

what i shout it to be like

 10
     101 313 525 737 949
    Unix-Box ~/Desktop$ 

Answer 1

According to https://www.quora.com/What-is-the-maximum-size-of-the-array-in-Java, the max size of an array is 2147483647 theoretically, but in practice we would want to use 2147483600 to be safe. Declaring the array as type long will mean that long values can be stored inside. Maybe you can use a two dimensional array to store a long n amount of values. Something like--

    public static void main(String[] args)
  {
System.out.println("enter the size of the array:");
Scanner in = new Scanner(System.in);
long n = Long.parseLong(in.nextLine()); 
int secondIndex = 2147483600;
int firstIndex = ((int)(n/secondIndex))+1;

if(secondIndex > n)
{secondIndex = (int)n;
}
    else{int leftover = (int)(n%secondIndex);
        secondIndex = secondIndex - leftover;}

    long[][] array = new long[firstIndex][secondIndex];

    //loop through array
      outerloop:
    for(int i =0;i <firstIndex; i++)
    {
      for(int z = 0; z<secondIndex; z++)
      {

        System.out.println("do work with number here: " + array[i][z]);
        if(z==(secondIndex-1))
        {
          z=0;
          continue outerloop;
        }
      }

    }
  }

You might get a java.lang.OutOfMemoryError:, which can be resolved by reading this article https://plumbr.eu/outofmemoryerror/java-heap-space.

Answer 2

As others have indicated,

array[(int) index++] = j; // You use index and then increment it
System.out.print(" " + array[(int) --index]); // You decrement the index here

That's why index will always be 0 when you print it.

Personally, I don't like mixing brackets with increment operators for the precise reason you're seeing here - it tends to be confusing and it lends itself to subtle (and not-so-subtle) bugs and off-by-one errors. In fact, I really don't like mixing them with any other syntax (with the exception of for loops) as it can quickly become very unclear. For example, if you had done something like

index++;
array[(int)index] = j;
index--;
System.out.print(" " + array[(int)index]);

the problem would've been obvious immediately.

In general, it's a bad idea to sacrifice clarity for brevity.

Also, just to review how the operators in question are working:
index++ - use the value and then increment it
index-- - use the value and then decrement it
++index - increment the value and then use it
--index - decrement the value and then use it.

Here's a C# code sample I put together (Java's behavior will be identical) to illustrate this:

int i = 0;

Trace.TraceInformation((i++).ToString()); // Prints 0

Trace.TraceInformation(i.ToString()); // Prints 1

Trace.TraceInformation((--i).ToString()); // Prints 0

Trace.TraceInformation((i--).ToString()); // Prints 0

Trace.TraceInformation(i.ToString()); // Prints -1

I'd encourage you to trace/step through this to convince yourself that that's the case and to understand exactly why the value is what it is at every point.

Either way, this syntax can be very confusing if overused.