[{"data":1,"prerenderedAt":1312},["ShallowReactive",2],{"navigation_docs":3,"-arreglos-stream":412,"-arreglos-stream-surround":1307},[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":228,"body":414,"description":1301,"extension":1302,"links":1303,"meta":1304,"navigation":497,"path":229,"seo":1305,"stem":230,"__hash__":1306},"docs\u002F6.arreglos\u002F07.stream.md",{"type":415,"value":416,"toc":1292},"minimark",[417,422,438,442,447,454,683,698,701,824,835,839,845,991,1021,1025,1031,1180,1268,1272,1288],[418,419,421],"h2",{"id":420},"qué-es-la-clase-stream","¿Qué es la clase Stream?",[423,424,425,426,430,431,433,434,437],"p",{},"La clase ",[427,428,429],"code",{},"Stream"," en Java es una herramienta poderosa para procesar colecciones de datos de manera eficiente y funcional. Introducida en Java 8, la clase ",[427,432,429],{}," forma parte del paquete ",[427,435,436],{},"java.util.stream"," y proporciona una forma de realizar operaciones como filtrado, mapeo, reducción y más, facilitando el manejo de datos en tus aplicaciones Java.",[418,439,441],{"id":440},"operaciones-comunes-con-stream","Operaciones comunes con Stream",[443,444,446],"h3",{"id":445},"filtrado","Filtrado",[423,448,449,450,453],{},"El método ",[427,451,452],{},"filter()"," se utiliza para filtrar elementos de un stream según una condición específica. Por ejemplo, si queremos filtrar una lista de números para obtener solo los números pares, podemos hacer lo siguiente:",[455,456,461],"pre",{"className":457,"code":458,"language":459,"meta":460,"style":460},"language-java shiki shiki-themes github-dark","import java.util.Arrays;\nimport java.util.List;\nimport java.util.stream.Collectors;\n\npublic class Main {\n    void main() {\n        List\u003CInteger> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);\n        List\u003CInteger> numerosPares = numeros.stream()\n                                            .filter(n -> n % 2 == 0)\n                                            .collect(Collectors.toList());\n        System.out.println(numerosPares); \u002F\u002F Output: [2, 4, 6]\n    }\n}\n","java","",[427,462,463,476,484,492,499,515,527,584,605,638,655,671,677],{"__ignoreMap":460},[464,465,468,472],"span",{"class":466,"line":467},"line",1,[464,469,471],{"class":470},"snl16","import",[464,473,475],{"class":474},"s95oV"," java.util.Arrays;\n",[464,477,479,481],{"class":466,"line":478},2,[464,480,471],{"class":470},[464,482,483],{"class":474}," java.util.List;\n",[464,485,487,489],{"class":466,"line":486},3,[464,488,471],{"class":470},[464,490,491],{"class":474}," java.util.stream.Collectors;\n",[464,493,495],{"class":466,"line":494},4,[464,496,498],{"emptyLinePlaceholder":497},true,"\n",[464,500,502,505,508,512],{"class":466,"line":501},5,[464,503,504],{"class":470},"public",[464,506,507],{"class":470}," class",[464,509,511],{"class":510},"svObZ"," Main",[464,513,514],{"class":474}," {\n",[464,516,518,521,524],{"class":466,"line":517},6,[464,519,520],{"class":470},"    void",[464,522,523],{"class":510}," main",[464,525,526],{"class":474},"() {\n",[464,528,530,533,536,539,542,545,548,551,555,558,561,563,566,568,571,573,576,578,581],{"class":466,"line":529},7,[464,531,532],{"class":474},"        List\u003C",[464,534,535],{"class":470},"Integer",[464,537,538],{"class":474},"> numeros ",[464,540,541],{"class":470},"=",[464,543,544],{"class":474}," Arrays.",[464,546,547],{"class":510},"asList",[464,549,550],{"class":474},"(",[464,552,554],{"class":553},"sDLfK","1",[464,556,557],{"class":474},", ",[464,559,560],{"class":553},"2",[464,562,557],{"class":474},[464,564,565],{"class":553},"3",[464,567,557],{"class":474},[464,569,570],{"class":553},"4",[464,572,557],{"class":474},[464,574,575],{"class":553},"5",[464,577,557],{"class":474},[464,579,580],{"class":553},"6",[464,582,583],{"class":474},");\n",[464,585,587,589,591,594,596,599,602],{"class":466,"line":586},8,[464,588,532],{"class":474},[464,590,535],{"class":470},[464,592,593],{"class":474},"> numerosPares ",[464,595,541],{"class":470},[464,597,598],{"class":474}," numeros.",[464,600,601],{"class":510},"stream",[464,603,604],{"class":474},"()\n",[464,606,608,611,614,617,620,623,626,629,632,635],{"class":466,"line":607},9,[464,609,610],{"class":474},"                                            .",[464,612,613],{"class":510},"filter",[464,615,616],{"class":474},"(n ",[464,618,619],{"class":470},"->",[464,621,622],{"class":474}," n ",[464,624,625],{"class":470},"%",[464,627,628],{"class":553}," 2",[464,630,631],{"class":470}," ==",[464,633,634],{"class":553}," 0",[464,636,637],{"class":474},")\n",[464,639,641,643,646,649,652],{"class":466,"line":640},10,[464,642,610],{"class":474},[464,644,645],{"class":510},"collect",[464,647,648],{"class":474},"(Collectors.",[464,650,651],{"class":510},"toList",[464,653,654],{"class":474},"());\n",[464,656,658,661,664,667],{"class":466,"line":657},11,[464,659,660],{"class":474},"        System.out.",[464,662,663],{"class":510},"println",[464,665,666],{"class":474},"(numerosPares); ",[464,668,670],{"class":669},"sAwPA","\u002F\u002F Output: [2, 4, 6]\n",[464,672,674],{"class":466,"line":673},12,[464,675,676],{"class":474},"    }\n",[464,678,680],{"class":466,"line":679},13,[464,681,682],{"class":474},"}\n",[684,685,686,687,690,691,694,695,697],"note",{},"Ten en cuenta que para recoger los resultados de un stream en una colección, como una lista, es necesario utilizar el método ",[427,688,689],{},"collect()"," junto con un colector adecuado, como ",[427,692,693],{},"Collectors.toList()"," que nos permite obtener una lista con los elementos filtrados. Si no utilizamos ",[427,696,689],{},", el stream no se ejecutará y no obtendremos ningún resultado, ya que las operaciones en un stream son perezosas (lazy) y solo se ejecutan cuando es necesario.",[423,699,700],{},"Los tipos de \"colectores\" disponibles en Java son:",[702,703,704,717],"table",{},[705,706,707],"thead",{},[708,709,710,714],"tr",{},[711,712,713],"th",{},"Colector",[711,715,716],{},"Descripción",[718,719,720,730,740,750,760,770,788,798,814],"tbody",{},[708,721,722,727],{},[723,724,725],"td",{},[427,726,693],{},[723,728,729],{},"Recoge los elementos del stream en una lista.",[708,731,732,737],{},[723,733,734],{},[427,735,736],{},"Collectors.toSet()",[723,738,739],{},"Recoge los elementos del stream en un conjunto (set), eliminando duplicados.",[708,741,742,747],{},[723,743,744],{},[427,745,746],{},"Collectors.toMap()",[723,748,749],{},"Recoge los elementos del stream en un mapa (map), donde se especifican las claves y los valores.",[708,751,752,757],{},[723,753,754],{},[427,755,756],{},"Collectors.joining()",[723,758,759],{},"Recoge los elementos del stream en una cadena de texto, concatenándolos con un separador opcional.",[708,761,762,767],{},[723,763,764],{},[427,765,766],{},"Collectors.groupingBy()",[723,768,769],{},"Agrupa los elementos del stream según una función de clasificación, creando un mapa donde las claves son los resultados de la función y los valores son listas de elementos que corresponden a cada clave.",[708,771,772,777],{},[723,773,774],{},[427,775,776],{},"Collectors.partitioningBy()",[723,778,779,780,783,784,787],{},"Particiona los elementos del stream en dos grupos según una condición, creando un mapa donde las claves son ",[427,781,782],{},"true"," y ",[427,785,786],{},"false",", y los valores son listas de elementos que corresponden a cada grupo.",[708,789,790,795],{},[723,791,792],{},[427,793,794],{},"Collectors.counting()",[723,796,797],{},"Cuenta el número de elementos en el stream.",[708,799,800,811],{},[723,801,802,557,805,557,808],{},[427,803,804],{},"Collectors.summarizingInt()",[427,806,807],{},"Collectors.summarizingDouble()",[427,809,810],{},"Collectors.summarizingLong()",[723,812,813],{},"Recoge estadísticas como el conteo, la suma, el mínimo, el promedio y el máximo de los elementos del stream, según el tipo de datos.",[708,815,816,821],{},[723,817,818],{},[427,819,820],{},"Collectors.reducing()",[723,822,823],{},"Realiza una reducción de los elementos del stream utilizando una función de acumulación, como suma, multiplicación, etc.",[423,825,826,827,834],{},"Para consultar la documentación oficial de Java sobre los colectores, puedes visitar el siguiente enlace: ",[828,829,833],"a",{"href":830,"rel":831},"https:\u002F\u002Fdocs.oracle.com\u002Fen\u002Fjava\u002Fjavase\u002F17\u002Fdocs\u002Fapi\u002Fjava.base\u002Fjava\u002Futil\u002Fstream\u002FCollectors.html",[832],"nofollow","Java Collectors Documentation",".",[443,836,838],{"id":837},"mapeo","Mapeo",[423,840,449,841,844],{},[427,842,843],{},"map()"," se utiliza para transformar los elementos de un stream aplicando una función a cada elemento. Por ejemplo, si queremos convertir una lista de cadenas de texto a mayúsculas, podemos hacer lo siguiente:",[455,846,848],{"className":457,"code":847,"language":459,"meta":460,"style":460},"import java.util.Arrays;\nimport java.util.List;\nimport java.util.stream.Collectors;\n\npublic class Main {\n    void main() {\n        List\u003CString> palabras = Arrays.asList(\"hola\", \"mundo\", \"java\");\n        List\u003CString> palabrasMayusculas = palabras.stream()\n                                                  .map(String::toUpperCase)\n                                                  .collect(Collectors.toList());\n        System.out.println(palabrasMayusculas); \u002F\u002F Output: [HOLA, MUNDO, JAVA]\n    }\n}\n",[427,849,850,856,862,868,872,882,890,924,942,959,971,983,987],{"__ignoreMap":460},[464,851,852,854],{"class":466,"line":467},[464,853,471],{"class":470},[464,855,475],{"class":474},[464,857,858,860],{"class":466,"line":478},[464,859,471],{"class":470},[464,861,483],{"class":474},[464,863,864,866],{"class":466,"line":486},[464,865,471],{"class":470},[464,867,491],{"class":474},[464,869,870],{"class":466,"line":494},[464,871,498],{"emptyLinePlaceholder":497},[464,873,874,876,878,880],{"class":466,"line":501},[464,875,504],{"class":470},[464,877,507],{"class":470},[464,879,511],{"class":510},[464,881,514],{"class":474},[464,883,884,886,888],{"class":466,"line":517},[464,885,520],{"class":470},[464,887,523],{"class":510},[464,889,526],{"class":474},[464,891,892,894,897,900,902,904,906,908,912,914,917,919,922],{"class":466,"line":529},[464,893,532],{"class":474},[464,895,896],{"class":470},"String",[464,898,899],{"class":474},"> palabras ",[464,901,541],{"class":470},[464,903,544],{"class":474},[464,905,547],{"class":510},[464,907,550],{"class":474},[464,909,911],{"class":910},"sU2Wk","\"hola\"",[464,913,557],{"class":474},[464,915,916],{"class":910},"\"mundo\"",[464,918,557],{"class":474},[464,920,921],{"class":910},"\"java\"",[464,923,583],{"class":474},[464,925,926,928,930,933,935,938,940],{"class":466,"line":586},[464,927,532],{"class":474},[464,929,896],{"class":470},[464,931,932],{"class":474},"> palabrasMayusculas ",[464,934,541],{"class":470},[464,936,937],{"class":474}," palabras.",[464,939,601],{"class":510},[464,941,604],{"class":474},[464,943,944,947,950,953,956],{"class":466,"line":607},[464,945,946],{"class":474},"                                                  .",[464,948,949],{"class":510},"map",[464,951,952],{"class":474},"(String",[464,954,955],{"class":470},"::",[464,957,958],{"class":474},"toUpperCase)\n",[464,960,961,963,965,967,969],{"class":466,"line":640},[464,962,946],{"class":474},[464,964,645],{"class":510},[464,966,648],{"class":474},[464,968,651],{"class":510},[464,970,654],{"class":474},[464,972,973,975,977,980],{"class":466,"line":657},[464,974,660],{"class":474},[464,976,663],{"class":510},[464,978,979],{"class":474},"(palabrasMayusculas); ",[464,981,982],{"class":669},"\u002F\u002F Output: [HOLA, MUNDO, JAVA]\n",[464,984,985],{"class":466,"line":673},[464,986,676],{"class":474},[464,988,989],{"class":466,"line":679},[464,990,682],{"class":474},[992,993,994,995,997,998,1000,1001,1003,1004,1006,1007,1009,1010,1013,1014,1017,1018,1020],"tip",{},"Recuerda que el método ",[427,996,843],{}," no modifica la colección original, sino que devuelve un nuevo stream con los elementos transformados. Por lo tanto, es importante recoger los resultados en una nueva colección utilizando ",[427,999,689],{}," para obtener los elementos transformados. Si no utilizamos ",[427,1002,689],{},", el stream no se ejecutará y no obtendremos ningún resultado, ya que las operaciones en un stream son perezosas (lazy) y solo se ejecutan cuando es necesario. Además, ten en cuenta que el método ",[427,1005,843],{}," puede ser utilizado para realizar cualquier tipo de transformación, no solo para convertir a mayúsculas. Puedes aplicar cualquier función que desees a los elementos del stream, como convertir a minúsculas, extraer una parte de la cadena, incluso funciones más complejas como calcular la longitud de las cadenas, etc. La flexibilidad del método ",[427,1008,843],{}," te permite realizar una amplia variedad de transformaciones en tus datos de manera eficiente y concisa. Incluyendo las funciones lambda, que son una forma de escribir funciones anónimas de manera más concisa. Por ejemplo, en lugar de escribir ",[427,1011,1012],{},"map(String::toUpperCase)",", podríamos escribir ",[427,1015,1016],{},"map(s -> s.toUpperCase())",", lo que hace exactamente lo mismo pero utilizando una expresión lambda. Las expresiones lambda son especialmente útiles cuando queremos realizar transformaciones más complejas o cuando no queremos crear métodos adicionales para nuestras transformaciones. En resumen, el método ",[427,1019,843],{}," es una herramienta poderosa para transformar los elementos de un stream de manera eficiente y concisa, permitiéndonos aplicar cualquier función que deseemos a nuestros datos.",[443,1022,1024],{"id":1023},"reducción","Reducción",[423,1026,449,1027,1030],{},[427,1028,1029],{},"reduce()"," se utiliza para combinar los elementos de un stream en un solo resultado utilizando una función de acumulación. Por ejemplo, si queremos sumar una lista de números, podemos hacer lo siguiente:",[455,1032,1034],{"className":457,"code":1033,"language":459,"meta":460,"style":460},"import java.util.Arrays;\nimport java.util.List;\nimport java.util.Optional;\n\npublic class Main {\n    void main() {\n        List\u003CInteger> numeros = Arrays.asList(1, 2, 3, 4, 5);\n        Optional\u003CInteger> suma = numeros.stream()\n                                        .reduce((a, b) -> a + b);\n        suma.ifPresent(System.out::println); \u002F\u002F Output: 15\n    }\n}\n",[427,1035,1036,1042,1048,1055,1059,1069,1077,1113,1131,1153,1172,1176],{"__ignoreMap":460},[464,1037,1038,1040],{"class":466,"line":467},[464,1039,471],{"class":470},[464,1041,475],{"class":474},[464,1043,1044,1046],{"class":466,"line":478},[464,1045,471],{"class":470},[464,1047,483],{"class":474},[464,1049,1050,1052],{"class":466,"line":486},[464,1051,471],{"class":470},[464,1053,1054],{"class":474}," java.util.Optional;\n",[464,1056,1057],{"class":466,"line":494},[464,1058,498],{"emptyLinePlaceholder":497},[464,1060,1061,1063,1065,1067],{"class":466,"line":501},[464,1062,504],{"class":470},[464,1064,507],{"class":470},[464,1066,511],{"class":510},[464,1068,514],{"class":474},[464,1070,1071,1073,1075],{"class":466,"line":517},[464,1072,520],{"class":470},[464,1074,523],{"class":510},[464,1076,526],{"class":474},[464,1078,1079,1081,1083,1085,1087,1089,1091,1093,1095,1097,1099,1101,1103,1105,1107,1109,1111],{"class":466,"line":529},[464,1080,532],{"class":474},[464,1082,535],{"class":470},[464,1084,538],{"class":474},[464,1086,541],{"class":470},[464,1088,544],{"class":474},[464,1090,547],{"class":510},[464,1092,550],{"class":474},[464,1094,554],{"class":553},[464,1096,557],{"class":474},[464,1098,560],{"class":553},[464,1100,557],{"class":474},[464,1102,565],{"class":553},[464,1104,557],{"class":474},[464,1106,570],{"class":553},[464,1108,557],{"class":474},[464,1110,575],{"class":553},[464,1112,583],{"class":474},[464,1114,1115,1118,1120,1123,1125,1127,1129],{"class":466,"line":586},[464,1116,1117],{"class":474},"        Optional\u003C",[464,1119,535],{"class":470},[464,1121,1122],{"class":474},"> suma ",[464,1124,541],{"class":470},[464,1126,598],{"class":474},[464,1128,601],{"class":510},[464,1130,604],{"class":474},[464,1132,1133,1136,1139,1142,1144,1147,1150],{"class":466,"line":607},[464,1134,1135],{"class":474},"                                        .",[464,1137,1138],{"class":510},"reduce",[464,1140,1141],{"class":474},"((a, b) ",[464,1143,619],{"class":470},[464,1145,1146],{"class":474}," a ",[464,1148,1149],{"class":470},"+",[464,1151,1152],{"class":474}," b);\n",[464,1154,1155,1158,1161,1164,1166,1169],{"class":466,"line":640},[464,1156,1157],{"class":474},"        suma.",[464,1159,1160],{"class":510},"ifPresent",[464,1162,1163],{"class":474},"(System.out",[464,1165,955],{"class":470},[464,1167,1168],{"class":474},"println); ",[464,1170,1171],{"class":669},"\u002F\u002F Output: 15\n",[464,1173,1174],{"class":466,"line":657},[464,1175,676],{"class":474},[464,1177,1178],{"class":466,"line":673},[464,1179,682],{"class":474},[684,1181,1182,1200,1253],{},[423,1183,1184,1185,1187,1188,1191,1192,1195,1196,1199],{},"Ten en cuenta que el método ",[427,1186,1029],{}," devuelve un ",[427,1189,1190],{},"Optional"," porque el resultado de la reducción puede no estar presente si el stream está vacío. Por lo tanto, es importante manejar el caso en el que el stream no tenga elementos para evitar errores. Puedes utilizar el método ",[427,1193,1194],{},"ifPresent()"," para ejecutar una acción solo si el resultado de la reducción está presente, o puedes proporcionar un valor predeterminado utilizando el método ",[427,1197,1198],{},"orElse()"," en caso de que el stream esté vacío. Por ejemplo:",[455,1201,1203],{"className":457,"code":1202,"language":459,"meta":460,"style":460},"Integer suma = numeros.stream()\n                     .reduce(0, (a, b) -> a + b);\nSystem.out.println(suma); \u002F\u002F Output: 15\n",[427,1204,1205,1218,1241],{"__ignoreMap":460},[464,1206,1207,1210,1212,1214,1216],{"class":466,"line":467},[464,1208,1209],{"class":474},"Integer suma ",[464,1211,541],{"class":470},[464,1213,598],{"class":474},[464,1215,601],{"class":510},[464,1217,604],{"class":474},[464,1219,1220,1223,1225,1227,1230,1233,1235,1237,1239],{"class":466,"line":478},[464,1221,1222],{"class":474},"                     .",[464,1224,1138],{"class":510},[464,1226,550],{"class":474},[464,1228,1229],{"class":553},"0",[464,1231,1232],{"class":474},", (a, b) ",[464,1234,619],{"class":470},[464,1236,1146],{"class":474},[464,1238,1149],{"class":470},[464,1240,1152],{"class":474},[464,1242,1243,1246,1248,1251],{"class":466,"line":486},[464,1244,1245],{"class":474},"System.out.",[464,1247,663],{"class":510},[464,1249,1250],{"class":474},"(suma); ",[464,1252,1171],{"class":669},[423,1254,1255,1256,1258,1259,1261,1262,1264,1265,1267],{},"En este caso, hemos proporcionado un valor predeterminado de ",[427,1257,1229],{}," para la reducción, lo que significa que si el stream está vacío, el resultado será ",[427,1260,1229],{}," en lugar de un ",[427,1263,1190],{}," vacío. Esto puede ser útil en situaciones donde deseas asegurarte de obtener un resultado incluso cuando no hay elementos en el stream. En resumen, el método ",[427,1266,1029],{}," es una herramienta poderosa para combinar los elementos de un stream en un solo resultado utilizando una función de acumulación, pero es importante manejar adecuadamente el caso en el que el stream esté vacío para evitar errores y obtener resultados consistentes.",[418,1269,1271],{"id":1270},"conclusión","Conclusión",[423,1273,1274,1275,1277,1278,557,1280,783,1282,1284,1285,1287],{},"En resumen, la clase ",[427,1276,429],{}," en Java es una herramienta poderosa para procesar colecciones de datos de manera eficiente y funcional. Con métodos como ",[427,1279,452],{},[427,1281,843],{},[427,1283,1029],{},", puedes realizar operaciones complejas en tus datos de manera concisa y legible. Además, los colectores disponibles en Java te permiten recoger los resultados de tus operaciones en diferentes tipos de colecciones, facilitando aún más el manejo de tus datos. Al utilizar la clase ",[427,1286,429],{},", puedes escribir código más limpio, eficiente y fácil de mantener para procesar tus datos en Java.",[1289,1290,1291],"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 pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}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}",{"title":460,"searchDepth":478,"depth":478,"links":1293},[1294,1295,1300],{"id":420,"depth":478,"text":421},{"id":440,"depth":478,"text":441,"children":1296},[1297,1298,1299],{"id":445,"depth":486,"text":446},{"id":837,"depth":486,"text":838},{"id":1023,"depth":486,"text":1024},{"id":1270,"depth":478,"text":1271},"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.","md",null,{"editButton":42},{"title":228,"description":1301},"6NSCeUY4cSX04Fonbl6ywVDcaE5X16gC43LvBT8C2XQ",[1308,1310],{"title":224,"path":225,"stem":226,"description":1309,"children":-1},"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.",{"title":237,"path":238,"stem":239,"description":1311,"children":-1},"Introducción al paquete Swing para la creación de interfaces gráficas en Java.",1779479571636]