Массив: Элемент считается равным другому, если его данные лежат в пределах некоего диапазона, сравнить массивы

import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
 
public class MyTest {
    
    //private Integer idEQ;
    //private double valueEQ;
    
    // центральная точка
    static Point basic = new Point (5,5);
    // Расстояние
    static HashMap<Integer,Double> arrdist1 = new HashMap<Integer, Double>();
    static HashMap<Integer,Double> arrdist2 = new HashMap<Integer, Double>();
    // Угол
    static HashMap<Integer,Double> arrangle1 = new HashMap<Integer, Double>();
    static HashMap<Integer,Double> arrangle2 = new HashMap<Integer, Double>();
    
    public static void main(String[] args) {
        // Синтез данных
        // набор координат конца вектора 1
        int[] x1 = {1,3,5,9,2};
        int[] y1 = {2,5,8,1,1};
        // набор координат конца вектора 2
        int[] x2 = {1,3,5,9,2};
        int[] y2 = {2,6,6,4,7};
        // уникальный угол
        int[] a1 = {135,45,78,2,90};
        int[] a2 = {130,41,81,0,89};
        
        Point source1 = null;
        Point source2 = null;
        
        // Рассчитываем эвклидово расстояние и разницу между
        // углом в направлении "центральная точка - конец вектора"
        // и уникальным угом вектора
        for (int c=0; c<5; c++) {
            source1 = new Point(x1[c], y1[c]);
            source2 = new Point(x2[c], y2[c]);
            // Расстояние
            arrdist1.put(c,distEuclidian(basic,source1));
            arrdist2.put(c,distEuclidian(basic,source2));
            // Угол
            arrangle1.put(c,a1[c]-rotationAngleInDeg(basic,source1));
            arrangle2.put(c,a2[c]-rotationAngleInDeg(basic,source2));
        }
        // Выводим
        //display(arrdist1);
        // с сортировкой по ключу
        //display(arrdist1,"sortbykey");
        // с сортировкой по значению
        //display(arrdist1,"sortbyvalue");
        
        // шаманим с retainAll(пересечение множеств)/removeAll(исключение)
        arrdist1.keySet().retainAll(arrdist2.keySet());
        //arrdist1.values().retainAll(arrdist2.values());
        display(arrdist1);
        display(arrdist2);
    }
    
    // Перегружаем
    public static void display(HashMap<Integer, Double> arrdist){
        Set<Entry<Integer, Double>> entries = arrdist.entrySet();
        for(Entry<Integer, Double> entry : entries){
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        System.out.println();
    }
    
    public static void display(HashMap<Integer, Double> arrdist, String string){
        if (string=="sortbykey"){
            TreeMap<Integer,Double> sorted = new TreeMap<>(arrdist);
            Set<Entry<Integer,Double>> mappings = sorted.entrySet();
            for(Entry<Integer,Double> mapping : mappings){
                System.out.println(mapping.getKey() + " -> " + mapping.getValue());
            }
            System.out.println();
        } else if (string=="sortbyvalue") {
            Set<Entry<Integer, Double>> entries = arrdist.entrySet();
            List<Entry<Integer,Double>> listOfEntries = new ArrayList<Entry<Integer,Double>>(entries);
            Collections.sort(listOfEntries, valueComparator);
            LinkedHashMap<Integer, Double> sortedByValue = new LinkedHashMap<Integer, Double>(listOfEntries.size());
            for(Entry<Integer, Double> entry : listOfEntries){
                sortedByValue.put(entry.getKey(), entry.getValue());
            }
            Set<Entry<Integer, Double>> entrySetSortedByValue = sortedByValue.entrySet();
            for(Entry<Integer, Double> mapping : entrySetSortedByValue){
                System.out.println(mapping.getKey() + " -> " + mapping.getValue());
            }
            System.out.println();
        }
        
    }
    // Сортировка по значению
    static Comparator<Entry<Integer,Double>> valueComparator = new Comparator<Entry<Integer,Double>>() {
        @Override
        public int compare(Entry<Integer,Double> e1, Entry<Integer,Double> e2) {
            Double v1 = e1.getValue();
            Double v2 = e2.getValue();
            return v1.compareTo(v2);
        }
    };
    // Эвклидово расстояние
    public static double distEuclidian(Point basic, Point target) {
        double euclidian = Math.sqrt(Math.pow((target.x-basic.x),2)+Math.pow((target.y-basic.y),2));
        return euclidian;
    }
    // Угол в направлении точка 1 - точка 2
    public static double rotationAngleInDeg(Point sourcePt, Point targetPt) {
        double theta = Math.atan2(targetPt.y - sourcePt.y, targetPt.x - sourcePt.x);
        double angle = Math.toDegrees(theta);
        if (angle < 0) {
            angle += 360;
        }
        return angle;
    }
    // Переопределяем equals и hashCode
    /*
    @Override
    public int hashCode() {
        int hash = 47;
        hash = hash*11 + idEQ.hashCode();
        hash = hash*11 + valueEQ;
        return hash;
    }
    /**/
    /*
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        MyTest other = (MyTest) obj;
        int dispersion = 15;
        if (Math.abs(idEQ-other.idEQ)>=dispersion) return false;
        if (Math.abs(valueEQ-other.valueEQ)>=dispersion) return false;
        return true;
    }
    /**/
 
}

public class MyElement implements Comparable<MyElement>{
    public static double distanceLimit;
    public static int angleLimit;
    private double distance;
    private int angle;
    private final int id;
 
 
    public MyElement(int id, double distance, int angle) {
        this.distance = distance;
        this.angle = angle;
        this.id = id;
    }
 
    public double getDistance() {
        return distance;
    }
 
    public int getAngle() {
        return angle;
    }
 
    public int getId() {
        return id;
    }
 
    int comp(double a, double b) {
        double sub = Math.abs(a-b);
        if (sub < distanceLimit) {
            return 0;
        }
        return (Double.compare(a,b));
    }
    int comp(int a, int b) {
        double sub = Math.abs(a-b);
        if (sub < angleLimit) {
            return 0;
        }
        return (Integer.compare(a,b));
    }
 
 
    @Override
    public int compareTo(MyElement o) {
        if (this == o) return 0;
        if (!(o instanceof MyElement))
            throw new RuntimeException("Not comparable object");
 
        MyElement myElement = (MyElement) o;
 
        int dist = comp(myElement.distance, distance);
        if (dist != 0) return dist;
        return comp(angle,myElement.angle);
 
    }
}

import java.awt.*;
import java.util.Set;
import java.util.TreeSet;
 
public class MyTest {
     // центральная точка
    static Point basic = new Point(5, 5);
    static double distance1 = 2;
    static double distance2 = 3;
    // Расстояние
    // Угол
    static Set<MyElement> set1 = new TreeSet<>();
    static Set<MyElement> set2 = new TreeSet<>();
 
    public static void main(String[] args) {
        // Синтез данных
        // набор координат конца вектора 1
        int[] x1 = {1, 3, 5, 9, 2};
        int[] y1 = {2, 5, 8, 1, 1};
        // набор координат конца вектора 2
        int[] x2 = {1, 3, 5, 9, 2};
        int[] y2 = {2, 6, 6, 4, 7};
        // уникальный угол
        int[] a1 = {135, 45, 78, 2, 90};
        int[] a2 = {130, 41, 81, 0, 89};
 
        Point source1 = null;
        Point source2 = null;
 
        // Рассчитываем эвклидово расстояние и разницу между
        // углом в направлении "центральная точка - конец вектора"
        // и уникальным угом вектора
        for (int c = 0; c < 5; c++) {
            source1 = new Point(x1[c], y1[c]);
            source2 = new Point(x2[c], y2[c]);
            // Расстояние
            // Угол
            set1.add(new MyElement(c, distEuclidian(basic, source1), a1[c] - (int) rotationAngleInDeg(basic, source1)));
            set2.add(new MyElement(c, distEuclidian(basic, source2), a2[c] - (int) rotationAngleInDeg(basic, source2)));
 
        }
        // Выводим
        MyElement.distanceLimit = 1.5;
        MyElement.angleLimit = 50;
 
        System.out.print("Set1: ");
        display(set1);
        System.out.print("Set2: ");
        display(set2);
        set1.retainAll(set2);
 
        System.out.print("Set1: ");
        display(set1);
    }
 
    // Перегружаем
    public static void display(Set<MyElement> set) {
        for (MyElement entry : set) {
            System.out.printf("[%2d ->%5.2f/% 3d] ",entry.getId(), entry.getDistance(), entry.getAngle());
        }
        System.out.println();
    }
 
    // Эвклидово расстояние
    public static double distEuclidian(Point basic, Point target) {
        double euclidian = Math.sqrt(Math.pow((target.x - basic.x), 2) + Math.pow((target.y - basic.y), 2));
        return euclidian;
    }
 
    // Угол в направлении точка 1 - точка 2
    public static double rotationAngleInDeg(Point sourcePt, Point targetPt) {
        double theta = Math.atan2(targetPt.y - sourcePt.y, targetPt.x - sourcePt.x);
        double angle = Math.toDegrees(theta);
        if (angle < 0) {
            angle += 360;
        }
        return angle;
    }
}