How do I compare each corresponding index from three array of different random lengths from 1-5 without getting a possible out of bound exception

I have 3 arrays of random length. I want to create a new array that stores the largest value from comparing those 3 arrays at each index.

 int size1=x.length;
int size2=y.length;
int size3=z.length;
int size=0;
if (size1>=size2 && size1>=size3)
size=size1;
else if (size2>=size1 &&size2>=size3) {
size=size2;
}
else if (size3>=size1 && size3>=size2) {
size=size3;
}
int[] largest= new int[size];
int[] x= {1, 4, 6};  // random array length from 1-5 and hypothetically each array hold these values
int[] y= {2, 4};
int[] z= {5, 6, 7, 8, 9};

// ideally after some sort of an algorithm largest[] should hold {5, 6, 7, 8, 9}
I initially thought of a for loop, but my loop will eventually throw me a out of bound exception, because of the random size length nature of the arrays and x/y/z won't hold a value at index [i]. Any other ways?

for (int i=0;i<size;i++) {
if (x[i]>y[i]) && t1[i]>t3[i]) {
largest[i]=x[i];
}
else if (y[i]>x[i]) && y[i]>z[i]) {
largest[i]=y[i];
}
else if (z[i]>x[i]) && z[i]>y[i]) {
largest[i]=z[i];
}
}

There are several ways of doing this. Here's one that avoids a ton of conditional statements at the cost of more memory.

int size = Math.max(x.length, Math.max(y.length, z.length));
int[] nooX = new int[size];
int[] nooY = new int[size];
int[] nooZ = new int[size];
// Copy over the values from x to the new array
for(int i = 0; i < x.length; i++){
nooX[i] = x[i];
}
// ... Copy paste the above and do the same for arrays nooY and nooZ
int[] largest = new int[size];
// ... Copy paste your code, using nooX, nooY, and nooZ instead of x, y, and z

A simpler approach without creating extra arrays to equalize size:

public static int[] getMaxValues(int[] x, int[] y, int[] z) {
    int size = Math.max(x.length, Math.max(y.length, z.length));

    int[] max = new int[size];

    for (int i = 0; i < size; i++) {
        int xi = i < x.length ? x[i] : Integer.MIN_VALUE;
        int yi = i < y.length ? y[i] : Integer.MIN_VALUE;
        int zi = i < z.length ? z[i] : Integer.MIN_VALUE;

        max[i] = Math.max(xi, Math.max(yi, zi));
    }

    return max;
}

Test:

int[] x= {4, 4, 6};  // random array length from 1-5 and hypothetically each array hold these values
int[] y= {2, 10};
int[] z= {3, 6, 7, 8, 9};

System.out.println(Arrays.toString(getMaxValues(x, y, z)));

Output:

[4, 10, 7, 8, 9]

Update<br/>
Defining a couple of functions allows to create the following implementation using Stream API that would be able to handle non-hardcoded number of arrays:

private static int getAtIndex(int[] arr, int i) {
    return i < arr.length ? arr[i] : Integer.MIN_VALUE;
}

private static int getMax(IntStream values) {
    return values.max().getAsInt();
}

// use Supplier to be able to use stream of the arrays twice 
public static int[] getMaxValues(Supplier<Stream<int[]>> arrs) {
    return IntStream.range(0, getMax(arrs.get().mapToInt(arr -> arr.length)))
                    .map(i -> getMax(arrs.get().mapToInt(arr -> getAtIndex(arr, i))))
                    .toArray();
}

Test:

int[] maxValues = getMaxValues(() -> Stream.of(x, y, z)); // supply stream of arrays
System.out.println(Arrays.toString(maxValues));

I think we should think this way

array1 = 1, 2, 3, 4, 6, 7

array2 = 3, 4, 5, 6, 23, 4

array3 = 5, 5, 32, 3, 2, 43, 56

Like a matrix
<pre>
1 2 3 4 6 7

3 4 5 6 23 4

5 5 32 3 2 43 56
</pre>
We need is the greatest value in every column.

largestArr = 5, 5, 32, 6, 23, 43, 56 <-- Like this

I hope this code is the answer to your problem.

public static int[] largestColumnsArr(int arr1[], int arr2[], int arr3[]) {
int[][] arr = {arr1, arr2, arr3};
//The size of the largest sized array
int size = Math.max(arr3.length, Math.max(arr2.length, arr1.length));
int[] largestArr = new int[size];
/*
Takes the largest value in each column and assigns it to the array
If it is try catch, if the size of the arrays is exceeded, the program exit is blocked.
*/
for (int i = 0; i < size; i++) {
int largestColumnValue = 0;
try {
for (int j = 0; j < arr.length; j++) {
if (largestColumnValue < arr[j][i]) {
largestColumnValue = arr[j][i];
}
}
} catch (Exception e) {
}
largestArr[i] = largestColumnValue;
}
return largestArr;
}