简体   繁体   中英

Setting the value of an array index

Hello Everyone,

I was trying to work out how to set Diff[0] equal to the sum of an equation and I found that when:

int a = 0;

System.out.println(Data[0] - Data[1]);   //The calculation is possible and correct

Diff[a] = Data[0] - Data[1];   //But this line outputs a value of 0

Diff[0] = Data[0] - Data[1];   //I have also tried this but still a value of 0

Here is my code: No Errors

public static void main(String[] args) {

    Scanner numbers = new Scanner(System.in);

    int Numbers;
    int A;
    int a = 0, b = 1, c = 2, d = 3, e = 4, f = 5, g = 6, h = 7, i = 8, j = 9, k = 10, l = 11, m = 12, n = 13, o = 14, p = 15, q = 16, r = 17;
    int num;
    int lengthOfArray;

    System.out.println("Welcome to Stone Pile");
    System.out.println("\nEnter the number of stones:");
    Numbers = numbers.nextInt();

    int Data[] = new int[Numbers];
    for (A = 0; A < Data.length; A++) {
        for (num = 1; num < Numbers; num++) {
            int numGen = ThreadLocalRandom.current().nextInt(1, 21);
            Data[A] = numGen;
        }
    }

    lengthOfArray = Data.length;

    System.out.println("\n");

    System.out.println(Data.length + " This is the length of the Data Array");

    System.out.println("\n");

    System.out.println(Data[0]);
    System.out.println(Data[1]);
    System.out.println(Data[2]);
    System.out.println(Data[3]);
    System.out.println(Data[4]);
    System.out.println(Data[5]);
    System.out.println(Data[6]);
    System.out.println(Data[7]);
    System.out.println(Data[8]);
    System.out.println(Data[9]);

    System.out.println("\n");

    int Diff[] = new int[20];

    System.out.println(Diff.length + " This is length of the Diff Array");

    System.out.println("\n");

    System.out.println(Diff[0]);
    System.out.println(Diff[1]);
    System.out.println(Diff[2]);
    System.out.println(Diff[3]);
    System.out.println(Diff[4]);
    System.out.println(Diff[5]);
    System.out.println(Diff[6]);
    System.out.println(Diff[7]);
    System.out.println(Diff[8]);
    System.out.println(Diff[9]);

    switch (lengthOfArray) {
        case 2:
            Diff[a] = Data[0] - Data[1];
            break;

        case 3:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            break;

        case 4:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            break;

        case 5:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            break;

        case 6:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            break;

        case 7:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            break;

        case 8:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            break;

        case 9:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            break;

        case 10:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            break;

        case 11:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            break;

        case 12:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            break;

        case 13:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            break;

        case 14:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            break;

        case 15:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            Diff[n] = Data[13] - Data[14];
            break;

        case 16:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            Diff[n] = Data[13] - Data[14];
            Diff[o] = Data[14] - Data[15];
            break;

        case 17:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            Diff[n] = Data[13] - Data[14];
            Diff[o] = Data[14] - Data[15];
            Diff[p] = Data[15] - Data[16];
            break;

        case 18:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            Diff[n] = Data[13] - Data[14];
            Diff[o] = Data[14] - Data[15];
            Diff[p] = Data[15] - Data[16];
            Diff[q] = Data[16] - Data[17];
            break;

        case 19:
            Diff[a] = Data[0] - Data[1];
            Diff[b] = Data[1] - Data[2];
            Diff[c] = Data[2] - Data[3];
            Diff[d] = Data[3] - Data[4];
            Diff[e] = Data[4] - Data[5];
            Diff[f] = Data[5] - Data[6];
            Diff[g] = Data[6] - Data[7];
            Diff[h] = Data[7] - Data[8];
            Diff[i] = Data[8] - Data[9];
            Diff[j] = Data[9] - Data[10];
            Diff[k] = Data[10] - Data[11];
            Diff[l] = Data[11] - Data[12];
            Diff[m] = Data[12] - Data[13];
            Diff[n] = Data[13] - Data[14];
            Diff[o] = Data[14] - Data[15];
            Diff[p] = Data[15] - Data[16];
            Diff[q] = Data[16] - Data[17];
            Diff[r] = Data[16] - Data[18];
            break;
    }

Output:

20 This is the length of the Data Array

9 17 5 20 20 17 17 3 7 6

20 This is length of the Diff Array

0 0 0 0 0 0 0 0 0 0

The numbers in the Diff array should not be all 0's

I wondering if there's a way I can set the value of an array index, based off an equation.

It would be easier to achieve this with loops:

for(int i=0; i<Data.length-1; i++){
    Diff[i] = Data[i]-Data[i+1];
    System.out.println(Diff[i]);
}

These four lines could replace your entire switch statement and all of the "println(Diff..." lines. (Note that the reason you're getting the wrong Diff output is because you print the Diffs before you set their values)

Ignoring the ugly code, you should move the stub of printing Diff array after the switch stub. You printed Diff array out before assigning it with values.

The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM