It is highly dependent on language.
Most high level function languages they are identical.
For interpreted languages there is usually little difference (especially when the language allows you to write your own operators (then it is just syntactic sugar for a method call), but then an interpreted language all operators are basically method calls as the language is interpreted).
When it comes to languages like C++ the story gets more complex.
- operators on primitive types are not like method calls.
- operators on class types are just that: method calls.
There is important distinction as this can change the inherent expected behavior of the operator. For example the && and || opertors are shortcut operators when used on primative types. But when you override for a particular class they are now the equivalent of method calls and thus all parameters must be evaluated before the method is called and thus they are no longer short-cut operators.
When using methods (and thus class specific overloaded operators) you have specific guarantees about where the sequence points are (thus certain side effects are OK). But with normal operators there are usually no sequence points until the end of the expression (thus side effects have a much larger scope for interfering with the rest of the expression).