Code duplication in general is highly undesirable for a range of reasons: The artificially inflated amount of code hinders comprehension, and ranges of similar but subtly different lines can mask the real purpose or intention behind a function. There's also a risk of update anomalies, where only one of several copies of the code is updated to address a defect or add a feature.

In the case of function similarity, how to address the issue depends on the functions themselves and on the precise classes in which they occur. At its simplest, if the differences are accidental, the problem can be addressed by unifying the functions to behave identically. Then, we can remove all but one of the duplicate function definitions and make callers of the removed functions refer to the (now canonical) single remaining definition instead.

In more complex cases, look for ways of encapsulating the commonality and sharing it while retaining the differences in functionality. Perhaps the function can be moved to a single place and given an additional parameter, allowing it to cover all use cases? Alternatively, there may be a common preprocessing or postprocessing step which can be extracted to its own (shared) function, leaving only the specific parts in the existing functions.

Modern IDEs may provide refactoring support for this sort of transformation. Relevant refactorings might be "Extract function", "Change function signature", "Pull up" or "Extract supertype".