[{"data":1,"prerenderedAt":1608},["ShallowReactive",2],{"navigation_docs":3,"-arreglos":412,"-arreglos-surround":1604},[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":206,"body":414,"description":1598,"extension":1599,"links":1600,"meta":1601,"navigation":945,"path":202,"seo":1602,"stem":203,"__hash__":1603},"docs\u002F6.arreglos\u002F01.index.md",{"type":415,"value":416,"toc":1589},"minimark",[417,421,425,430,438,460,470,499,505,554,557,562,573,585,594,623,629,679,683,689,788,793,907,910,914,928,971,983,1030,1036,1088,1109,1184,1191,1249,1256,1260,1272,1306,1315,1346,1376,1381,1427,1444,1465,1468,1488,1502,1571,1578,1582,1585],[418,419,206],"h1",{"id":420},"los-arreglos-en-java",[422,423,424],"p",{},"Dentro de Java, las estructuras de datos más utilizadas son los arreglos. Un arreglo es una estructura de datos que permite almacenar una colección de elementos del mismo tipo. Para efectos prácticos los arreglos se clasifican según la forma de almacenamiento, es decir, si son ordinales o asociativos. Aunque también se clasificán según su tamaño, es decir, si son estáticos o dinámicos. Y por último, según su dimensión, es decir, si son unidimensionales o multidimensionales.",[426,427,429],"h2",{"id":428},"arreglos-ordinales-y-estáticos","Arreglos Ordinales y Estáticos",[422,431,432,433,437],{},"Los arreglos ordinales son aquellos que almacenan elementos de forma secuencial, es decir, cada elemento tiene un índice numérico que lo identifica. En Java, los arreglos ordinales se declaran utilizando la sintaxis ",[434,435,436],"code",{},"tipo[] nombreArreglo;",". Por ejemplo:",[439,440,445],"pre",{"className":441,"code":442,"language":443,"meta":444,"style":444},"language-java shiki shiki-themes github-dark","int[] numeros;\n","java","",[434,446,447],{"__ignoreMap":444},[448,449,452,456],"span",{"class":450,"line":451},"line",1,[448,453,455],{"class":454},"snl16","int",[448,457,459],{"class":458},"s95oV","[] numeros;\n",[422,461,462,463,466,467,437],{},"En este ejemplo, se declara un arreglo de enteros llamado ",[434,464,465],{},"numeros",". Para inicializar el arreglo, se utiliza la sintaxis ",[434,468,469],{},"nombreArreglo = new tipo[tamaño];",[439,471,473],{"className":441,"code":472,"language":443,"meta":444,"style":444},"numeros = new int[5];\n",[434,474,475],{"__ignoreMap":444},[448,476,477,480,483,486,489,492,496],{"class":450,"line":451},[448,478,479],{"class":458},"numeros ",[448,481,482],{"class":454},"=",[448,484,485],{"class":454}," new",[448,487,488],{"class":454}," int",[448,490,491],{"class":458},"[",[448,493,495],{"class":494},"sDLfK","5",[448,497,498],{"class":458},"];\n",[422,500,501,502,437],{},"En este caso, se crea un arreglo de enteros con capacidad para almacenar 5 elementos. Para acceder a los elementos del arreglo, se utiliza la sintaxis ",[434,503,504],{},"nombreArreglo[indice];",[439,506,508],{"className":441,"code":507,"language":443,"meta":444,"style":444},"numeros[0] = 10; \u002F\u002F Asigna el valor 10 al primer elemento del arreglo\nint valor = numeros[0]; \u002F\u002F Obtiene el valor del primer elemento del arreglo\n",[434,509,510,533],{"__ignoreMap":444},[448,511,512,515,518,521,523,526,529],{"class":450,"line":451},[448,513,514],{"class":458},"numeros[",[448,516,517],{"class":494},"0",[448,519,520],{"class":458},"] ",[448,522,482],{"class":454},[448,524,525],{"class":494}," 10",[448,527,528],{"class":458},"; ",[448,530,532],{"class":531},"sAwPA","\u002F\u002F Asigna el valor 10 al primer elemento del arreglo\n",[448,534,536,538,541,543,546,548,551],{"class":450,"line":535},2,[448,537,455],{"class":454},[448,539,540],{"class":458}," valor ",[448,542,482],{"class":454},[448,544,545],{"class":458}," numeros[",[448,547,517],{"class":494},[448,549,550],{"class":458},"]; ",[448,552,553],{"class":531},"\u002F\u002F Obtiene el valor del primer elemento del arreglo\n",[422,555,556],{},"Una característica importante de los arreglos en Java es que son estáticos, lo que significa que su tamaño no puede cambiar una vez que han sido creados. Si se necesita un arreglo con un tamaño diferente, es necesario crear uno nuevo y copiar los elementos del arreglo original al nuevo arreglo.",[558,559,561],"h3",{"id":560},"multidimensionales","Multidimensionales",[422,563,564,565,568,569,572],{},"Los arreglos multidimensionales son aquellos que almacenan elementos en una estructura de varias dimensiones. En Java, los arreglos multidimensionales se declaran utilizando la sintaxis ",[434,566,567],{},"tipo[][] nombreArreglo;"," para un arreglo bidimensional, o ",[434,570,571],{},"tipo[][][] nombreArreglo;"," para un arreglo tridimensional, y así sucesivamente. Por ejemplo:",[439,574,576],{"className":441,"code":575,"language":443,"meta":444,"style":444},"int[][] matriz;\n",[434,577,578],{"__ignoreMap":444},[448,579,580,582],{"class":450,"line":451},[448,581,455],{"class":454},[448,583,584],{"class":458},"[][] matriz;\n",[422,586,587,588,466,591,437],{},"En este ejemplo, se declara un arreglo bidimensional de enteros llamado ",[434,589,590],{},"matriz",[434,592,593],{},"nombreArreglo = new tipo[filas][columnas];",[439,595,597],{"className":441,"code":596,"language":443,"meta":444,"style":444},"matriz = new int[3][4];\n",[434,598,599],{"__ignoreMap":444},[448,600,601,604,606,608,610,612,615,618,621],{"class":450,"line":451},[448,602,603],{"class":458},"matriz ",[448,605,482],{"class":454},[448,607,485],{"class":454},[448,609,488],{"class":454},[448,611,491],{"class":458},[448,613,614],{"class":494},"3",[448,616,617],{"class":458},"][",[448,619,620],{"class":494},"4",[448,622,498],{"class":458},[422,624,625,626,437],{},"En este caso, se crea un arreglo bidimensional de enteros con 3 filas y 4 columnas. Para acceder a los elementos del arreglo, se utiliza la sintaxis ",[434,627,628],{},"nombreArreglo[fila][columna];",[439,630,632],{"className":441,"code":631,"language":443,"meta":444,"style":444},"matriz[0][0] = 1; \u002F\u002F Asigna el valor 1 al primer elemento de la primera fila\nint valor = matriz[0][0]; \u002F\u002F Obtiene el valor del primer elemento de la primera fila\n",[434,633,634,657],{"__ignoreMap":444},[448,635,636,639,641,643,645,647,649,652,654],{"class":450,"line":451},[448,637,638],{"class":458},"matriz[",[448,640,517],{"class":494},[448,642,617],{"class":458},[448,644,517],{"class":494},[448,646,520],{"class":458},[448,648,482],{"class":454},[448,650,651],{"class":494}," 1",[448,653,528],{"class":458},[448,655,656],{"class":531},"\u002F\u002F Asigna el valor 1 al primer elemento de la primera fila\n",[448,658,659,661,663,665,668,670,672,674,676],{"class":450,"line":535},[448,660,455],{"class":454},[448,662,540],{"class":458},[448,664,482],{"class":454},[448,666,667],{"class":458}," matriz[",[448,669,517],{"class":494},[448,671,617],{"class":458},[448,673,517],{"class":494},[448,675,550],{"class":458},[448,677,678],{"class":531},"\u002F\u002F Obtiene el valor del primer elemento de la primera fila\n",[558,680,682],{"id":681},"arreglos-irregulares","Arreglos Irregulares",[422,684,685,686,688],{},"Los arreglos irregulares, también conocidos como arreglos jagged, son aquellos que tienen filas de diferentes longitudes. En Java, los arreglos irregulares se declaran utilizando la sintaxis ",[434,687,567],{}," y se inicializan asignando un arreglo a cada fila. Por ejemplo:",[439,690,692],{"className":441,"code":691,"language":443,"meta":444,"style":444},"int[][] jaggedArray = new int[3][];\njaggedArray[0] = new int[2]; \u002F\u002F Primera fila con 2 elementos\njaggedArray[1] = new int[3]; \u002F\u002F Segunda fila con 3 elementos\njaggedArray[2] = new int[1]; \u002F\u002F Tercera fila con 1 elemento\n",[434,693,694,714,739,764],{"__ignoreMap":444},[448,695,696,698,701,703,705,707,709,711],{"class":450,"line":451},[448,697,455],{"class":454},[448,699,700],{"class":458},"[][] jaggedArray ",[448,702,482],{"class":454},[448,704,485],{"class":454},[448,706,488],{"class":454},[448,708,491],{"class":458},[448,710,614],{"class":494},[448,712,713],{"class":458},"][];\n",[448,715,716,719,721,723,725,727,729,731,734,736],{"class":450,"line":535},[448,717,718],{"class":458},"jaggedArray[",[448,720,517],{"class":494},[448,722,520],{"class":458},[448,724,482],{"class":454},[448,726,485],{"class":454},[448,728,488],{"class":454},[448,730,491],{"class":458},[448,732,733],{"class":494},"2",[448,735,550],{"class":458},[448,737,738],{"class":531},"\u002F\u002F Primera fila con 2 elementos\n",[448,740,742,744,747,749,751,753,755,757,759,761],{"class":450,"line":741},3,[448,743,718],{"class":458},[448,745,746],{"class":494},"1",[448,748,520],{"class":458},[448,750,482],{"class":454},[448,752,485],{"class":454},[448,754,488],{"class":454},[448,756,491],{"class":458},[448,758,614],{"class":494},[448,760,550],{"class":458},[448,762,763],{"class":531},"\u002F\u002F Segunda fila con 3 elementos\n",[448,765,767,769,771,773,775,777,779,781,783,785],{"class":450,"line":766},4,[448,768,718],{"class":458},[448,770,733],{"class":494},[448,772,520],{"class":458},[448,774,482],{"class":454},[448,776,485],{"class":454},[448,778,488],{"class":454},[448,780,491],{"class":458},[448,782,746],{"class":494},[448,784,550],{"class":458},[448,786,787],{"class":531},"\u002F\u002F Tercera fila con 1 elemento\n",[422,789,790,791,437],{},"En este caso, se crea un arreglo bidimensional irregular con 3 filas, donde la primera fila tiene 2 elementos, la segunda fila tiene 3 elementos y la tercera fila tiene 1 elemento. Para acceder a los elementos del arreglo irregular, se utiliza la sintaxis ",[434,792,628],{},[439,794,796],{"className":441,"code":795,"language":443,"meta":444,"style":444},"jaggedArray[0][0] = 1; \u002F\u002F Asigna el valor 1 al primer elemento de la primera fila\njaggedArray[1][0] = 2; \u002F\u002F Asigna el valor 2 al primer elemento de la segunda fila\njaggedArray[1][1] = 3; \u002F\u002F Asigna el valor 3 al segundo elemento de la segunda fila\njaggedArray[1][2] = 4; \u002F\u002F Asigna el valor 4 al tercer elemento de la segunda fila\njaggedArray[2][0] = 5; \u002F\u002F Asigna el valor 5 al primer elemento de la tercera fila\n",[434,797,798,818,840,862,884],{"__ignoreMap":444},[448,799,800,802,804,806,808,810,812,814,816],{"class":450,"line":451},[448,801,718],{"class":458},[448,803,517],{"class":494},[448,805,617],{"class":458},[448,807,517],{"class":494},[448,809,520],{"class":458},[448,811,482],{"class":454},[448,813,651],{"class":494},[448,815,528],{"class":458},[448,817,656],{"class":531},[448,819,820,822,824,826,828,830,832,835,837],{"class":450,"line":535},[448,821,718],{"class":458},[448,823,746],{"class":494},[448,825,617],{"class":458},[448,827,517],{"class":494},[448,829,520],{"class":458},[448,831,482],{"class":454},[448,833,834],{"class":494}," 2",[448,836,528],{"class":458},[448,838,839],{"class":531},"\u002F\u002F Asigna el valor 2 al primer elemento de la segunda fila\n",[448,841,842,844,846,848,850,852,854,857,859],{"class":450,"line":741},[448,843,718],{"class":458},[448,845,746],{"class":494},[448,847,617],{"class":458},[448,849,746],{"class":494},[448,851,520],{"class":458},[448,853,482],{"class":454},[448,855,856],{"class":494}," 3",[448,858,528],{"class":458},[448,860,861],{"class":531},"\u002F\u002F Asigna el valor 3 al segundo elemento de la segunda fila\n",[448,863,864,866,868,870,872,874,876,879,881],{"class":450,"line":766},[448,865,718],{"class":458},[448,867,746],{"class":494},[448,869,617],{"class":458},[448,871,733],{"class":494},[448,873,520],{"class":458},[448,875,482],{"class":454},[448,877,878],{"class":494}," 4",[448,880,528],{"class":458},[448,882,883],{"class":531},"\u002F\u002F Asigna el valor 4 al tercer elemento de la segunda fila\n",[448,885,887,889,891,893,895,897,899,902,904],{"class":450,"line":886},5,[448,888,718],{"class":458},[448,890,733],{"class":494},[448,892,617],{"class":458},[448,894,517],{"class":494},[448,896,520],{"class":458},[448,898,482],{"class":454},[448,900,901],{"class":494}," 5",[448,903,528],{"class":458},[448,905,906],{"class":531},"\u002F\u002F Asigna el valor 5 al primer elemento de la tercera fila\n",[422,908,909],{},"Un punto importante a destacar es que los arreglos irregulares pueden ser útiles cuando se necesita almacenar datos que no tienen una estructura uniforme, como por ejemplo, una lista de estudiantes donde cada estudiante tiene un número diferente de calificaciones. Sin embargo, es importante tener en cuenta que el acceso a los elementos de un arreglo irregular puede ser más complejo que el acceso a los elementos de un arreglo regular, ya que se debe verificar la longitud de cada fila antes de acceder a sus elementos.",[426,911,913],{"id":912},"arreglos-asociativos","Arreglos Asociativos",[422,915,916,917,920,921,924,925,437],{},"Los arreglos asociativos, también conocidos como mapas o diccionarios, son aquellos que almacenan elementos en pares clave-valor. En Java, los arreglos asociativos se implementan utilizando la clase ",[434,918,919],{},"HashMap"," del paquete ",[434,922,923],{},"java.util",". Para declarar un arreglo asociativo, se utiliza la sintaxis ",[434,926,927],{},"HashMap\u003CtipoClave, tipoValor> nombreArreglo;",[439,929,931],{"className":441,"code":930,"language":443,"meta":444,"style":444},"import java.util.HashMap;\n\nHashMap\u003CString, Integer> edades = new HashMap\u003C>();\n",[434,932,933,941,947],{"__ignoreMap":444},[448,934,935,938],{"class":450,"line":451},[448,936,937],{"class":454},"import",[448,939,940],{"class":458}," java.util.HashMap;\n",[448,942,943],{"class":450,"line":535},[448,944,946],{"emptyLinePlaceholder":945},true,"\n",[448,948,949,952,955,958,961,964,966,968],{"class":450,"line":741},[448,950,951],{"class":458},"HashMap\u003C",[448,953,954],{"class":454},"String",[448,956,957],{"class":458},", ",[448,959,960],{"class":454},"Integer",[448,962,963],{"class":458},"> edades ",[448,965,482],{"class":454},[448,967,485],{"class":454},[448,969,970],{"class":458}," HashMap\u003C>();\n",[422,972,973,974,976,977,979,980,437],{},"En este ejemplo, se declara un arreglo asociativo que almacena pares de clave-valor, donde la clave es de tipo ",[434,975,954],{}," y el valor es de tipo ",[434,978,960],{},". Para agregar elementos al arreglo asociativo, se utiliza el método ",[434,981,982],{},"put()",[439,984,986],{"className":441,"code":985,"language":443,"meta":444,"style":444},"edades.put(\"Alice\", 30);\nedades.put(\"Bob\", 25);\n",[434,987,988,1012],{"__ignoreMap":444},[448,989,990,993,997,1000,1004,1006,1009],{"class":450,"line":451},[448,991,992],{"class":458},"edades.",[448,994,996],{"class":995},"svObZ","put",[448,998,999],{"class":458},"(",[448,1001,1003],{"class":1002},"sU2Wk","\"Alice\"",[448,1005,957],{"class":458},[448,1007,1008],{"class":494},"30",[448,1010,1011],{"class":458},");\n",[448,1013,1014,1016,1018,1020,1023,1025,1028],{"class":450,"line":535},[448,1015,992],{"class":458},[448,1017,996],{"class":995},[448,1019,999],{"class":458},[448,1021,1022],{"class":1002},"\"Bob\"",[448,1024,957],{"class":458},[448,1026,1027],{"class":494},"25",[448,1029,1011],{"class":458},[422,1031,1032,1033,437],{},"En este caso, se agregan dos pares clave-valor al arreglo asociativo, donde \"Alice\" es la clave y 30 es el valor asociado a esa clave, y \"Bob\" es la clave y 25 es el valor asociado a esa clave. Para acceder a los valores del arreglo asociativo, se utiliza el método ",[434,1034,1035],{},"get()",[439,1037,1039],{"className":441,"code":1038,"language":443,"meta":444,"style":444},"int edadAlice = edades.get(\"Alice\"); \u002F\u002F Obtiene el valor asociado a la clave \"Alice\"\nint edadBob = edades.get(\"Bob\"); \u002F\u002F Obtiene el valor asociado a la clave \"Bob\"\n",[434,1040,1041,1066],{"__ignoreMap":444},[448,1042,1043,1045,1048,1050,1053,1056,1058,1060,1063],{"class":450,"line":451},[448,1044,455],{"class":454},[448,1046,1047],{"class":458}," edadAlice ",[448,1049,482],{"class":454},[448,1051,1052],{"class":458}," edades.",[448,1054,1055],{"class":995},"get",[448,1057,999],{"class":458},[448,1059,1003],{"class":1002},[448,1061,1062],{"class":458},"); ",[448,1064,1065],{"class":531},"\u002F\u002F Obtiene el valor asociado a la clave \"Alice\"\n",[448,1067,1068,1070,1073,1075,1077,1079,1081,1083,1085],{"class":450,"line":535},[448,1069,455],{"class":454},[448,1071,1072],{"class":458}," edadBob ",[448,1074,482],{"class":454},[448,1076,1052],{"class":458},[448,1078,1055],{"class":995},[448,1080,999],{"class":458},[448,1082,1022],{"class":1002},[448,1084,1062],{"class":458},[448,1086,1087],{"class":531},"\u002F\u002F Obtiene el valor asociado a la clave \"Bob\"\n",[422,1089,1090,1091,1094,1095,1098,1099,1101,1102,1105,1106,437],{},"En este caso, se obtiene el valor asociado a la clave \"Alice\" y se almacena en la variable ",[434,1092,1093],{},"edadAlice",", y se obtiene el valor asociado a la clave \"Bob\" y se almacena en la variable ",[434,1096,1097],{},"edadBob",". Es importante tener en cuenta que si se intenta acceder a una clave que no existe en el arreglo asociativo, el método ",[434,1100,1035],{}," devolverá ",[434,1103,1104],{},"null",". Por lo tanto, es recomendable verificar si la clave existe antes de intentar acceder a su valor utilizando el método ",[434,1107,1108],{},"containsKey()",[439,1110,1112],{"className":441,"code":1111,"language":443,"meta":444,"style":444},"if (edades.containsKey(\"Charlie\")) {\n    int edadCharlie = edades.get(\"Charlie\");\n} else {\n    System.out.println(\"La clave 'Charlie' no existe en el arreglo asociativo.\");\n}\n",[434,1113,1114,1133,1153,1164,1179],{"__ignoreMap":444},[448,1115,1116,1119,1122,1125,1127,1130],{"class":450,"line":451},[448,1117,1118],{"class":454},"if",[448,1120,1121],{"class":458}," (edades.",[448,1123,1124],{"class":995},"containsKey",[448,1126,999],{"class":458},[448,1128,1129],{"class":1002},"\"Charlie\"",[448,1131,1132],{"class":458},")) {\n",[448,1134,1135,1138,1141,1143,1145,1147,1149,1151],{"class":450,"line":535},[448,1136,1137],{"class":454},"    int",[448,1139,1140],{"class":458}," edadCharlie ",[448,1142,482],{"class":454},[448,1144,1052],{"class":458},[448,1146,1055],{"class":995},[448,1148,999],{"class":458},[448,1150,1129],{"class":1002},[448,1152,1011],{"class":458},[448,1154,1155,1158,1161],{"class":450,"line":741},[448,1156,1157],{"class":458},"} ",[448,1159,1160],{"class":454},"else",[448,1162,1163],{"class":458}," {\n",[448,1165,1166,1169,1172,1174,1177],{"class":450,"line":766},[448,1167,1168],{"class":458},"    System.out.",[448,1170,1171],{"class":995},"println",[448,1173,999],{"class":458},[448,1175,1176],{"class":1002},"\"La clave 'Charlie' no existe en el arreglo asociativo.\"",[448,1178,1011],{"class":458},[448,1180,1181],{"class":450,"line":886},[448,1182,1183],{"class":458},"}\n",[422,1185,1186,1187,1190],{},"En este caso, se verifica si la clave \"Charlie\" existe en el arreglo asociativo antes de intentar acceder a su valor. Si la clave existe, se obtiene su valor y se almacena en la variable ",[434,1188,1189],{},"edadCharlie",". Si la clave no existe, se imprime un mensaje indicando que la clave no existe en el arreglo asociativo.",[439,1192,1194],{"className":441,"code":1193,"language":443,"meta":444,"style":444},"if (edades.containsValue(30)) {\n    System.out.println(\"El valor 30 existe en el arreglo asociativo.\");\n} else {\n    System.out.println(\"El valor 30 no existe en el arreglo asociativo.\");\n}\n",[434,1195,1196,1211,1224,1232,1245],{"__ignoreMap":444},[448,1197,1198,1200,1202,1205,1207,1209],{"class":450,"line":451},[448,1199,1118],{"class":454},[448,1201,1121],{"class":458},[448,1203,1204],{"class":995},"containsValue",[448,1206,999],{"class":458},[448,1208,1008],{"class":494},[448,1210,1132],{"class":458},[448,1212,1213,1215,1217,1219,1222],{"class":450,"line":535},[448,1214,1168],{"class":458},[448,1216,1171],{"class":995},[448,1218,999],{"class":458},[448,1220,1221],{"class":1002},"\"El valor 30 existe en el arreglo asociativo.\"",[448,1223,1011],{"class":458},[448,1225,1226,1228,1230],{"class":450,"line":741},[448,1227,1157],{"class":458},[448,1229,1160],{"class":454},[448,1231,1163],{"class":458},[448,1233,1234,1236,1238,1240,1243],{"class":450,"line":766},[448,1235,1168],{"class":458},[448,1237,1171],{"class":995},[448,1239,999],{"class":458},[448,1241,1242],{"class":1002},"\"El valor 30 no existe en el arreglo asociativo.\"",[448,1244,1011],{"class":458},[448,1246,1247],{"class":450,"line":886},[448,1248,1183],{"class":458},[422,1250,1251,1252,1255],{},"En este caso, se verifica si el valor 30 existe en el arreglo asociativo utilizando el método ",[434,1253,1254],{},"containsValue()",". Si el valor existe, se imprime un mensaje indicando que el valor existe en el arreglo asociativo. Si el valor no existe, se imprime un mensaje indicando que el valor no existe en el arreglo asociativo.",[426,1257,1259],{"id":1258},"arreglos-dinámicos","Arreglos Dinámicos",[422,1261,1262,1263,920,1266,1268,1269,437],{},"Los arreglos dinámicos son aquellos que pueden cambiar de tamaño durante la ejecución del programa. En Java, los arreglos dinámicos se implementan utilizando la clase ",[434,1264,1265],{},"ArrayList",[434,1267,923],{},". Para declarar un arreglo dinámico, se utiliza la sintaxis ",[434,1270,1271],{},"ArrayList\u003Ctipo> nombreArreglo;",[439,1273,1275],{"className":441,"code":1274,"language":443,"meta":444,"style":444},"import java.util.ArrayList;\n\nArrayList\u003CT> nombres = new ArrayList\u003C>();\n",[434,1276,1277,1284,1288],{"__ignoreMap":444},[448,1278,1279,1281],{"class":450,"line":451},[448,1280,937],{"class":454},[448,1282,1283],{"class":458}," java.util.ArrayList;\n",[448,1285,1286],{"class":450,"line":535},[448,1287,946],{"emptyLinePlaceholder":945},[448,1289,1290,1293,1296,1299,1301,1303],{"class":450,"line":741},[448,1291,1292],{"class":458},"ArrayList\u003C",[448,1294,1295],{"class":454},"T",[448,1297,1298],{"class":458},"> nombres ",[448,1300,482],{"class":454},[448,1302,485],{"class":454},[448,1304,1305],{"class":458}," ArrayList\u003C>();\n",[422,1307,1308,1309,1311,1312,437],{},"En este ejemplo, se declara un arreglo dinámico que almacena elementos de tipo ",[434,1310,1295],{},". Para agregar elementos al arreglo dinámico, se utiliza el método ",[434,1313,1314],{},"add()",[439,1316,1318],{"className":441,"code":1317,"language":443,"meta":444,"style":444},"nombres.add(\"Alice\");\nnombres.add(\"Bob\");\n",[434,1319,1320,1334],{"__ignoreMap":444},[448,1321,1322,1325,1328,1330,1332],{"class":450,"line":451},[448,1323,1324],{"class":458},"nombres.",[448,1326,1327],{"class":995},"add",[448,1329,999],{"class":458},[448,1331,1003],{"class":1002},[448,1333,1011],{"class":458},[448,1335,1336,1338,1340,1342,1344],{"class":450,"line":535},[448,1337,1324],{"class":458},[448,1339,1327],{"class":995},[448,1341,999],{"class":458},[448,1343,1022],{"class":1002},[448,1345,1011],{"class":458},[422,1347,1348,1349,1352,1353,1356,1357,1360,1361,957,1363,1366,1367,1369,1370,957,1372,1375],{},"Es importante destacar que el valor en la notación diamante ",[434,1350,1351],{},"ArrayList\u003CT>"," debe ser una clase o tipo de datos válido en Java. Por ejemplo, si se desea almacenar cadenas de texto, se puede utilizar ",[434,1354,1355],{},"ArrayList\u003CString>",". Si se desea almacenar números enteros, se puede utilizar ",[434,1358,1359],{},"ArrayList\u003CInteger>",". Es importante tener en cuenta que los tipos primitivos como ",[434,1362,455],{},[434,1364,1365],{},"double",", etc., no pueden ser utilizados directamente en un ",[434,1368,1265],{},", sino que deben ser envueltos en sus clases envolventes correspondientes, como ",[434,1371,960],{},[434,1373,1374],{},"Double",", etc.",[422,1377,1378,1379,437],{},"En este caso, se agregan dos elementos al arreglo dinámico, \"Alice\" y \"Bob\". Para acceder a los elementos del arreglo dinámico, se utiliza el método ",[434,1380,1035],{},[439,1382,1384],{"className":441,"code":1383,"language":443,"meta":444,"style":444},"String nombreAlice = nombres.get(0); \u002F\u002F Obtiene el primer elemento del arreglo dinámico\nString nombreBob = nombres.get(1); \u002F\u002F Obtiene el segundo elemento del arreglo dinámico\n",[434,1385,1386,1407],{"__ignoreMap":444},[448,1387,1388,1391,1393,1396,1398,1400,1402,1404],{"class":450,"line":451},[448,1389,1390],{"class":458},"String nombreAlice ",[448,1392,482],{"class":454},[448,1394,1395],{"class":458}," nombres.",[448,1397,1055],{"class":995},[448,1399,999],{"class":458},[448,1401,517],{"class":494},[448,1403,1062],{"class":458},[448,1405,1406],{"class":531},"\u002F\u002F Obtiene el primer elemento del arreglo dinámico\n",[448,1408,1409,1412,1414,1416,1418,1420,1422,1424],{"class":450,"line":535},[448,1410,1411],{"class":458},"String nombreBob ",[448,1413,482],{"class":454},[448,1415,1395],{"class":458},[448,1417,1055],{"class":995},[448,1419,999],{"class":458},[448,1421,746],{"class":494},[448,1423,1062],{"class":458},[448,1425,1426],{"class":531},"\u002F\u002F Obtiene el segundo elemento del arreglo dinámico\n",[422,1428,1429,1430,1433,1434,1437,1438,1440,1441,437],{},"En este caso, se obtiene el primer elemento del arreglo dinámico y se almacena en la variable ",[434,1431,1432],{},"nombreAlice",", y se obtiene el segundo elemento del arreglo dinámico y se almacena en la variable ",[434,1435,1436],{},"nombreBob",". Es importante tener en cuenta que los índices de un ",[434,1439,1265],{}," comienzan en 0, por lo que el primer elemento tiene un índice de 0, el segundo elemento tiene un índice de 1, y así sucesivamente. Para eliminar elementos del arreglo dinámico, se utiliza el método ",[434,1442,1443],{},"remove()",[439,1445,1447],{"className":441,"code":1446,"language":443,"meta":444,"style":444},"nombres.remove(0); \u002F\u002F Elimina el primer elemento del arreglo dinámico\n",[434,1448,1449],{"__ignoreMap":444},[448,1450,1451,1453,1456,1458,1460,1462],{"class":450,"line":451},[448,1452,1324],{"class":458},[448,1454,1455],{"class":995},"remove",[448,1457,999],{"class":458},[448,1459,517],{"class":494},[448,1461,1062],{"class":458},[448,1463,1464],{"class":531},"\u002F\u002F Elimina el primer elemento del arreglo dinámico\n",[422,1466,1467],{},"En este caso, se elimina el primer elemento del arreglo dinámico, que es \"Alice\". Después de eliminar un elemento, los índices de los elementos restantes se ajustan automáticamente. Por ejemplo, después de eliminar el primer elemento, \"Bob\" se convierte en el nuevo primer elemento del arreglo dinámico y su índice cambia a 0.",[439,1469,1471],{"className":441,"code":1470,"language":443,"meta":444,"style":444},"nombres.remove(\"Bob\"); \u002F\u002F Elimina el elemento \"Bob\" del arreglo dinámico\n",[434,1472,1473],{"__ignoreMap":444},[448,1474,1475,1477,1479,1481,1483,1485],{"class":450,"line":451},[448,1476,1324],{"class":458},[448,1478,1455],{"class":995},[448,1480,999],{"class":458},[448,1482,1022],{"class":1002},[448,1484,1062],{"class":458},[448,1486,1487],{"class":531},"\u002F\u002F Elimina el elemento \"Bob\" del arreglo dinámico\n",[422,1489,1490,1491,1493,1494,1497,1498,1501],{},"En este caso, se elimina el elemento \"Bob\" del arreglo dinámico utilizando el método ",[434,1492,1443],{}," con el valor del elemento a eliminar. Después de eliminar un elemento, los índices de los elementos restantes se ajustan automáticamente. Es importante tener en cuenta que si se intenta acceder a un índice que no existe en el arreglo dinámico, se lanzará una excepción ",[434,1495,1496],{},"IndexOutOfBoundsException",". Por lo tanto, es recomendable verificar el tamaño del arreglo dinámico utilizando el método ",[434,1499,1500],{},"size()"," antes de intentar acceder a un índice específico. Por ejemplo:",[439,1503,1505],{"className":441,"code":1504,"language":443,"meta":444,"style":444},"if (nombres.size() > 0) {\n    String primerNombre = nombres.get(0);\n} else {\n    System.out.println(\"El arreglo dinámico está vacío.\");\n}\n",[434,1506,1507,1529,1546,1554,1567],{"__ignoreMap":444},[448,1508,1509,1511,1514,1517,1520,1523,1526],{"class":450,"line":451},[448,1510,1118],{"class":454},[448,1512,1513],{"class":458}," (nombres.",[448,1515,1516],{"class":995},"size",[448,1518,1519],{"class":458},"() ",[448,1521,1522],{"class":454},">",[448,1524,1525],{"class":494}," 0",[448,1527,1528],{"class":458},") {\n",[448,1530,1531,1534,1536,1538,1540,1542,1544],{"class":450,"line":535},[448,1532,1533],{"class":458},"    String primerNombre ",[448,1535,482],{"class":454},[448,1537,1395],{"class":458},[448,1539,1055],{"class":995},[448,1541,999],{"class":458},[448,1543,517],{"class":494},[448,1545,1011],{"class":458},[448,1547,1548,1550,1552],{"class":450,"line":741},[448,1549,1157],{"class":458},[448,1551,1160],{"class":454},[448,1553,1163],{"class":458},[448,1555,1556,1558,1560,1562,1565],{"class":450,"line":766},[448,1557,1168],{"class":458},[448,1559,1171],{"class":995},[448,1561,999],{"class":458},[448,1563,1564],{"class":1002},"\"El arreglo dinámico está vacío.\"",[448,1566,1011],{"class":458},[448,1568,1569],{"class":450,"line":886},[448,1570,1183],{"class":458},[422,1572,1573,1574,1577],{},"En este caso, se verifica si el tamaño del arreglo dinámico es mayor que 0 antes de intentar acceder al primer elemento. Si el arreglo dinámico no está vacío, se obtiene el primer elemento y se almacena en la variable ",[434,1575,1576],{},"primerNombre",". Si el arreglo dinámico está vacío, se imprime un mensaje indicando que el arreglo dinámico está vacío.",[426,1579,1581],{"id":1580},"resumen","Resumen",[422,1583,1584],{},"En esta sección se ha explicado qué es un arreglo, cómo se declara, cómo se inicializa y cómo se accede a sus elementos en Java. Se han presentado los diferentes tipos de arreglos, incluyendo arreglos ordinales y estáticos, arreglos multidimensionales, arreglos irregulares, arreglos asociativos y arreglos dinámicos. Es importante tener en cuenta las características y limitaciones de cada tipo de arreglo para utilizarlos de manera efectiva en la programación en Java.",[1586,1587,1588],"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 .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 .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}",{"title":444,"searchDepth":535,"depth":535,"links":1590},[1591,1595,1596,1597],{"id":428,"depth":535,"text":429,"children":1592},[1593,1594],{"id":560,"depth":741,"text":561},{"id":681,"depth":741,"text":682},{"id":912,"depth":535,"text":913},{"id":1258,"depth":535,"text":1259},{"id":1580,"depth":535,"text":1581},"En esta sección se explicará qué es un arreglo, cómo se declara, cómo se inicializa y cómo se accede a sus elementos.","md",null,{"editButton":42},{"title":206,"description":1598},"UXcU4eEYxbw4Vl7sf68RO-Te1O4kejBOGzp57fybqMo",[1605,1606],{"title":196,"path":197,"stem":198,"description":444,"children":-1},{"title":208,"path":209,"stem":210,"description":1607,"children":-1},"En esta sección se introduce el concepto de arreglos, que son estructuras de datos que permiten almacenar múltiples valores en una sola variable. Se explican las características de los arreglos, cómo se declaran y se utilizan en diferentes lenguajes de programación.",1779479570863]