Groovy: primeros pasos

es facil, aunque no es un operador, es un metodo:

def s1 = "Hola"

def s2 = "Hola"

s1.is(s2)

String s1 = "Hola"

String s2 = s1

 

if (s1.is(s2)) // true

 

Lo cual quiere decir, s1 es s2 ? :P

 

Gracias por tu respuesta, por alguna razón el sitio se cayo varias veces cuando hice el post.

Como refresque en varias ocasiones el post, esperando respuesta, el mismo se publico 4 veces, si alguien puede eliminar el resto menos este!

Gracias de antemano! 

De nada, por si no quedo claro, el metodo se llama is y se le pasa como referencia el otro objeto:

miObjeto.is(otroObjeto)

Aunque revise el ejemplo que puse, con el JDK de Sun  en Ubuntu, me dio true enlos casos que puse, por que al parecer las constantes de String, me imagino que de los tipos primitivos, se comparten, por lo cual tienen la misma direccion de memoria, pero segun lei eso puede cambiar dependiendo la implementacion de la JRE :P Un poco latoso el asunto. Y el metodo is al parecer invoca a hashCode :P pero para otros objetos debe ser valido utilizarlo para saber si estan en la misma direccion de memoria.

Hay que checar un poco mas, pero me imagino que con lo actual puedes trabajar. De los mensajes repetidos, ya  hemos comentado eso, tiene un tiempo sucediendo esto, antes no pasaba, fue despues de un cambio en la web, me imagino que despues lo van a corregir.

Ya lo corrigieron, gracias muchachos :D son los mejores

No, me volvio a salir el mensaje :P bueno, sigamos:

En este momento estamos trabajando para mejorar el servicio. Sentimos las molestias.

ImaginaWorks: info@imaginaworks.com

 

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.

Volviendo a hacer la prueba, pero con otras clases, ya no con Strings ni con nada que tenga que ver con tipos primitivos(int, float, boolean, etc), hice la prueba con listas:

def f1 = []
def f2 = []
println f1 == f2
println f2 == f1
println f1.is(f2)
println f2.is(f1)
println f1.is(f1)
println f2.is(f2)

 

Siendo la salida:

true //s1 igual a s2

true //s2 iguala s1

false //s1 es s2
false // s2 es s1
true // s1 es s1

true // s2 es s2

Funcionando como esperamos, por lo cual, el unico problema seria con las constantes que se comparten las direcciones de memoria, pero como eso la hace la JVM, no lo podemos controlary depende de la implementacion, entonces tan solo hay que recordarlo para los Strings y los tipos primitivos que vienen de Java.