# Testing equality of Geometry objects¶

JTS has a number of different equals methods for comparing Geometry objects. If you are doing a lot of comparisons with large, complex Geometry objects it’s important to understand the differences between these methods to get the best runtime performance in your application.

Hint

If this page looks long and scary, the important bit is to always avoid using
`Geometry.equals(Geometry g)`

in your code. Use `equalsExact`

or `equalsTopo`

instead.

`Geometry.equalsExact( Geometry g )`

- This method tests for
**structural equality**of Geometry objects. In simple terms, this means that they must have the same number of vertices, in the same locations, and in the same order. The latter condition is the tricky one. If two Polygons have matching vertices, but one is arranged clockwise while the other is counter-clockwise, then then this method will return**false**. It’s important to know this because vertex order can change when objects are being stored in, and later retrieved from, data stores. `Geometry.equalsExact( Geometry g, double tolerance )`

- This is just like the previous method but lets you specify a tolerance for the comparison of vertex coordinates.
`Geometry.equalsNorm( Geometry g )`

This method frees you from the vertex order problem mentioned above by

*normalizing*the Geometry objects (i.e. putting each into a standard or*canonical*form), before comparison. It is equivalent to:geomA.normalize(); geomB.normalize(); boolean result = geomA.equalsExact( geomB );

Vertex order will is guaranteed to be the same, but the price is additional computation which, for complex Geometry objects, can be expensive.

`Geometry.equalsTopo( Geometry g )`

- This method tests for
**topological equality**which is equivalent to drawing the two Geometry objects and seeing if all of their component edges overlap. It is the most robust kind of comparison but also the most computationally expensive. `Geometry.equals( Object o )`

- This method is a synonym for
`Geometry.equalsExact`

and lets you use Geometry objects in Java Collections. `Geometry.equals( Geometry g )`

This method is a synonym for

`Geometry.equalsTopo`

. It should really come with a health warning because its presence means that you can unknowingly be doing computationally expensive comparisons when quick cheap ones are all you need. For example:Geometry geomA = ... Geometry geomB = ... // If geomA and geomB are complex, this will be slow: boolean result = geomA.equals( geomB ); // If you know that a structural comparison is all you need, do // this instead: result = geomA.equalsExact( geomB );

The best thing approach you can take with this method is to vow never to use it.