1. Syntax: Groovy has a more concise and simplified syntax compared to Java, making it easier to read and write code. For instance, Groovy doesn't require semicolons at the end of statements and allows optional parentheses for method calls. This results in less boilerplate code and a more natural language-like syntax in Groovy.
2. Dynamic Typing: Groovy is dynamically typed, meaning variables do not have to be declared with a specific type. This allows for more flexibility and less verbose code, as types are inferred at runtime. In contrast, Java is statically typed, requiring explicit declaration of variable types.
3. Metaprogramming: Groovy provides extensive support for metaprogramming, allowing developers to modify classes and objects at runtime. This enables features like adding methods to classes at runtime, which is not as easily achievable in Java. Metaprogramming in Groovy can lead to more dynamic and flexible code compared to Java.
4. Closures and Builders: Groovy has built-in support for closures, which are blocks of code that can be assigned to variables and passed around as arguments. This feature is not as seamlessly integrated into Java, making Groovy more expressive and concise when working with higher-order functions. Additionally, Groovy's builder pattern simplifies the creation of complex data structures, reducing boilerplate code.
5. Null Safety: In Groovy, the Elvis operator (?:) and safe navigation operator (?.) help mitigate null pointer exceptions by providing concise ways to handle null values. Java lacks these features, relying more on explicit null checks and exception handling, which can lead to more verbose code for null safety.
6. Integration with Java: Groovy is designed to seamlessly integrate with existing Java code, allowing developers to gradually introduce Groovy into Java projects. This interoperability enables developers to leverage the strengths of both languages, such as using Groovy for scripting and Java for performance-critical components.

In Summary, Groovy and Java differ in syntax simplicity, typing system, metaprogramming capabilities, support for closures and builders, null safety features, and integration with Java.