[{"data":1,"prerenderedAt":1380},["ShallowReactive",2],{"navigation_docs":3,"-arreglos-hashmap":412,"-arreglos-hashmap-surround":1375},[4,18,43,118,160,200,231,320,346],{"title":5,"path":6,"stem":7,"children":8,"icon":17},"Evaluación","\u002Fintroduction","1.introduction\u002F1.index",[9,12],{"title":10,"path":6,"stem":7,"icon":11},"Método de Evaluación","i-iconamoon-cheque-bold",{"title":13,"path":14,"stem":15,"icon":16},"Plataforma de Aprendizaje","\u002Fintroduction\u002Fplataforma","1.introduction\u002F2.plataforma","i-lucide-book-marked","i-lucide-house",{"title":19,"icon":20,"path":21,"stem":22,"children":23,"page":42},"Entorno de desarrollo","i-codicon-edit-code","\u002Fide","2.ide",[24,28,33,37],{"title":25,"path":26,"stem":27,"icon":20},"¿Qué es un IDE?","\u002Fide\u002Fentorno","2.ide\u002F1.entorno",{"title":29,"path":30,"stem":31,"icon":32},"Estructura de un Proyecto","\u002Fide\u002Festructura","2.ide\u002F2.estructura","i-clarity-tree-view-line",{"title":34,"path":35,"stem":36,"icon":20},"La compilación en un IDE","\u002Fide\u002Fcompilacion","2.ide\u002F3.compilacion",{"title":38,"path":39,"stem":40,"icon":41},"Depuración de Código","\u002Fide\u002Fdepurar","2.ide\u002F4.depurar","i-lucide-bug",false,{"title":44,"icon":45,"path":46,"stem":47,"children":48,"page":42},"Clases y Objetos","i-catppuccin-java-class","\u002Fclases-objetos","3.clases-objetos",[49,53,57,62,66,70,74,78,83,88,92,96,101,106,110,114],{"title":50,"path":51,"stem":52},"Repaso previo a Clases y Objetos","\u002Fclases-objetos\u002Fpreview","3.clases-objetos\u002F00.preview",{"title":54,"path":55,"stem":56,"icon":45},"¿Qué es la Programación Orientada a Objetos (POO)?","\u002Fclases-objetos\u002Fpoo","3.clases-objetos\u002F01.poo",{"title":58,"path":59,"stem":60,"icon":61},"Diagramas de Clases y Objetos","\u002Fclases-objetos\u002Fdiagramas","3.clases-objetos\u002F02.diagramas","i-devicon-uml",{"title":63,"path":64,"stem":65,"icon":45},"Las Clases","\u002Fclases-objetos\u002Fclases","3.clases-objetos\u002F03.clases",{"title":67,"path":68,"stem":69,"icon":45},"Ámbito y Visibilidad","\u002Fclases-objetos\u002Fambito","3.clases-objetos\u002F04.ambito",{"title":71,"path":72,"stem":73,"icon":45},"Declaración e Instanciación de Objetos","\u002Fclases-objetos\u002Fobjetos","3.clases-objetos\u002F05.objetos",{"title":75,"path":76,"stem":77,"icon":45},"Clases Predefinidas en Java","\u002Fclases-objetos\u002Fpredefinidas","3.clases-objetos\u002F06.predefinidas",{"title":79,"path":80,"stem":81,"icon":82},"Paquetes en Java","\u002Fclases-objetos\u002Fpaquetes","3.clases-objetos\u002F07.paquetes","i-material-icon-theme-folder-java-open",{"title":84,"path":85,"stem":86,"icon":87},"Las Excepciones","\u002Fclases-objetos\u002Fexcepciones","3.clases-objetos\u002F08.excepciones","i-catppuccin-java-exception",{"title":89,"path":90,"stem":91,"icon":45},"La clase JOptionPane","\u002Fclases-objetos\u002Fjoptionpane","3.clases-objetos\u002F09.joptionpane",{"title":93,"path":94,"stem":95,"icon":45},"Constructores y Accesores","\u002Fclases-objetos\u002Fconstructores","3.clases-objetos\u002F10.constructores",{"title":97,"path":98,"stem":99,"icon":100},"Tipos Enumerados (Enums)","\u002Fclases-objetos\u002Fenumerados","3.clases-objetos\u002F11.enumerados","i-catppuccin-java-enum",{"title":102,"path":103,"stem":104,"icon":105},"Modificadores de acceso static y final","\u002Fclases-objetos\u002Fmodificadores","3.clases-objetos\u002F12.modificadores","i-mdi-chart-box",{"title":107,"path":108,"stem":109,"icon":105},"El casting en Java","\u002Fclases-objetos\u002Fcasting","3.clases-objetos\u002F13.casting",{"title":111,"path":112,"stem":113},"Las Expresiones Regulares","\u002Fclases-objetos\u002Fexpresiones-regulares","3.clases-objetos\u002F14.expresiones-regulares",{"title":115,"path":116,"stem":117,"icon":105},"Clases Genéricas en Java","\u002Fclases-objetos\u002Fclases-genericas","3.clases-objetos\u002F15.clases-genericas",{"title":119,"icon":120,"path":121,"stem":122,"children":123,"page":42},"Funciones (Métodos)","i-material-symbols-function","\u002Fmetodos","4.metodos",[124,128,132,136,140,144,148,152,156],{"title":125,"path":126,"stem":127},"Funciones Genéricas","\u002Fmetodos\u002Ffuncion-generica","4.metodos\u002F01.funcion-generica",{"title":129,"path":130,"stem":131},"Métodos de Instancia y de Clase","\u002Fmetodos\u002Finstancia-clase","4.metodos\u002F02.instancia-clase",{"title":133,"path":134,"stem":135},"Sobrecarga de Funciones","\u002Fmetodos\u002Fsobrecarga","4.metodos\u002F03.sobrecarga",{"title":137,"path":138,"stem":139},"Alcance de Variables y Métodos","\u002Fmetodos\u002Falcance","4.metodos\u002F04.alcance",{"title":141,"path":142,"stem":143},"Recursividad","\u002Fmetodos\u002Frecursividad","4.metodos\u002F05.recursividad",{"title":145,"path":146,"stem":147},"Puntero this","\u002Fmetodos\u002Fthis","4.metodos\u002F06.this",{"title":149,"path":150,"stem":151},"Los argumentos variables (varargs)","\u002Fmetodos\u002Fvarargs","4.metodos\u002F07.varargs",{"title":153,"path":154,"stem":155},"La clase Arrays","\u002Fmetodos\u002Farrays","4.metodos\u002F08.arrays",{"title":157,"path":158,"stem":159},"Predicados Simples y Compuestos en Java","\u002Fmetodos\u002Fpredicados","4.metodos\u002F09.predicados",{"title":161,"path":162,"stem":163,"children":164,"icon":199},"Herencia","\u002Fherencia","5.herencia\u002F01.index",[165,167,171,175,179,183,187,191,195],{"title":166,"path":162,"stem":163},"¿Qué es la herencia?",{"title":168,"path":169,"stem":170},"Sobreescritura de métodos y uso de `super`","\u002Fherencia\u002Fsobeescritura","5.herencia\u002F02.sobeescritura",{"title":172,"path":173,"stem":174},"Tipos de herencia","\u002Fherencia\u002Ftipos-herencia","5.herencia\u002F03.tipos-herencia",{"title":176,"path":177,"stem":178},"La clase Object en Java","\u002Fherencia\u002Fobject","5.herencia\u002F04.object",{"title":180,"path":181,"stem":182},"Polimorfismo","\u002Fherencia\u002Fpolimorfismo","5.herencia\u002F05.polimorfismo",{"title":184,"path":185,"stem":186},"Clases y Funciones Abstractas","\u002Fherencia\u002Fabstract","5.herencia\u002F06.abstract",{"title":188,"path":189,"stem":190},"Interfaces","\u002Fherencia\u002Finterfaces","5.herencia\u002F07.interfaces",{"title":192,"path":193,"stem":194},"Funciones e Interfaces","\u002Fherencia\u002Ffunciones-interfaces","5.herencia\u002F08.funciones-interfaces",{"title":196,"path":197,"stem":198},"Interfaces y Funciones Lambda","\u002Fherencia\u002Flambda-interface","5.herencia\u002F09.lambda-interface","i-material-symbols-heritage",{"title":201,"path":202,"stem":203,"children":204,"icon":199},"Arreglos","\u002Farreglos","6.arreglos\u002F01.index",[205,207,211,215,219,223,227],{"title":206,"path":202,"stem":203},"Los arreglos en Java",{"title":208,"path":209,"stem":210},"Los arreglos","\u002Farreglos\u002Farray","6.arreglos\u002F02.array",{"title":212,"path":213,"stem":214},"Matrices","\u002Farreglos\u002Fmatrices","6.arreglos\u002F03.matrices",{"title":216,"path":217,"stem":218},"Comparadores","\u002Farreglos\u002Fcomparator","6.arreglos\u002F04.comparator",{"title":220,"path":221,"stem":222},"Arreglos dinámicos: ArrayList","\u002Farreglos\u002Farraylist","6.arreglos\u002F05.arraylist",{"title":224,"path":225,"stem":226},"Arreglos Relacionales: HashMap","\u002Farreglos\u002Fhashmap","6.arreglos\u002F06.hashmap",{"title":228,"path":229,"stem":230},"La clase Stream en Java","\u002Farreglos\u002Fstream","6.arreglos\u002F07.stream",{"title":232,"icon":199,"path":233,"stem":234,"children":235,"page":42},"Archivos e Interfaz de Usuario","\u002Farchivos-ui","7.archivos-ui",[236,240,244,248,252,256,260,264,268,272,276,280,284,288,292,296,300,304,308,312,316],{"title":237,"path":238,"stem":239},"El paquete Swing","\u002Farchivos-ui\u002Fswing","7.archivos-ui\u002F01.swing",{"title":241,"path":242,"stem":243},"La clase JFrame y el JPanel","\u002Farchivos-ui\u002Fjpanel","7.archivos-ui\u002F02.jpanel",{"title":245,"path":246,"stem":247},"Los Layouts en Swing","\u002Farchivos-ui\u002Flayout","7.archivos-ui\u002F03.layout",{"title":249,"path":250,"stem":251},"Iniciando con Swing","\u002Farchivos-ui\u002Finiciando","7.archivos-ui\u002F04.iniciando",{"title":253,"path":254,"stem":255},"Las clases Color y Font en Swing","\u002Farchivos-ui\u002Fcolor-font","7.archivos-ui\u002F05.color-font",{"title":257,"path":258,"stem":259},"Etiquetas en Swing","\u002Farchivos-ui\u002Fetiquetas","7.archivos-ui\u002F06.etiquetas",{"title":261,"path":262,"stem":263},"Personalizando la apariencia de los componentes en Swing","\u002Farchivos-ui\u002Fpersonalizando","7.archivos-ui\u002F07.personalizando",{"title":265,"path":266,"stem":267},"Sobrescribiendo el método drawComponent() en Swing","\u002Farchivos-ui\u002Fdraw","7.archivos-ui\u002F08.draw",{"title":269,"path":270,"stem":271},"Manejando eventos en Swing","\u002Farchivos-ui\u002Feventos","7.archivos-ui\u002F09.eventos",{"title":273,"path":274,"stem":275},"Personalización de Componentes mediante la Extensión de Clases en Swing","\u002Farchivos-ui\u002Fextends-component","7.archivos-ui\u002F10.extends-component",{"title":277,"path":278,"stem":279},"Gradientes","\u002Farchivos-ui\u002Fgradientes","7.archivos-ui\u002F11.gradientes",{"title":281,"path":282,"stem":283},"Botones en Swing","\u002Farchivos-ui\u002Fbotones","7.archivos-ui\u002F12.botones",{"title":285,"path":286,"stem":287},"Los delegadores en Swing","\u002Farchivos-ui\u002Fdelegadores","7.archivos-ui\u002F13.delegadores",{"title":289,"path":290,"stem":291},"UI para nuestro RPG: Parte 1","\u002Farchivos-ui\u002Frpg-ui-1","7.archivos-ui\u002F14.rpg-ui-1",{"title":293,"path":294,"stem":295},"UI para nuestro RPG: Parte 2","\u002Farchivos-ui\u002Frpg-ui-2","7.archivos-ui\u002F15.rpg-ui-2",{"title":297,"path":298,"stem":299},"Los Streams Entrada y Salida","\u002Farchivos-ui\u002Fstreams","7.archivos-ui\u002F16.streams",{"title":301,"path":302,"stem":303},"Archivo tipo Objeto","\u002Farchivos-ui\u002Farchivo-objeto","7.archivos-ui\u002F17.archivo-objeto",{"title":305,"path":306,"stem":307},"UI para nuestro RPG: Parte 3","\u002Farchivos-ui\u002Frpg-ui-3","7.archivos-ui\u002F18.rpg-ui-3",{"title":309,"path":310,"stem":311},"UI para nuestro RPG: Parte 4","\u002Farchivos-ui\u002Frpg-ui-4","7.archivos-ui\u002F19.rpg-ui-4",{"title":313,"path":314,"stem":315},"UI para nuestro RPG: Parte 5","\u002Farchivos-ui\u002Frpg-ui-5","7.archivos-ui\u002F20.rpg-ui-5",{"title":317,"path":318,"stem":319},"UI para nuestro RPG: Parte 6","\u002Farchivos-ui\u002Frpg-ui-6","7.archivos-ui\u002F21.rpg-ui-6",{"title":321,"icon":322,"path":323,"stem":324,"children":325,"page":42},"Ejemplos","i-check-circle","\u002Fejemplos","8.ejemplos",[326,330,334,338,342],{"title":327,"path":328,"stem":329,"icon":105},"Ejemplo 1: Validando entradas con JOptionPane","\u002Fejemplos\u002Fejemplo-01","8.ejemplos\u002F01.ejemplo-01",{"title":331,"path":332,"stem":333},"Ejemplo 02: Uso de clases genéricas en Java","\u002Fejemplos\u002Fejemplo-02","8.ejemplos\u002F02.ejemplo-02",{"title":335,"path":336,"stem":337},"Ejemplo 03: Uso de Enum, Excepciones en Java","\u002Fejemplos\u002Fejemplo-03","8.ejemplos\u002F03.ejemplo-03",{"title":339,"path":340,"stem":341},"Ejemplo 4: Clase con funciones genéricas de validación","\u002Fejemplos\u002Fejemplo-04","8.ejemplos\u002F04.ejemplo-04",{"title":343,"path":344,"stem":345},"Ejemplo 5: Sistema de Gestión de Empleados","\u002Fejemplos\u002Fejemplo-05","8.ejemplos\u002F05.ejemplo-05",{"title":347,"icon":322,"path":348,"stem":349,"children":350,"page":42},"Actividades","\u002Factividades","9.actividades",[351,355,360,364,368,372,376,380,384,388,392,396,400,404,408],{"title":352,"path":353,"stem":354,"icon":105},"Actividad 1: Infografía sobre el proceso de compilación","\u002Factividades\u002Fact-01","9.actividades\u002F01.act-01",{"title":356,"path":357,"stem":358,"icon":359},"Actividad 2: Modelando Diagramas de Clases UML","\u002Factividades\u002Fact-02","9.actividades\u002F02.act-02","i-material-icon-theme-uml",{"title":361,"path":362,"stem":363,"icon":45},"Actividad 3: Creando Clases y Objetos en Java","\u002Factividades\u002Fact-03","9.actividades\u002F03.act-03",{"title":365,"path":366,"stem":367},"Actividad 4: Validando entradas de datos","\u002Factividades\u002Fact-04","9.actividades\u002F04.act-04",{"title":369,"path":370,"stem":371,"icon":105},"Actividad 5: Implementando una clase genérica","\u002Factividades\u002Fact-05","9.actividades\u002F05.act-05",{"title":373,"path":374,"stem":375,"icon":105},"Actividad 6: Expandiendo InputValidator con Predicados y Function","\u002Factividades\u002Fact-06","9.actividades\u002F06.act-06",{"title":377,"path":378,"stem":379,"icon":105},"Actividad 7: Gestor de Biblioteca con InputValidator","\u002Factividades\u002Fact-07","9.actividades\u002F07.act-07",{"title":381,"path":382,"stem":383,"icon":105},"Actividad 8: Calculadora de Figuras Geométricas","\u002Factividades\u002Fact-08","9.actividades\u002F08.act-08",{"title":385,"path":386,"stem":387,"icon":105},"Actividad 9: gestión de una empresa agroalimentaria","\u002Factividades\u002Fact-09","9.actividades\u002F09.act-09",{"title":389,"path":390,"stem":391,"icon":105},"Actividad 10: Sistema de gestión de clínicas veterinarias","\u002Factividades\u002Fact-10","9.actividades\u002F10.act-10",{"title":393,"path":394,"stem":395},"Definición de Proyecto Evolutivo","\u002Factividades\u002Frpg","9.actividades\u002F11.rpg",{"title":397,"path":398,"stem":399},"Actividad 11: Creación de Personajes","\u002Factividades\u002Fact-11","9.actividades\u002F12.act-11",{"title":401,"path":402,"stem":403},"Actividad 12: El Inventario y los Objetos","\u002Factividades\u002Fact-12","9.actividades\u002F13.act-12",{"title":405,"path":406,"stem":407},"Actividad 13: El combate por turnos","\u002Factividades\u002Fact-13","9.actividades\u002F14.act-13",{"title":409,"path":410,"stem":411},"Actividad 14: Guardando y Cargando","\u002Factividades\u002Fact-14","9.actividades\u002F15.act-14",{"id":413,"title":224,"body":414,"description":1369,"extension":1370,"links":1371,"meta":1372,"navigation":484,"path":225,"seo":1373,"stem":226,"__hash__":1374},"docs\u002F6.arreglos\u002F06.hashmap.md",{"type":415,"value":416,"toc":1356},"minimark",[417,422,435,439,446,451,457,553,563,577,581,591,638,641,668,674,745,756,760,768,815,825,851,857,888,892,900,921,927,951,955,963,1014,1022,1114,1118,1126,1152,1156,1170,1259,1265,1299,1305,1339,1343,1352],[418,419,421],"h2",{"id":420},"qué-es-un-arreglo-relacional","¿Qué es un arreglo relacional?",[423,424,425,426,430,431,434],"p",{},"Un arreglo relacional es una estructura de datos que permite almacenar pares clave-valor de manera eficiente. En Java, la clase ",[427,428,429],"code",{},"HashMap"," es una implementación de un arreglo relacional que forma parte del paquete ",[427,432,433],{},"java.util",". Esta clase proporciona métodos para agregar, eliminar y acceder a los elementos de la colección de manera eficiente.",[418,436,438],{"id":437},"hashmap-en-java","HashMap en Java",[423,440,441,442,430,444,434],{},"Dentro de Java, la clase ",[427,443,429],{},[427,445,433],{},[447,448,450],"h3",{"id":449},"creación-de-un-hashmap","Creación de un HashMap",[423,452,453,454,456],{},"Para crear un ",[427,455,429],{},", puedes usar la siguiente sintaxis:",[458,459,464],"pre",{"className":460,"code":461,"language":462,"meta":463,"style":463},"language-java shiki shiki-themes github-dark","import java.util.HashMap;\n\npublic class Main {\n    void main() {\n        HashMap\u003CString, Integer> mapa = new HashMap\u003C>();\n    }\n}\n","java","",[427,465,466,479,486,502,514,541,547],{"__ignoreMap":463},[467,468,471,475],"span",{"class":469,"line":470},"line",1,[467,472,474],{"class":473},"snl16","import",[467,476,478],{"class":477},"s95oV"," java.util.HashMap;\n",[467,480,482],{"class":469,"line":481},2,[467,483,485],{"emptyLinePlaceholder":484},true,"\n",[467,487,489,492,495,499],{"class":469,"line":488},3,[467,490,491],{"class":473},"public",[467,493,494],{"class":473}," class",[467,496,498],{"class":497},"svObZ"," Main",[467,500,501],{"class":477}," {\n",[467,503,505,508,511],{"class":469,"line":504},4,[467,506,507],{"class":473},"    void",[467,509,510],{"class":497}," main",[467,512,513],{"class":477},"() {\n",[467,515,517,520,523,526,529,532,535,538],{"class":469,"line":516},5,[467,518,519],{"class":477},"        HashMap\u003C",[467,521,522],{"class":473},"String",[467,524,525],{"class":477},", ",[467,527,528],{"class":473},"Integer",[467,530,531],{"class":477},"> mapa ",[467,533,534],{"class":473},"=",[467,536,537],{"class":473}," new",[467,539,540],{"class":477}," HashMap\u003C>();\n",[467,542,544],{"class":469,"line":543},6,[467,545,546],{"class":477},"    }\n",[467,548,550],{"class":469,"line":549},7,[467,551,552],{"class":477},"}\n",[423,554,555,556,559,560,562],{},"Como puedes notar, se utiliza la sintaxis de genéricos ",[427,557,558],{},"\u003CString, Integer>"," para especificar el tipo de clave y valor que se almacenarán en el mapa. En este caso, estamos creando un ",[427,561,429],{}," donde las claves son cadenas de texto y los valores son números enteros. Sin embargo, puedes almacenar cualquier tipo de dato como clave o valor, como objetos personalizados, listas, etc.",[564,565,566,567,569,570,572,573,576],"tip",{},"Recuerda que las claves en un ",[427,568,429],{}," deben ser únicas. Si intentas agregar un par clave-valor con una clave que ya existe en el mapa, el valor asociado a esa clave se actualizará con el nuevo valor. Por lo tanto, es importante asegurarse de que las claves sean únicas para evitar sobrescribir datos importantes. Además, ten en cuenta que el orden de los elementos en un ",[427,571,429],{}," no está garantizado, ya que se basa en la función hash de las claves. Si necesitas mantener el orden de inserción, puedes considerar usar ",[427,574,575],{},"LinkedHashMap"," en su lugar.",[418,578,580],{"id":579},"agregar-elementos-a-un-hashmap","Agregar elementos a un HashMap",[423,582,583,584,586,587,590],{},"Para agregar elementos a un ",[427,585,429],{},", puedes usar el método ",[427,588,589],{},"put()",":",[458,592,594],{"className":460,"code":593,"language":462,"meta":463,"style":463},"mapa.put(\"clave1\", 100);\nmapa.put(\"clave2\", 200);\n",[427,595,596,620],{"__ignoreMap":463},[467,597,598,601,604,607,611,613,617],{"class":469,"line":470},[467,599,600],{"class":477},"mapa.",[467,602,603],{"class":497},"put",[467,605,606],{"class":477},"(",[467,608,610],{"class":609},"sU2Wk","\"clave1\"",[467,612,525],{"class":477},[467,614,616],{"class":615},"sDLfK","100",[467,618,619],{"class":477},");\n",[467,621,622,624,626,628,631,633,636],{"class":469,"line":481},[467,623,600],{"class":477},[467,625,603],{"class":497},[467,627,606],{"class":477},[467,629,630],{"class":609},"\"clave2\"",[467,632,525],{"class":477},[467,634,635],{"class":615},"200",[467,637,619],{"class":477},[423,639,640],{},"Esto agrega dos pares clave-valor al mapa, donde \"clave1\" está asociada con el valor 100 y \"clave2\" con el valor 200. Si intentas agregar un par clave-valor con una clave que ya existe en el mapa, el valor asociado a esa clave se actualizará con el nuevo valor. Por ejemplo:",[458,642,644],{"className":460,"code":643,"language":462,"meta":463,"style":463},"mapa.put(\"clave1\", 300); \u002F\u002F Esto actualizará el valor asociado a \"clave1\" a 300\n",[427,645,646],{"__ignoreMap":463},[467,647,648,650,652,654,656,658,661,664],{"class":469,"line":470},[467,649,600],{"class":477},[467,651,603],{"class":497},[467,653,606],{"class":477},[467,655,610],{"class":609},[467,657,525],{"class":477},[467,659,660],{"class":615},"300",[467,662,663],{"class":477},"); ",[467,665,667],{"class":666},"sAwPA","\u002F\u002F Esto actualizará el valor asociado a \"clave1\" a 300\n",[423,669,670,671,590],{},"De igual manera, puedes agregar varios pares clave-valor a la vez utilizando el método ",[427,672,673],{},"putAll()",[458,675,677],{"className":460,"code":676,"language":462,"meta":463,"style":463},"HashMap\u003CString, Integer> otroMapa = new HashMap\u003C>();\notroMapa.put(\"clave3\", 300);\notroMapa.put(\"clave4\", 400);\nmapa.putAll(otroMapa);\n",[427,678,679,699,717,735],{"__ignoreMap":463},[467,680,681,684,686,688,690,693,695,697],{"class":469,"line":470},[467,682,683],{"class":477},"HashMap\u003C",[467,685,522],{"class":473},[467,687,525],{"class":477},[467,689,528],{"class":473},[467,691,692],{"class":477},"> otroMapa ",[467,694,534],{"class":473},[467,696,537],{"class":473},[467,698,540],{"class":477},[467,700,701,704,706,708,711,713,715],{"class":469,"line":481},[467,702,703],{"class":477},"otroMapa.",[467,705,603],{"class":497},[467,707,606],{"class":477},[467,709,710],{"class":609},"\"clave3\"",[467,712,525],{"class":477},[467,714,660],{"class":615},[467,716,619],{"class":477},[467,718,719,721,723,725,728,730,733],{"class":469,"line":488},[467,720,703],{"class":477},[467,722,603],{"class":497},[467,724,606],{"class":477},[467,726,727],{"class":609},"\"clave4\"",[467,729,525],{"class":477},[467,731,732],{"class":615},"400",[467,734,619],{"class":477},[467,736,737,739,742],{"class":469,"line":504},[467,738,600],{"class":477},[467,740,741],{"class":497},"putAll",[467,743,744],{"class":477},"(otroMapa);\n",[423,746,747,748,751,752,755],{},"Esto agregará los pares clave-valor del ",[427,749,750],{},"otroMapa"," al ",[427,753,754],{},"mapa",", resultando en un mapa que contiene \"clave1\" con valor 300, \"clave2\" con valor 200, \"clave3\" con valor 300 y \"clave4\" con valor 400.",[418,757,759],{"id":758},"acceder-a-elementos-en-un-hashmap","Acceder a elementos en un HashMap",[423,761,762,763,586,765,590],{},"Para acceder a los elementos de un ",[427,764,429],{},[427,766,767],{},"get()",[458,769,771],{"className":460,"code":770,"language":462,"meta":463,"style":463},"Integer valor1 = mapa.get(\"clave1\"); \u002F\u002F 300\nInteger valor2 = mapa.get(\"clave2\"); \u002F\u002F 200\n",[427,772,773,795],{"__ignoreMap":463},[467,774,775,778,780,783,786,788,790,792],{"class":469,"line":470},[467,776,777],{"class":477},"Integer valor1 ",[467,779,534],{"class":473},[467,781,782],{"class":477}," mapa.",[467,784,785],{"class":497},"get",[467,787,606],{"class":477},[467,789,610],{"class":609},[467,791,663],{"class":477},[467,793,794],{"class":666},"\u002F\u002F 300\n",[467,796,797,800,802,804,806,808,810,812],{"class":469,"line":481},[467,798,799],{"class":477},"Integer valor2 ",[467,801,534],{"class":473},[467,803,782],{"class":477},[467,805,785],{"class":497},[467,807,606],{"class":477},[467,809,630],{"class":609},[467,811,663],{"class":477},[467,813,814],{"class":666},"\u002F\u002F 200\n",[423,816,817,818,820,821,824],{},"Esto te permitirá obtener el valor asociado a una clave específica. Si la clave no existe en el mapa, el método ",[427,819,767],{}," devolverá ",[427,822,823],{},"null",". Por ejemplo:",[458,826,828],{"className":460,"code":827,"language":462,"meta":463,"style":463},"Integer valorInexistente = mapa.get(\"claveInexistente\"); \u002F\u002F null\n",[427,829,830],{"__ignoreMap":463},[467,831,832,835,837,839,841,843,846,848],{"class":469,"line":470},[467,833,834],{"class":477},"Integer valorInexistente ",[467,836,534],{"class":473},[467,838,782],{"class":477},[467,840,785],{"class":497},[467,842,606],{"class":477},[467,844,845],{"class":609},"\"claveInexistente\"",[467,847,663],{"class":477},[467,849,850],{"class":666},"\u002F\u002F null\n",[423,852,853,854,590],{},"Sin embargo puedes devolver un valor predeterminado en caso de que la clave no exista utilizando el método ",[427,855,856],{},"getOrDefault()",[458,858,860],{"className":460,"code":859,"language":462,"meta":463,"style":463},"Integer valorPredeterminado = mapa.getOrDefault(\"claveInexistente\", 0); \u002F\u002F Esto devolverá 0 en lugar de null\n",[427,861,862],{"__ignoreMap":463},[467,863,864,867,869,871,874,876,878,880,883,885],{"class":469,"line":470},[467,865,866],{"class":477},"Integer valorPredeterminado ",[467,868,534],{"class":473},[467,870,782],{"class":477},[467,872,873],{"class":497},"getOrDefault",[467,875,606],{"class":477},[467,877,845],{"class":609},[467,879,525],{"class":477},[467,881,882],{"class":615},"0",[467,884,663],{"class":477},[467,886,887],{"class":666},"\u002F\u002F Esto devolverá 0 en lugar de null\n",[418,889,891],{"id":890},"eliminar-elementos-de-un-hashmap","Eliminar elementos de un HashMap",[423,893,894,895,586,897,590],{},"Para eliminar elementos de un ",[427,896,429],{},[427,898,899],{},"remove()",[458,901,903],{"className":460,"code":902,"language":462,"meta":463,"style":463},"mapa.remove(\"clave1\"); \u002F\u002F Esto eliminará el par clave-valor asociado a \"clave1\"\n",[427,904,905],{"__ignoreMap":463},[467,906,907,909,912,914,916,918],{"class":469,"line":470},[467,908,600],{"class":477},[467,910,911],{"class":497},"remove",[467,913,606],{"class":477},[467,915,610],{"class":609},[467,917,663],{"class":477},[467,919,920],{"class":666},"\u002F\u002F Esto eliminará el par clave-valor asociado a \"clave1\"\n",[423,922,923,924,926],{},"También puedes eliminar un elemento por su valor utilizando el método ",[427,925,899],{}," con dos parámetros:",[458,928,930],{"className":460,"code":929,"language":462,"meta":463,"style":463},"mapa.remove(\"clave2\", 200); \u002F\u002F Esto eliminará el par clave-valor asociado a \"clave2\" solo si su valor es 200\n",[427,931,932],{"__ignoreMap":463},[467,933,934,936,938,940,942,944,946,948],{"class":469,"line":470},[467,935,600],{"class":477},[467,937,911],{"class":497},[467,939,606],{"class":477},[467,941,630],{"class":609},[467,943,525],{"class":477},[467,945,635],{"class":615},[467,947,663],{"class":477},[467,949,950],{"class":666},"\u002F\u002F Esto eliminará el par clave-valor asociado a \"clave2\" solo si su valor es 200\n",[418,952,954],{"id":953},"verificar-la-existencia-de-claves-o-valores-en-un-hashmap","Verificar la existencia de claves o valores en un HashMap",[423,956,957,958,586,960,590],{},"Para verificar si una clave existe en un ",[427,959,429],{},[427,961,962],{},"containsKey()",[458,964,966],{"className":460,"code":965,"language":462,"meta":463,"style":463},"boolean existeClave1 = mapa.containsKey(\"clave1\"); \u002F\u002F false, ya que \"clave1\" fue eliminada\nboolean existeClave2 = mapa.containsKey(\"clave2\"); \u002F\u002F true\n",[427,967,968,992],{"__ignoreMap":463},[467,969,970,973,976,978,980,983,985,987,989],{"class":469,"line":470},[467,971,972],{"class":473},"boolean",[467,974,975],{"class":477}," existeClave1 ",[467,977,534],{"class":473},[467,979,782],{"class":477},[467,981,982],{"class":497},"containsKey",[467,984,606],{"class":477},[467,986,610],{"class":609},[467,988,663],{"class":477},[467,990,991],{"class":666},"\u002F\u002F false, ya que \"clave1\" fue eliminada\n",[467,993,994,996,999,1001,1003,1005,1007,1009,1011],{"class":469,"line":481},[467,995,972],{"class":473},[467,997,998],{"class":477}," existeClave2 ",[467,1000,534],{"class":473},[467,1002,782],{"class":477},[467,1004,982],{"class":497},[467,1006,606],{"class":477},[467,1008,630],{"class":609},[467,1010,663],{"class":477},[467,1012,1013],{"class":666},"\u002F\u002F true\n",[423,1015,1016,1017,586,1019,590],{},"Para verificar si un valor existe en un ",[427,1018,429],{},[427,1020,1021],{},"containsValue()",[458,1023,1025],{"className":460,"code":1024,"language":462,"meta":463,"style":463},"boolean existeValor200 = mapa.containsValue(200); \u002F\u002F true\nboolean existeValor300 = mapa.containsValue(300); \u002F\u002F true\nboolean existeValor400 = mapa.containsValue(400); \u002F\u002F true\nboolean existeValor500 = mapa.containsValue(500); \u002F\u002F false\n",[427,1026,1027,1049,1070,1091],{"__ignoreMap":463},[467,1028,1029,1031,1034,1036,1038,1041,1043,1045,1047],{"class":469,"line":470},[467,1030,972],{"class":473},[467,1032,1033],{"class":477}," existeValor200 ",[467,1035,534],{"class":473},[467,1037,782],{"class":477},[467,1039,1040],{"class":497},"containsValue",[467,1042,606],{"class":477},[467,1044,635],{"class":615},[467,1046,663],{"class":477},[467,1048,1013],{"class":666},[467,1050,1051,1053,1056,1058,1060,1062,1064,1066,1068],{"class":469,"line":481},[467,1052,972],{"class":473},[467,1054,1055],{"class":477}," existeValor300 ",[467,1057,534],{"class":473},[467,1059,782],{"class":477},[467,1061,1040],{"class":497},[467,1063,606],{"class":477},[467,1065,660],{"class":615},[467,1067,663],{"class":477},[467,1069,1013],{"class":666},[467,1071,1072,1074,1077,1079,1081,1083,1085,1087,1089],{"class":469,"line":488},[467,1073,972],{"class":473},[467,1075,1076],{"class":477}," existeValor400 ",[467,1078,534],{"class":473},[467,1080,782],{"class":477},[467,1082,1040],{"class":497},[467,1084,606],{"class":477},[467,1086,732],{"class":615},[467,1088,663],{"class":477},[467,1090,1013],{"class":666},[467,1092,1093,1095,1098,1100,1102,1104,1106,1109,1111],{"class":469,"line":504},[467,1094,972],{"class":473},[467,1096,1097],{"class":477}," existeValor500 ",[467,1099,534],{"class":473},[467,1101,782],{"class":477},[467,1103,1040],{"class":497},[467,1105,606],{"class":477},[467,1107,1108],{"class":615},"500",[467,1110,663],{"class":477},[467,1112,1113],{"class":666},"\u002F\u002F false\n",[418,1115,1117],{"id":1116},"tamaño-de-un-hashmap","Tamaño de un HashMap",[423,1119,1120,1121,586,1123,590],{},"Para obtener el tamaño de un ",[427,1122,429],{},[427,1124,1125],{},"size()",[458,1127,1129],{"className":460,"code":1128,"language":462,"meta":463,"style":463},"int tamaño = mapa.size(); \u002F\u002F Esto devolverá el número de pares clave-valor en el mapa\n",[427,1130,1131],{"__ignoreMap":463},[467,1132,1133,1136,1139,1141,1143,1146,1149],{"class":469,"line":470},[467,1134,1135],{"class":473},"int",[467,1137,1138],{"class":477}," tamaño ",[467,1140,534],{"class":473},[467,1142,782],{"class":477},[467,1144,1145],{"class":497},"size",[467,1147,1148],{"class":477},"(); ",[467,1150,1151],{"class":666},"\u002F\u002F Esto devolverá el número de pares clave-valor en el mapa\n",[418,1153,1155],{"id":1154},"iterar-sobre-un-hashmap","Iterar sobre un HashMap",[423,1157,1158,1159,1161,1162,1165,1166,1169],{},"Puedes iterar sobre los elementos de un ",[427,1160,429],{}," utilizando un bucle ",[427,1163,1164],{},"for-each"," junto con el método ",[427,1167,1168],{},"entrySet()"," para obtener los pares clave-valor:",[458,1171,1173],{"className":460,"code":1172,"language":462,"meta":463,"style":463},"for (Map.Entry\u003CString, Integer> entrada : mapa.entrySet()) {\n    String clave = entrada.getKey();\n    Integer valor = entrada.getValue();\n    System.out.println(clave + \": \" + valor);\n}\n",[427,1174,1175,1202,1218,1232,1255],{"__ignoreMap":463},[467,1176,1177,1180,1183,1185,1187,1189,1192,1194,1196,1199],{"class":469,"line":470},[467,1178,1179],{"class":473},"for",[467,1181,1182],{"class":477}," (Map.Entry\u003C",[467,1184,522],{"class":473},[467,1186,525],{"class":477},[467,1188,528],{"class":473},[467,1190,1191],{"class":477},"> entrada ",[467,1193,590],{"class":473},[467,1195,782],{"class":477},[467,1197,1198],{"class":497},"entrySet",[467,1200,1201],{"class":477},"()) {\n",[467,1203,1204,1207,1209,1212,1215],{"class":469,"line":481},[467,1205,1206],{"class":477},"    String clave ",[467,1208,534],{"class":473},[467,1210,1211],{"class":477}," entrada.",[467,1213,1214],{"class":497},"getKey",[467,1216,1217],{"class":477},"();\n",[467,1219,1220,1223,1225,1227,1230],{"class":469,"line":488},[467,1221,1222],{"class":477},"    Integer valor ",[467,1224,534],{"class":473},[467,1226,1211],{"class":477},[467,1228,1229],{"class":497},"getValue",[467,1231,1217],{"class":477},[467,1233,1234,1237,1240,1243,1246,1249,1252],{"class":469,"line":504},[467,1235,1236],{"class":477},"    System.out.",[467,1238,1239],{"class":497},"println",[467,1241,1242],{"class":477},"(clave ",[467,1244,1245],{"class":473},"+",[467,1247,1248],{"class":609}," \": \"",[467,1250,1251],{"class":473}," +",[467,1253,1254],{"class":477}," valor);\n",[467,1256,1257],{"class":469,"line":516},[467,1258,552],{"class":477},[423,1260,1261,1262,590],{},"También puedes iterar solo sobre las claves utilizando el método ",[427,1263,1264],{},"keySet()",[458,1266,1268],{"className":460,"code":1267,"language":462,"meta":463,"style":463},"for (String clave : mapa.keySet()) {\n    System.out.println(clave);\n}\n",[427,1269,1270,1286,1295],{"__ignoreMap":463},[467,1271,1272,1274,1277,1279,1281,1284],{"class":469,"line":470},[467,1273,1179],{"class":473},[467,1275,1276],{"class":477}," (String clave ",[467,1278,590],{"class":473},[467,1280,782],{"class":477},[467,1282,1283],{"class":497},"keySet",[467,1285,1201],{"class":477},[467,1287,1288,1290,1292],{"class":469,"line":481},[467,1289,1236],{"class":477},[467,1291,1239],{"class":497},[467,1293,1294],{"class":477},"(clave);\n",[467,1296,1297],{"class":469,"line":488},[467,1298,552],{"class":477},[423,1300,1301,1302,590],{},"O solo sobre los valores utilizando el método ",[427,1303,1304],{},"values()",[458,1306,1308],{"className":460,"code":1307,"language":462,"meta":463,"style":463},"for (Integer valor : mapa.values()) {\n    System.out.println(valor);\n}\n",[427,1309,1310,1326,1335],{"__ignoreMap":463},[467,1311,1312,1314,1317,1319,1321,1324],{"class":469,"line":470},[467,1313,1179],{"class":473},[467,1315,1316],{"class":477}," (Integer valor ",[467,1318,590],{"class":473},[467,1320,782],{"class":477},[467,1322,1323],{"class":497},"values",[467,1325,1201],{"class":477},[467,1327,1328,1330,1332],{"class":469,"line":481},[467,1329,1236],{"class":477},[467,1331,1239],{"class":497},[467,1333,1334],{"class":477},"(valor);\n",[467,1336,1337],{"class":469,"line":488},[467,1338,552],{"class":477},[418,1340,1342],{"id":1341},"conclusión","Conclusión",[423,1344,1345,1346,1348,1349,1351],{},"El ",[427,1347,429],{}," es una estructura de datos poderosa y eficiente para almacenar pares clave-valor en Java. Permite agregar, eliminar y acceder a los elementos de manera rápida, lo que lo convierte en una opción ideal para muchas aplicaciones. Al comprender cómo usar un ",[427,1350,429],{},", puedes mejorar la eficiencia de tu código y gestionar tus datos de manera más efectiva. Recuerda siempre tener en cuenta las características y limitaciones de esta estructura para aprovechar al máximo sus beneficios.",[1353,1354,1355],"style",{},"html pre.shiki code .snl16, html code.shiki .snl16{--shiki-default:#F97583}html pre.shiki code .s95oV, html code.shiki .s95oV{--shiki-default:#E1E4E8}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}",{"title":463,"searchDepth":481,"depth":481,"links":1357},[1358,1359,1362,1363,1364,1365,1366,1367,1368],{"id":420,"depth":481,"text":421},{"id":437,"depth":481,"text":438,"children":1360},[1361],{"id":449,"depth":488,"text":450},{"id":579,"depth":481,"text":580},{"id":758,"depth":481,"text":759},{"id":890,"depth":481,"text":891},{"id":953,"depth":481,"text":954},{"id":1116,"depth":481,"text":1117},{"id":1154,"depth":481,"text":1155},{"id":1341,"depth":481,"text":1342},"Explora los arreglos relacionales con HashMap en Java, una estructura de datos que permite almacenar pares clave-valor de manera eficiente. Aprende a crear, modificar y gestionar tus datos con esta poderosa herramienta.","md",null,{"editButton":42},{"title":224,"description":1369},"-GFCvATEwaUppC4voQISdRh1sLT_MoIs0Yv_MV-Xh1s",[1376,1378],{"title":220,"path":221,"stem":222,"description":1377,"children":-1},"Explora los arreglos dinámicos con ArrayList en Java, una estructura de datos que permite almacenar elementos de manera flexible. Aprende a crear, modificar y gestionar tus listas de datos con esta poderosa herramienta.",{"title":228,"path":229,"stem":230,"description":1379,"children":-1},"Descubre la clase Stream en Java, una herramienta poderosa para procesar colecciones de datos de manera eficiente y funcional. Aprende a utilizar Stream para realizar operaciones como filtrado, mapeo, reducción y más, facilitando el manejo de datos en tus aplicaciones Java.",1779479571564]