How to add/append new rows from Array1[][] that do not exist in Array2[][] to Array2[][] in Java?

I came across a problem where one needs to check for rows in Array1 that are not in Array2 and append it at the end of Array2 in Java. The rows that are common with regard to the first column i.e. name can be skipped. In the below example, the rows in firstarray with "Nick" and "Bruce" should be appended at the end of secondarray.

I have edited the arrays again slightly to get more clarity.

String firstarray[][] = {
	{"John","04-Feb-1982","Economics","Leeds"},
	{"Mathias","08-Jan-1985","Arts","London"},
	{"Nick","09-06-1974","History","Johanesburg"},
	{"Bruce","13-08-1975","Philosophy","Seattle"}};
	       
String secondarray[][] = {
	{"Adam","01-Dec-1980","Commerce","New York"},
	{"John","04-Feb-1982","Economics","Leeds"},
	{"Mathias","08-Jan-1985","Arts","London"}};

The solution should be like:

secondarray[][]:
    {"Adam","01-Dec-1980","Commerce","New York"},
    {"John","04-Feb-1982","Economics","Leeds"},
    {"Mathias","08-Jan-1985","Arts","London"},
    {"Nick","09-06-1974","History","Johanesburg"},
    {"Bruce","13-08-1975","Philosophy","Seattle"}}

Collect the names of the second array to a set, iterate over your first array and filter out those elements which are in the set and collect the result in a third array (or any other collection). Append this collection to your second array.

public static void main(String[] args){
String firstarray[][] = {
{"Adam","01-Dec-1980","Commerce","Kansas"},
{"John","04-Feb-1982","Economics","Leeds"},
{"Mathias","08-Jan-1985","Arts","London"},
{"Nick","09-06-1974","History","Johanesburg"},
{"Bruce","13-08-1975","Philosophy","Seattle"}};
String secondarray[][] = {
{"Adam","01-Dec-1980","Commerce","Kansas"},
{"John","04-Feb-1982","Economics","Leeds"},
{"Mathias","08-Jan-1985","Arts","London"},
{"Sujay Muramalla","08-Jan-1985","Arts","London"}};
//collect names of second array to set
Set<String> secondSet = Arrays.stream(secondarray).map(e -> e[0]).collect(Collectors.toSet());
//stream over your first array and keep only those which are not in the above set
String[][] third = Arrays.stream(firstarray)
.filter(e -> !secondSet.contains(e[0]))
.toArray(String[][]::new);
//stream over second and delta (third array) and collect to a result array
String[][] result = Stream.concat(Arrays.stream(secondarray), Arrays.stream(third))
.toArray(String[][]::new);
//output
Arrays.stream(result).forEach(e ->{
System.out.println(Arrays.toString(e));
});
}

EDIT 1 - Using Custom Class
I suggest you to always use List over Array.

import java.time.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    static class Person {
        public String name;
        public String birthDate;
        public String field;
        public String city;

        public static Person fromArray(String[] data) {
            Person p = new Person();
            if (data.length == 4) {
                p.name = data[0];
                p.birthDate = data[1];
                p.field = data[2];
                p.city = data[3];
            } else {
                // Handle me
            }
            return p;
        }

        @Override
        public String toString() {
            return new StringBuilder("[").append(name)
                    .append(",").append(birthDate)
                    .append("] learns ").append(field)
                    .append(" at ").append(city).toString();
        }
    }

    public static void main(String[] args) {
        String firstArray[][] = {
                {"Adam","01-Dec-1980","Commerce","Kansas"},
                {"John","04-Feb-1982","Economics","Leeds"},
                {"Mathias","08-Jan-1985","Arts","London"},
                {"Nick","09-06-1974","History","Johanesburg"},
                {"Bruce","13-08-1975","Philosophy","Seattle"}};

        String secondArray[][] = {
                {"Adam","01-Dec-1980","Commerce","Kansas"},
                {"John","04-Feb-1982","Economics","Leeds"},
                {"Mathias","08-Jan-1985","Arts","London"}};

        List<Person> finalList = getFinalList(firstArray, secondArray);
        // Display
        System.out.println(finalList);
    }

    public static List<Person> getFinalList(String[][] arr1, String[][] arr2) {
        // First cast to Lists of persons
        List<Person> firstList = Arrays.asList(arr1).stream().map(Person::fromArray).collect(Collectors.toList());
        List<Person> secondList = Arrays.asList(arr2).stream().map(Person::fromArray).collect(Collectors.toList());

        // Get names in secondList
        Set<String> existingNames = secondList.stream().map(p -> p.name).collect(Collectors.toSet());
        System.out.println("Names: "+ existingNames);

        firstList.forEach(person -> {
            if (! existingNames.contains(person.name)) {
                secondList.add(person);
            }
        });
        return secondList;
    }
}

You should not be using arrays for this. Much better to use libraries already doing the job.

Even if the data you receive is already that way, you can converted first to a Map<String, Person> it will be more efficient, and readable code.

With arrays or many solutions not using some hashing system, you end up with exponential complexity O(n2), so not efficient.

Convert at least secondarray

Map<String, Person> secondMap = new HashMap();
for(String [] row : secondarray){
secondMap.put(row[0], new Person(row[0], row[1], row[2], row[3]));
}

Then put in the map if not already there

for(String[] row : firstarray){
if(!secondMap.containsKey(row[0])){
secondMap.put(row[0], new Person(row[0], row[1], row[2], row[3]));
}
}

Where Person class could be simply defined as

private static class Person{
public Person(String name, String birth, String area, String city){
this.name = name;
this.birth = birth;
this.area = area;
this.city = city;
}
String name;
String birth;
String area;
String city;
}

if you want check more than the first element of the array you can use nopens solution and replace e[0] with Arrays.toString(e).

A cleaner way if this is possible for you, is to use a list with a object and use a id for checking equals or override the hashcode function of the customer object.
You can also check for name and birth like that:

class Customer {
private String name;
private String birth;
private String type;
private String location;
public Customer(String name, String birth, String type, String location) {
this.name = name;
this.birth = birth;
this.type = type;
this.location = location;
}
@Override
public String toString() {
return "Customer [name=" + name + ", birth=" + birth + ", type=" + type + ", location=" + location + "]";
}
}
List<Customer> firstList = new ArrayList<Customer>();
firstList.add(new Customer("Adam", "01-Dec-1980", "Commerce", "Kansas"));
firstList.add(new Customer("John", "04-Feb-1982", "Economics", "Leeds"));
firstList.add(new Customer("Mathias", "08-Jan-1985", "Arts", "London"));
firstList.add(new Customer("Nick", "09-06-1974", "History", "Johanesburg"));
firstList.add(new Customer("Bruce", "13-08-1975", "Philosophy", "Seattle"));
List<Customer> secondList = new ArrayList<Customer>();
secondList.add(new Customer("Adam", "01-Dec-1980", "Commerce", "Kansas"));
secondList.add(new Customer("John", "04-Feb-1982", "Economics", "Leeds"));
secondList.add(new Customer("Mathias", "08-Jan-1985", "Arts", "London"));
for (Customer customer : firstList) {
if (containsNameAndBirth(secondList, customer) == false) {
secondList.add(customer);
}
}
for (Customer customer : secondList) {
System.out.println(customer);
}
}
public static boolean containsNameAndBirth(final List<Customer> list, final Customer customer) {
return list.stream().filter(o -> o.name.equals(customer.name) && o.birth.equals(customer.birth)).findFirst()
.isPresent();
}

I upvoted nopens solutions cause it is nice one
Here another that uses maps and makes use of a logic of skipping common keys using removeAll on the keySet of the map, which was a functional method existing befor Java turned "more" functional

static public <T> Map<T,T[]> arrayToMap(T[][] array, int i) {
return Arrays.stream(array).collect(Collectors.toMap(e -> e[i], e -> e));
}
public static void main(String[] args){
String firstarray[][] = {
{"Adam","01-Dec-1980","Commerce","Kansas"},
{"John","04-Feb-1982","Economics","Leeds"},
{"Mathias","08-Jan-1985","Arts","London"},
{"Nick","09-06-1974","History","Johanesburg"},
{"Bruce","13-08-1975","Philosophy","Seattle"}};
String secondarray[][] = {
{"Adam","01-Dec-1980","Commerce","Kansas"},
{"John","04-Feb-1982","Economics","Leeds"},
{"Mathias","08-Jan-1985","Arts","London"},
{"Sujay Muramalla","08-Jan-1985","Arts","London"}};
Map<String,String[]> firstMap = arrayToMap(firstarray, 0);
Map<String,String[]> secondMap = arrayToMap(secondarray, 0);
secondMap.keySet().removeAll(firstMap.keySet());
firstMap.putAll(secondMap);	    
String[][] result = firstMap.values().stream().toArray(String[][]::new);
//output
Arrays.stream(result).forEach(e ->{
System.out.println(Arrays.toString(e));
});
}

sidenote: in arrayToMap you can choose which column you use as key.

And the logic could be even reduced to this 3 lines:

    Map<String,String[]> firstMap = arrayToMap(firstarray, 0);
firstMap.putAll(arrayToMap(secondarray, 0));	
String[][] result = firstMap.values().stream().toArray(String[][]::new);

since inserting a value with the same key overwrites the existing one and you get the same if the values are the same in case of equal keys.

A simple an efficient way to do it (if you don't care about ordering) is the following:

Time complexity: O(nlog(n))

Space complexity: O(n+m)

import java.util.Arrays;

public class Main {

    public static void main(String ... args) {

        String firstarray[][] = {
                {"John","04-Feb-1982","Economics","Leeds"},
                {"Mathias","08-Jan-1985","Arts","London"},
                {"Nick","09-06-1974","History","Johanesburg"},
                {"Bruce","13-08-1975","Philosophy","Seattle"}};

        String secondarray[][] = {
                {"Adam","01-Dec-1980","Commerce","Kansas"},
                {"John","04-Feb-1982","Economics","Leeds"},
                {"Mathias","08-Jan-1985","Arts","London"}};

        String result [][] =  new String[firstarray.length
                + secondarray.length][firstarray[0].length];

        // sort firstarray
        java.util.Arrays.sort(firstarray, new java.util.Comparator<String[]>() {
            public int compare(String [] a, String[] b) {
                return a[0].compareTo(b[0]);
            }
        });

        //sort secondarray
        java.util.Arrays.sort(secondarray, new java.util.Comparator<String[]>() {
            public int compare(String [] a, String[] b) {
                return a[0].compareTo(b[0]);
            }
        });
 

        int i = 0, j=0, k=0, cmp ;
        for ( ;i < secondarray.length && j< firstarray.length;) {

            cmp = firstarray[i][0].compareTo(secondarray[j][0]);
            if(cmp ==0) {
                System.arraycopy(firstarray[i], 0, result[k++], 0, 4);
                i++; j++;
            }else if( cmp <0){
                System.arraycopy(firstarray[i], 0, result[k++], 0, 4);
                i++;
            } else {
                System.arraycopy(secondarray[j], 0, result[k++], 0, 4);
                j++;
            }
        }

        // copy the remaining if any from firstarray to the result
        for (; i < firstarray.length; i++) {
            System.arraycopy(firstarray[i], 0, result[k++], 0, 4);
        }

        // copy the remaining if any from secondarray to the result
        for (; j < secondarray.length; j++) {
            System.arraycopy(secondarray[j], 0, result[k++], 0, 4);
        }
        
        //resize it
        secondarray = Arrays.copyOf(result, k);

        // just print the secondarray
        for (int x = 0; x < secondarray.length; x++) {

           for (int y = 0; y < 4; y++) {
               System.out.print(secondarray[x][y] + ",");
            }
            System.out.println("");
        }

    }
}