You may give this solution a try:

public static void main(String[] args) {
    String[][] employee_t = {
            {"1","ram","Mech"},
            {"1","ram","Mech"},
            {"1","siva","Mech"},
            {"1","siva","Mech"},
            {"1","gopi","Mech"},
            {"1","gopi","Mech"} };
    System.out.println("ID Name   Dept");
    Arrays.stream(employee_t)
          .map(Arrays::asList)
          .distinct()
          .forEach(row -> System.out.printf("%-3s%-7s%s\n", row.get(0), row.get(1), row.get(2)));
}

Output

ID Name   Dept
1  ram    Mech
1  siva   Mech
1  gopi   Mech

How it works: comparing arrays does rely on instance equality and not on comparing contained elements by equals. Hence converting each row of your 2D array into a List will enable you to compare lists, which takes equals of the elements contained into account.

The Java Stream API does provide a method distinct which relies on equals and will remove all duplicates for you.

Based on your code. Maybe it is not the BEST solution but it works.

public static void main(String[] args) {

    System.out.println("Name  ID  Dept ");
    // I added duplicated rows
    String[][] inputArray = {
            { "1", "ram", "Mech" }, 
            { "1", "siva", "Mech" }, 
            { "1", "gopi", "Mech" }, 
            { "1", "gopi", "Mech" }, 
            { "4", "jenkat", "Mech" },
            { "5", "linda", "Mech" }, 
            { "1", "velu", "Mech" },
            { "1", "velu", "Mech" }
    };

    // I will add all rows in a Set as it doesn't store duplicate values
    Set<String> solutionSet = new LinkedHashSet<String>();

    // I get all rows, create a string and insert into Set
    for (int i = 0 ; i < inputArray.length ; i++) {
        String input = inputArray[i][0]+","+inputArray[i][1]+","+inputArray[i][2];
        solutionSet.add(input);
    }

    // You know the final size of the output array
    String[][] outputArray = new String[solutionSet.size()][3];

    // I get the results without duplicated values and reconvert it to your format
    int position = 0;
    for(String solution : solutionSet) {
        String[] solutionArray = solution.split(",");

        outputArray[position][0] = solutionArray[0];
        outputArray[position][1] = solutionArray[1];
        outputArray[position][2] = solutionArray[2];

        position++;
    }


    System.out.println("Name  ID  Dept ");
    for (int i = 0; i < outputArray.length; i++) {
        for (int j = 0; j < outputArray[0].length; j++) {

            System.out.print(outputArray[i][j] + " ");
        }
        System.out.println();
    }

}

I have posted what I think is a readable and easy to maintain solution.

I decided to use distinct from Stream which is part of Java 8

Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream. - https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#distinct--

Main.class

class Main {
    public static void main(String[] args)
    {
        //Create a list of Employee objects
        List<Employee> employeeList = new ArrayList<Employee>();
        Employee e1 = new Employee(1, "ram", "mech");
        Employee e2 = new Employee(1, "ram", "mech");
        Employee e3 = new Employee(2, "gopi", "csc");
        Employee e4 = new Employee(2, "gopi", "civil");

        employeeList.add(e1);
        employeeList.add(e2);
        employeeList.add(e3);
        employeeList.add(e4);

        System.out.println("Before removing duplicates");
        employeeList.stream().forEach(System.out::println);

        //This is where all the magic happens.
        employeeList = employeeList.stream().distinct().collect(Collectors.toList());

        System.out.println("\nAfter removing duplicates");
        employeeList.stream().forEach(System.out::println);
    }
}

Output:

Before removing duplicates
Employee [valA=1, valB=ram, valC=mech]
Employee [valA=1, valB=ram, valC=mech]
Employee [valA=2, valB=gopi, valC=csc]
Employee [valA=2, valB=gopi, valC=civil]

After removing duplicates
Employee [valA=1, valB=ram, valC=mech]
Employee [valA=2, valB=gopi, valC=csc]
Employee [valA=2, valB=gopi, valC=civil]

Employee.class

//This is just a regular POJO class.
class Employee {

    int valA;
    String valB, valC;

    public Employee(int valA, String valB, String valC){
        this.valA = valA;
        this.valB = valB;
        this.valC = valC;
    }

    public Employee(Employee e) {
        this.valA = e.valA;
        this.valB = e.valB;
        this.valC = e.valC;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + valA;
        result = prime * result + ((valB == null) ? 0 : valB.hashCode());
        result = prime * result + ((valC == null) ? 0 : valC.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {

        if(obj instanceof Employee && ((Employee)obj).hashCode() == this.hashCode()){
            return true;
        }

        return false;
    }

    @Override
    public String toString() {
        return "Employee [valA=" + valA + ", valB=" + valB + ", valC=" + valC + "]";
    }
}