umgekehrte Methode für generische Paar in Java

Question

public class Main{ 

public static void main(String[] args) { 

    final Pair<Integer> p = new DefaultPair<>(3,5); 
    p.reverse(); 
    final Pair<Integer> q = new DefaultPair<>(5,3); 
    } 

} 

public interface Pair<F> { 
    F first(); 
    F second(); 
    F reverse(); 
} 

public class DefaultPair<F> implements Pair<F> { 
    private final F first; 
    private final F second; 
    private F reverseFirst; 
    private F reverseSecond; 


    public DefaultPair(F first, F second){//constructor 
    this.first = first; 
    this.second = second; 
    } 

// method that is not working  
@Override 
    public F reverse() { 

    this.reverseFirst = second; 
    this.reverseSecond = first; 

    System.out.println(this); 
    return (F)this; 
    } 

@Override 
public int hashCode() { 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + ((first == null) ? 0 : first.hashCode()); 
    result = prime * result + ((second == null) ? 0 : second.hashCode()); 
    return result; 
} 

@Override 
public boolean equals(Object obj) { 
    if (this == obj) 
     return true; 
    if (obj == null) 
     return false; 
    if (!(obj instanceof DefaultPair)) 
     return false; 
    DefaultPair<F> other = (DefaultPair) obj; 
    if (first == null) { 
     if (other.first != null) 
      return false; 
    } else if (!first.equals(other.first)) 
     return false; 
    if (second == null) { 
     if (other.second != null) 
      return false; 
    } else if (!second.equals(other.second)) 
     return false; 
    return true; 
} 

@Override 
    public F first(){ 
     return first; 
    } 

@Override 
    public F second(){ 
     return second; 
    } 


@Override 
public String toString() { 
     return "<" + first + ", " + second + ">"; 
    } 

} 

import static org.junit.Assert.*; 

import org.junit.Test; 

public class TestDefaultPair { 

    @Test 
    public void test() { 
     final Pair<Integer> p = new DefaultPair<>(3, 5); 
     final Pair<Integer> q = new DefaultPair<>(5, 3); 
     assertEquals(3, p.first().intValue()); 
     assertEquals(5, p.second().intValue()); 
     assertEquals("<3, 5>", p.toString()); 
     assertTrue(p.equals(p)); 
     assertFalse(p.equals(q)); 
     assertFalse(q.equals(p)); 
     assertFalse(p.equals(null)); 
     assertTrue(p.equals(q.reverse()));//test that is not passing 
    } 

} 

Ich muss alle Testfälle bestanden haben. Alle gehen neben dem letzten, wo ich die umgekehrte Methode aufrufen muss. Der Empfänger der umgekehrten Methode sollte nicht mutiert werden. Zum Beispiel sollte ich nicht p (3,5) eingeben, um umgekehrt zu werden. Alles andere funktioniert neben der umgekehrten Methode. Wenn ich p.reverse() aufrufe; und druckt p aus, es druckt in der ursprünglichen Reihenfolge.

Answer 1

Ihre equals() Implementierung in DefaultPair überprüft first und second Feldwerte für die Gleichheit. Aber Ihre reverse() Methode ändert nur die Werte von reverseFirst und reverseSecond Felder.

Entweder Sie reverseFirst und reverseSecond in equals() oder ändern die Werte von first und second in reverse()

Answer 2

verwenden müssen, denke ich, was los ist hier: F reverse(), in Ihrer Situation, F ist Integer, aber Integer ist nicht das, was Sie sollten zurückkehren, Sie sollten Pair zurückgeben.

p.equals(q.reverse()) is like: pair.equals(Integer) 

Answer 3

Hoffentlich habe ich alles richtig verstanden habe, aber ich denke, Ihre Reverse-Methode wie folgt aussehen sollte:

public DefaultPair<F> reverse() { 
    return new DefaultPair<F>(second,first); 
    // Here you should return a new instance of `DefaultPair<F>`, 
    // which uses second as first and first as second. 
    // Now you are left with an non mutable reversed new instance of DefaultPair 

} 

würde dies reverseFirst machen logisch auch und reverseSecond nutzlos in Ihrer Klasse Am Ende, und als ob sie entfernt werden sollten.