doppelte Einträge in Array - Java

Question

Für Java Praxis Ich versuche, eine Methode in meiner EmployeesDirectory Klasse zu erstellen, dass:

• Entfernt doppelte Einträge aus dem Array
• Das Array sollte die gleiche Länge nach Entfernen von Duplikaten
• nicht leeren Einträge sollten eine zusammenhängende Sequenz am Anfang des Arrays macht - und die actualNum sollte eine Aufzeichnung der Einträge halten

Duplizieren Bedeutet: gleichen Namen, Position und Gehalt

Hier ist meine aktuellen Code ist:

Ich bin nicht sicher, wie diese umzusetzen - jede Hilfe würde

class EmployeeDirectory { 

    private Employee dir[]; 
    private int size; 
    private int actualNum; 

    public EmployeeDirectory(int n) { 
     this.size = n; 
     dir = new Employee[size]; 
    } 

    public boolean add(String name, String position, double salary) { 
     if (dir[size-1] != null) { 
      dir[actualNum] = new Employee(name, position, salary); 
      actualNum++; 
      return true; 
     } else { 
      return false; 
     } 
    } 
} 

Answer 1

Ich würde eher Sie erkannt werden, hat keine eindeutige Methode zum Entfernen von Duplikaten geschrieben. Wenn ich Sie wäre, würde ich nach Duplikaten in add Methode suchen und dann sofort entscheiden, ob ich hinzufügen muss.

Auch warum verwenden Sie nicht Sets (Link für HashSet) anstelle von Arrays für Ihren Zweck? Sets durch ihre eigene Definition disallow Hinzufügen von Duplikaten, so dass sie zu sein scheinen angemessen als Lösung

Answer 2

Wenn Ihre Aufgabe Staaten als „Duplikate entfernen aus Array“ (dh Sie können nicht ArrayList oder Steuerung verwenden, wenn Elemente hinzugefügt) können Sie verwenden Sie den folgenden Ansatz:

public void removeDuplicates() { 
    Set<Employee> d = new HashSet<>(); // here to store distinct items 
    int shift = 0; 
    for (int i = 0; i > dir.length; i++) { 
     if (d.contains(dir[i])) {  // duplicate, shift += 1 
      shift++; 
     } else {      // distinct 
      d.add(dir[i]);    // copy to `d` set 
      dir[i - shift] = dir[i]; // move item left 
     } 
    } 
    for (int i = d.size(); i < dir.length; i++) 
     dir[i] = null;     // fill rest of array with nulls 

    actualNum = d.size(); 
} 

Hier shift Variable speichert Anzahl von Duplikaten im Array gefunden bisher. Jeder einzelne Artikel wird in shift Positionen verschoben, um die Reihenfolge kontinuierlich zu halten, während die anfängliche Bestellung beibehalten wird. Dann werden die verbleibenden Elemente in Nullen geändert.

Um Hash-basierte Sammlungen arbeiten mit Employee Instanzen richtig zu machen, müssen Sie auch hashCode() und equals() Methoden außer Kraft setzen, wie folgt: Leider

public class Employee { 

    //... 

    @Override 
    public int hashCode() { 
     return Objects.hash(name, position, salary); 
    } 

    @Override 
    public boolean equals(Object o) { 
     if (this == o) return true; 
     if (o == null) return false; 
     if (!o.getType().equals(this.getType()) return false; 
     Employee e = (Employee) o; 
     return Objects.equals(e.name, name) 
      && Objects.equals(e.position, position) 
      && Objects.equals(e.salary, salary); // or e.salary == salary, if it primitive type 
    } 
} 

Answer 3

, ich habe die Klasse Employee nicht bekam meinen Code zu überprüfen, aber versuchen Sie dies:

void removeDuplicates() { 
    int length = dir.length; 
    HashSet set = new HashSet(Arrays.asList(dir)); 
    dir = new Employee[length]; 
    Employee[] temp = (Employee[]) set.toArray(); 
    for (int index = 0; index < temp.length; index++) 
     dir[index] = temp[index]; 
} 

Der Code muss die Größe des Arrays nach dem Löschen der Duplikate bleiben. Zu Beginn des Arrays muss es gültige Mitarbeiter geben, am Ende - Nullen. Und vergessen Sie nicht, dies am Anfang Ihres hinzuzufügen.Java-Datei

import java.util.Arrays; 
import java.util.HashSet; 

Answer 4

Zu allererst Aufschaltenequals und hashCode Methoden in Employee Klasse wie folgt

@Override 
public boolean equals(Object other) { 
    if(this == other) return true; 

    if(other == null || (this.getClass() != other.getClass())){ 
     return false; 
    } 

    Employee guest = (Employee) other; 
    return Objects.equals(guest.name, name) 
      && Objects.equals(guest.position, position) 
      && Objects.equals(guest.salary, salary); 
} 

@Override 
public int hashCode() { 
    return Arrays.hashCode(new Object[] { 
       name, 
       position, 
       salary 
     }); 
} 

Dann können Sie Stream-API distinct Methode verwenden Duplikate

Returns zu entfernen ein Strom, der aus den einzelnen Elementen besteht (nach Object.equals (Object)) dieses Streams.

Sie können es wie so

Employee e1 = new Employee("John", "developer", 2000); 
Employee e2 = new Employee("John", "developer", 2000); 
Employee e3 = new Employee("Fres", "designer", 1500); 

Employee[] allEmployees = new Employee[100]; 
allEmployees[0] = e1; 
allEmployees[1] = e2; 
allEmployees[2] = e3; 

allEmployees = Arrays.asList(allEmployees).stream().distinct() 
      .toArray(Employee[]::new); 

Arrays.asList(allEmployees).forEach(System.out::println); 

Ausgang: (wobei beide leer und nicht leere Einträge)

John developer 2000.0 
Fres designer 1500.0 
null