{"id":335948,"date":"2023-03-24T12:18:16","date_gmt":"2023-03-24T11:18:16","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=idea&p=335948"},"modified":"2023-03-24T12:18:20","modified_gmt":"2023-03-24T11:18:20","slug":"concordancia-de-patrones-en-java-cinco-ejemplos-para-desarrolladores-con-poco-tiempo-libre","status":"publish","type":"idea","link":"https:\/\/blog.jetbrains.com\/es\/idea\/2023\/03\/concordancia-de-patrones-en-java-cinco-ejemplos-para-desarrolladores-con-poco-tiempo-libre\/","title":{"rendered":"Concordancia de patrones en Java: cinco ejemplos para desarrolladores con poco tiempo libre"},"content":{"rendered":"

Dado que sabemos que tiene poco tiempo libre, no siempre es f\u00e1cil estar al d\u00eda de las nuevas funcionalidades y entender bien d\u00f3nde y c\u00f3mo se pueden utilizar.<\/p>\n

En este art\u00edculo del blog, repasaremos cinco entornos en los que utilizar la concordancia de patrones en Java sin entrar en demasiados detalles. Cuando tenga un rato, eche un vistazo a los enlaces que encontrar\u00e1 a lo largo de este art\u00edculo.<\/p>\n

\u00a1Vamos all\u00e1!<\/p>\n

\u00a0<\/p>\n

1. Mejorar la legibilidad del c\u00f3digo convirtiendo las construcciones largas \u00abif-else\u00bb en expresiones \u00abswitch\u00bb<\/h2>\n

En primer lugar, una pregunta clave: \u00bfpor qu\u00e9 es importante esta conversi\u00f3n?<\/p>\n

Una de las principales ventajas es que el c\u00f3digo ser\u00e1 m\u00e1s conciso y f\u00e1cil de leer y entender. Dado que, normalmente, las declaraciones largas \u00abif-else\u00bb no caben en una sola pantalla y es posible que tenga que desplazarse de forma vertical, no siempre es f\u00e1cil entender el c\u00f3digo que se ejecuta para todas las comparaciones \u00abif\u00bb. Adem\u00e1s, la sintaxis de las condiciones \u00abif\u00bb puede ser poco clara, porque cada una de ellas podr\u00eda estar formada por otro conjunto de condiciones.<\/p>\n

A menudo, al navegar por una base de c\u00f3digo, observamos c\u00f3digo similar al que se muestra a continuaci\u00f3n para una construcci\u00f3n \u00abif-else\u00bb larga, que asigna un valor a una variable local de forma condicional. Eche un vistazo al c\u00f3digo de la siguiente imagen. Le ayudaremos a navegar por este resaltando ciertas secciones un poco m\u00e1s adelante:<\/p>\n

\u00a0<\/p>\n

    \nprivate static String getValueText(Object value) {\n    final String newExpression;\n    if (value instanceof String) {\n        final String string = (String)value;\n        newExpression = '\"' + StringUtil.escapeStringCharacters(string) + '\"';\n    }\n    else if (value instanceof Character) {\n        newExpression = ''' + StringUtil.escapeStringCharacters(value.toString()) + ''';\n    }\n    else if (value instanceof Long) {\n        newExpression = value.toString() + 'L';\n    }\n    else if (value instanceof Double) {\n        final double v = (Double)value;\n        if (Double.isNaN(v)) {\n            newExpression = \"java.lang.Double.NaN\";\n        }\n        else if (Double.isInfinite(v)) {\n            if (v > 0.0) {\n                newExpression = \"java.lang.Double.POSITIVE_INFINITY\";\n            }\n            else {\n                newExpression = \"java.lang.Double.NEGATIVE_INFINITY\";\n            }\n        }\n        else {\n            newExpression = Double.toString(v);\n        }\n    }\n    else if (value instanceof Float) {\n        final float v = (Float) value;\n        if (Float.isNaN(v)) {\n            newExpression = \"java.lang.Float.NaN\";\n        }\n        else if (Float.isInfinite(v)) {\n            if (v > 0.0F) {\n                newExpression = \"java.lang.Float.POSITIVE_INFINITY\";\n            }\n            else {\n                newExpression = \"java.lang.Float.NEGATIVE_INFINITY\";\n            }\n        }\n        else {\n            newExpression = Float.toString(v) + 'f';\n        }\n    }\n    else if (value == null) {\n        newExpression = \"null\";\n    }\n    else {\n        newExpression = String.valueOf(value);\n    }\n    return newExpression;\n}\n<\/pre>\n
Resaltemos el c\u00f3digo que nos interesa. En la siguiente imagen, ver\u00e1 que el m\u00e9todo getValueText<\/code> compara si el valor de la variable value<\/code> es de un determinado tipo de datos, como String<\/code>, Character<\/code>, Long<\/code>, Double<\/code> u otro:<\/p>\n
\u00a0<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Para entender las otras partes de esta construcci\u00f3n \u00abif-else\u00bb, nos centraremos en la variable <\/span>newExpression<\/code>. Observe que a esta variable se le est\u00e1 asignando un valor para todos los valores posibles de la variable value<\/code>:<\/p>\n
\u00a0<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Curiosamente, salvo dos, el resto de bloques de c\u00f3digo correspondientes a las condiciones \u00abif\u00bb son m\u00e1s largos que los dem\u00e1s, que suelen tener solo una l\u00ednea de c\u00f3digo:<\/span><\/p>\n
\u00a0<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Vamos a extraer estos dos bloques de c\u00f3digo m\u00e1s largos en m\u00e9todos separados y, despu\u00e9s, convertiremos la construcci\u00f3n \u00abif-else\u00bb en una expresi\u00f3n \u00abswitch\u00bb.<\/p>\n
Para extraer c\u00f3digo a otro m\u00e9todo, seleccione el c\u00f3digo, invoque las acciones contextuales con Alt+Intro(Opci\u00f3n+Intro para macOS) y seleccione la opci\u00f3n \u00abExtract method\u00bb. Puede elegir uno de los nombres sugeridos para el nuevo m\u00e9todo o ponerle uno nuevo. Para seleccionar fragmentos l\u00f3gicos de c\u00f3digo, le recomendamos el atajo Ctrl+W (o Ctrl+May\u00fas+W para reducir la selecci\u00f3n). Tras extraer el m\u00e9todo, siga las indicaciones de IntelliJ IDEA fij\u00e1ndose en las palabras clave resaltadas en amarillo e invoque las acciones contextuales (Alt+Intro). Para convertir este \u00abif-else\u00bb en \u00abswitch\u00bb, hemos invocado las acciones contextuales sobre \u00abif\u00bb y seleccionado \u00abReplace ‘if’ with ‘switch’\u00bb:<\/p>\n
\u00a0<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Esta es la construcci\u00f3n \u00abswitch\u00bb en el m\u00e9todo getValueText<\/code>, que es concisa y m\u00e1s f\u00e1cil de entender:<\/p>\n
private static String getValueText(Object value) {\n    final String newExpression = switch (value) {\n        case String string -> '\"' + StringUtil.escapeStringCharacters(string) + '\"';\n        case Character character -> ''' + StringUtil.escapeStringCharacters(value.toString()) + ''';\n        case Long aLong -> value.toString() + 'L';\n        case Double aDouble -> getNewExpression(aDouble);\n        case Float aFloat -> getNewExpression(aFloat);\n        case null -> \"null\";\n        default -> String.valueOf(value);\n    };\n    return newExpression;\n}\n<\/pre>\n
Llegados a este punto, quiz\u00e1s se est\u00e9 preguntando por qu\u00e9 no utiliza las expresiones \u00abswitch\u00bb tan a menudo en su c\u00f3digo como las construcciones \u00abif-else\u00bb. Los motivos son diversos. En las \u00faltimas versiones de Java, se ha mejorado la expresi\u00f3n \u00abswitch\u00bb, que ahora puede devolver valores (expresiones \u00abswitch\u00bb) y ya no se limita a comparar valores para un tipo de datos primitivo limitado, clases \u00abwrapper\u00bb y otros elementos como String<\/code> o enumeraciones. Adem\u00e1s, las etiquetas \u00abcase\u00bb pueden incluir patrones y condiciones.<\/p>\n
Con la concordancia de patrones y \u00abswitch\u00bb, tambi\u00e9n es posible manejar valores nulos utilizando \u00abnull\u00bb como etiqueta \u00abcase\u00bb. Adem\u00e1s, cada etiqueta \u00abcase\u00bb declara una variable de patr\u00f3n, tanto si se utilizan en el bloque de c\u00f3digo correspondiente como si no. En cuanto a las etiquetas \u00abbreak\u00bb que faltan, no son necesarias cuando se utilizan los estilos de flecha con \u00abswitch\u00bb.<\/p>\n
Sin embargo, la versi\u00f3n de esta funcionalidad todav\u00eda es preliminar, por lo que no deber\u00eda utilizarla en el c\u00f3digo de producci\u00f3n, ya que podr\u00eda cambiar en las versiones posteriores de Java. Visite este enlace<\/a> para comprobar la configuraci\u00f3n si no est\u00e1 familiarizado con esta.<\/p>\n
No todas las declaraciones \u00abif-else\u00bb pueden convertirse en construcciones \u00abswitch\u00bb. Puede utilizar las construcciones \u00abif-else\u00bb para definir condiciones complejas que podr\u00edan utilizar una combinaci\u00f3n de variables, constantes o llamadas a m\u00e9todos. Este tipo de comparaciones complejas a\u00fan no son compatibles con las construcciones \u00abswitch\u00bb.\u00a0<\/span><\/p>\n
Para obtener m\u00e1s informaci\u00f3n acerca de la concordancia de patrones, consulte este art\u00edculo del blog<\/a>.<\/p>\n
Ejecutar la inspecci\u00f3n \u00abif can be replaced with switch\u00bb en el c\u00f3digo base<\/h4>\n
Buscar construcciones \u00abif-else\u00bb en el c\u00f3digo y comprobar si pueden sustituirse por \u00abswitch\u00bb lleva tiempo. As\u00ed pues, puede ejecutar la inspecci\u00f3n \u00abif can be replaced with switch\u00bb en todas las clases del c\u00f3digo base o en su subconjunto, tal como se explica en este art\u00edculo del blog<\/a>.<\/p>\n
Ahora nos centraremos en el siguiente ejemplo, que utiliza la concordancia de patrones para \u00abinstanceof\u00bb, una funcionalidad de producci\u00f3n en Java.<\/p>\n
2. Escribir c\u00f3digo conciso utilizando la concordancia de patrones con \u00abinstanceof\u00bb<\/h2>\n
El uso de la concordancia de patrones para el operador instanceof<\/code> ha estado disponible como una funcionalidad de producci\u00f3n desde la versi\u00f3n 16 de Java y se puede utilizar en c\u00f3digo de producci\u00f3n.<\/p>\n
Para utilizar esta funci\u00f3n, seguiremos el ejemplo de IntelliJ IDEA e invocaremos las acciones contextuales sobre la palabra clave if<\/code>,\u00a0que aparece resaltada en amarillo.<\/p>\n
Imagine que tiene una clase llamada Monitor<\/code>. Este es uno de los muchos ejemplos que encontrar\u00e1 en bases de c\u00f3digo para implementar su m\u00e9todo equals<\/code>:<\/p>\n
\n
public class Monitor {\n    String model;\n    double price;\n\n    @Override\n    public boolean equals(Object object) {\n        if (object instanceof Monitor) {\n            Monitor other = (Monitor) object;\n            return model.equals(other.model) && price == other.price;\n        }\n        return false;\n    }\n}\n<\/pre>\n
El siguiente gif muestra c\u00f3mo utilizar la concordancia de patrones invocando acciones contextuales sobre la variable llamada other<\/code>, resaltada en amarillo, y seleccionando la opci\u00f3n \u00abReplace ‘other’ with pattern variable\u00bb. Refactorizar el c\u00f3digo resultante invocando acciones contextuales sobre la sentencia \u00abif\u00bb puede hacer que este c\u00f3digo sea a\u00fan m\u00e1s conciso. El c\u00f3digo final es m\u00e1s f\u00e1cil de leer y entender, ya que devuelve \u00abtrue\u00bb si las tres condiciones mencionadas son verdaderas.<\/p>\n
\"\"<\/figure>\n<\/div>\n
\u00bfQu\u00e9 ocurre si, en lugar de una clase normal, trabaja con una instancia de Record? En el caso de Record, la concordancia de patrones para \u00abinstanceof\u00bb puede deconstruir una instancia de Record definiendo variables de patr\u00f3n para los componentes de Record. En el siguiente ejemplo, el uso de Citizen(String name, int age)<\/code> con el operador instanceof<\/code> es un patr\u00f3n Record:<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Es f\u00e1cil no reparar en el potencial de estas funcionalidades si nos limitamos a mostrar ejemplos de c\u00f3digo sencillos como los dos anteriores. Veamos r\u00e1pidamente otro ejemplo de uso de la concordancia de patrones con el operador \u00abinstanceof\u00bb, en el que la eliminaci\u00f3n de la declaraci\u00f3n de una variable local abre otras posibilidades de refactorizaci\u00f3n o mejora. En resumen, combinar esta funci\u00f3n con otras t\u00e9cnicas de refactorizaci\u00f3n o mejora del c\u00f3digo le ayudar\u00e1 a escribir mejor c\u00f3digo (\u00a1solo tiene que seguir las indicaciones de IntelliJ IDEA!):<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
3. Ignorar los estados que no tienen sentido<\/h2>\n
Una construcci\u00f3n \u00abif-else\u00bb puede no ser la mejor opci\u00f3n para iterar sobre los valores de un tipo que tiene un conjunto exhaustivo de valores, como las enumeraciones o los subtipos de una clase sellada. Por ejemplo, imagine que tiene una enumeraci\u00f3n que define un conjunto fijo de valores, como el siguiente:<\/span><\/p>\n
\n
enum SingleUsePlastic {\n    BOTTLE, SPOON, CARRY_BAG;\n}<\/pre>\n
Aunque sepa que una instancia del tipo SingleUsePlastic<\/code> puede tener cualquiera de los tres valores, es decir, BOTTLE<\/code>, SPOON<\/code> y CARRY_BAG<\/code>, la variable local final replacement<\/code> no compilar\u00eda el siguiente c\u00f3digo:<\/span><\/p>\n<\/div>\n
\n
public class Citizen {\n    String getReplacements(SingleUsePlastic plastic) {\n        final String replacement;\n        if (plastic == SingleUsePlastic.BOTTLE) {\n            replacement = \"Booth 4: Pick up a glass bottle\";\n        } else if (plastic == SingleUsePlastic.SPOON) {\n            replacement = \"Pantry: Pick up a steel spoon\";\n        } else if (plastic == SingleUsePlastic.CARRY_BAG) {\n            replacement = \"Booth 5: Pick up a cloth bag\";\n        } \n        return replacement;\n    }\n}<\/pre>\n
Para que se compile, tendr\u00e1 que a\u00f1adir al final una cl\u00e1usula \u00abelse\u00bb que no tenga sentido.<\/span><\/p>\n
public class Citizen {\n    String getReplacements(SingleUsePlastic plastic) {\n        final String replacement;\n        if (plastic == SingleUsePlastic.BOTTLE) {\n            replacement = \"Booth 4: Pick up a glass bottle\";\n        } else if (plastic == SingleUsePlastic.SPOON) {\n            replacement = \"Pantry: Pick up a steel spoon\";\n        } else if (plastic == SingleUsePlastic.CARRY_BAG) {\n            replacement = \"Booth 5: Pick up a cloth bag\";\n        } else {\n            replacement = \"\";\n        }\n        return replacement;\n    }\n}<\/pre>\n
Con una construcci\u00f3n \u00abswitch\u00bb, no es necesario codificar una parte \u00abdefault\u00bb para valores que no existen:<\/span><\/p>\n<\/div>\n
public class Citizen {\n    String getReplacements(SingleUsePlastic plastic) {\n        final String replacement = switch (plastic) {\n            case BOTTLE -> \"Booth 4: Pick up a glass bottle\";\n            case SPOON -> \"Pantry: Pick up a steel spoon\";\n            case CARRY_BAG -> \"Booth 5: Pick up a cloth bag\";\n        };\n        return replacement;\n    }\n}<\/pre>\n
Del mismo modo, si define una clase sellada, puede utilizar una construcci\u00f3n \u00abswitch\u00bb para iterar sobre su lista exhaustiva de subclases sin definir una cl\u00e1usula \u00abdefault\u00bb:<\/p>\n
sealed interface Lego {}\nfinal class SquareLego implements Lego {}\nnon-sealed class RectangleLogo implements Lego {}\nsealed class CharacterLego implements Lego permits PandaLego {}\nfinal class PandaLego extends CharacterLego {}\n\npublic class MyLegoGame {\n    int processLego(Lego lego) {\n        return switch (lego) {\n            case SquareLego squareLego -> 100;\n            case RectangleLego rectangleLego-> 200;\n            case CharacterLego characterLego -> 300;\n        };\n    }\n}<\/pre>\n
Si no est\u00e1 familiarizado con las clases selladas y quiere obtener m\u00e1s informaci\u00f3n al respecto, este art\u00edculo del blog<\/a> le ser\u00e1 de gran ayuda.<\/p>\n
4. Procesamiento de datos potente y conciso<\/h2>\n
Puede crear c\u00f3digo potente, pero conciso y expresivo al mismo tiempo, para procesar los datos utilizando una combinaci\u00f3n de patrones Record, expresiones \u00abswitch\u00bb y clases selladas. Aqu\u00ed tiene un ejemplo de una interfaz sellada TwoDimensional<\/code>, que se implementa con los Records Point<\/code>, Line<\/code>, Triangle<\/code> y Square<\/code>:<\/p>\n
sealed interface TwoDimensional {}\nrecord Point    (int x, \n                 int y) implements TwoDimensional { }\nrecord Line     (Point start, \n                 Point end) implements TwoDimensional { }\nrecord Triangle (Point pointA, \n                 Point pointB, \n\t\t\t\t Point PointC) implements TwoDimensional { }\nrecord Square   (Point pointA, \n                 Point pointB, \n\t\t\t     Point PointC, \n\t\t\t     Point pointD) implements TwoDimensional { }\n<\/pre>\n
El siguiente m\u00e9todo define un proceso de m\u00e9todo recursivo que utiliza una construcci\u00f3n \u00abswitch\u00bb para devolver la suma de las coordenadas x e y de todos los puntos de una figura bidimensional, como en el caso de Line<\/code>, Triangle<\/code> o Square<\/code>:<\/p>\n
static int process(TwoDimensional twoDim) {\n    return switch (twoDim) {\n        case Point(int x, int y) -> x + y;\n        case Line(Point a, Point b) -> process(a) + process(b);\n        case Triangle(Point a, Point b, Point c) -> process(a) + process(b) + process(c);\n        case Square(Point a, Point b, Point c, Point d) -> process(a) + process(b) + process(c) + process(d);\n    };\n}\n<\/pre>\n
IntelliJ IDEA tambi\u00e9n muestra el icono de llamada recursiva en el medianil para este m\u00e9todo:<\/p>\n
\u00a0<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
5. Separaci\u00f3n de c\u00e1lculo y efecto secundario<\/h2>\n
No es extra\u00f1o encontrarse con c\u00f3digo que combine un c\u00e1lculo y un efecto secundario (como imprimir en la consola) en el mismo bloque de c\u00f3digo. Por ejemplo, el siguiente c\u00f3digo utiliza un bloque \u00abif-else\u00bb y el operador instanceof<\/code> para determinar el tipo de una variable y devuelve un valor condicional en cada bloque de c\u00f3digo \u00abif\u00bb.<\/p>\n
void printObject(Object obj) {\n    if (obj instanceof String s) {\n        System.out.println(\"String: \"\" + s + \"\"\");\n    } else if (obj instanceof Collection<?> c) {\n        System.out.println(\"Collection (size = \" + c.size() + \")\");\n    } else {\n        System.out.println(\"Other object: \" + obj);\n    }\n}\n<\/pre>\n
El siguiente gif muestra c\u00f3mo se puede convertir este bloque \u00abif-else\u00bb en una construcci\u00f3n \u00abswitch\u00bb y, despu\u00e9s, utilizar una nueva inspecci\u00f3n en \u00abswitch\u00bb (\u00abPush down ‘switch’ expression\u00bb), seguida de la extracci\u00f3n de una variable para separar el c\u00e1lculo y sus efectos secundarios:<\/p>\n
\"\"<\/figure>\n
\u00a0<\/p>\n
Resumen<\/h2>\n
En este art\u00edculo del blog, hemos presentado cinco entornos en los que los desarrolladores con poco tiempo libre pueden utilizar la concordancia de patrones en Java. Si quiere obtener m\u00e1s informaci\u00f3n acerca de estas funcionalidades o c\u00f3mo ayuda IntelliJ IDEA a usarlas, consulte los enlaces que hemos incluido en los ejemplos.<\/p>\n
D\u00edganos sobre qu\u00e9 otros temas le gustar\u00eda leer en el pr\u00f3ximo art\u00edculo del blog.<\/p>\n
Hasta entonces, \u00a1feliz programaci\u00f3n!<\/p>\n
Art\u00edculo original en ingl\u00e9s de<\/em><\/p>\n\n    
\n        
\n            
\n                
\n                    \"\"\n                <\/div>\n                
\n                                                        <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n","protected":false},"author":1086,"featured_media":320082,"comment_status":"closed","ping_status":"closed","template":"","categories":[4759,5088],"tags":[40,155],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/idea\/335948"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/idea"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/types\/idea"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/users\/1086"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/comments?post=335948"}],"version-history":[{"count":6,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/idea\/335948\/revisions"}],"predecessor-version":[{"id":335955,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/idea\/335948\/revisions\/335955"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media\/320082"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media?parent=335948"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/categories?post=335948"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/tags?post=335948"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/cross-post-tag?post=335948"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}