[{"data":1,"prerenderedAt":1354},["ShallowReactive",2],{"navigation_docs":3,"-metodos-predicados":412,"-metodos-predicados-surround":1349},[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":157,"body":414,"description":1343,"extension":1344,"links":1345,"meta":1346,"navigation":622,"path":158,"seo":1347,"stem":159,"__hash__":1348},"docs\u002F4.metodos\u002F09.predicados.md",{"type":415,"value":416,"toc":1328},"minimark",[417,422,435,440,443,503,507,522,569,573,588,595,605,761,764,779,782,792,926,933,937,955,958,970,1080,1085,1092,1195,1200,1207,1306,1310,1324],[418,419,421],"h2",{"id":420},"qué-son-los-predicados-simples-y-compuestos","¿Qué son los predicados simples y compuestos?",[423,424,425,426,430,431,434],"p",{},"En Java, un predicado es una función que toma uno o más argumentos y devuelve un valor booleano (",[427,428,429],"code",{},"true"," o ",[427,432,433],{},"false","). Los predicados se utilizan para evaluar condiciones y tomar decisiones en el código.",[436,437,439],"h3",{"id":438},"predicados-simples","Predicados Simples",[423,441,442],{},"Un predicado simple es una función que evalúa una sola condición. Por ejemplo, un predicado que verifica si un número es mayor que 10 podría ser:",[444,445,450],"pre",{"className":446,"code":447,"language":448,"meta":449,"style":449},"language-java shiki shiki-themes github-dark","public boolean esMayorQueDiez(int numero) {\n    return numero > 10;\n}\n","java","",[427,451,452,478,497],{"__ignoreMap":449},[453,454,457,461,464,468,472,475],"span",{"class":455,"line":456},"line",1,[453,458,460],{"class":459},"snl16","public",[453,462,463],{"class":459}," boolean",[453,465,467],{"class":466},"svObZ"," esMayorQueDiez",[453,469,471],{"class":470},"s95oV","(",[453,473,474],{"class":459},"int",[453,476,477],{"class":470}," numero) {\n",[453,479,481,484,487,490,494],{"class":455,"line":480},2,[453,482,483],{"class":459},"    return",[453,485,486],{"class":470}," numero ",[453,488,489],{"class":459},">",[453,491,493],{"class":492},"sDLfK"," 10",[453,495,496],{"class":470},";\n",[453,498,500],{"class":455,"line":499},3,[453,501,502],{"class":470},"}\n",[436,504,506],{"id":505},"predicados-compuestos","Predicados Compuestos",[423,508,509,510,513,514,517,518,521],{},"Un predicado compuesto es una función que combina múltiples predicados simples utilizando operadores lógicos como ",[427,511,512],{},"&&"," (AND), ",[427,515,516],{},"||"," (OR) y ",[427,519,520],{},"!"," (NOT). Por ejemplo, un predicado compuesto que verifica si un número es mayor que 10 y menor que 20 podría ser:",[444,523,525],{"className":446,"code":524,"language":448,"meta":449,"style":449},"public boolean estaEntreDiezYVeinte(int numero) {\n    return numero > 10 && numero \u003C 20;\n}\n",[427,526,527,542,565],{"__ignoreMap":449},[453,528,529,531,533,536,538,540],{"class":455,"line":456},[453,530,460],{"class":459},[453,532,463],{"class":459},[453,534,535],{"class":466}," estaEntreDiezYVeinte",[453,537,471],{"class":470},[453,539,474],{"class":459},[453,541,477],{"class":470},[453,543,544,546,548,550,552,555,557,560,563],{"class":455,"line":480},[453,545,483],{"class":459},[453,547,486],{"class":470},[453,549,489],{"class":459},[453,551,493],{"class":492},[453,553,554],{"class":459}," &&",[453,556,486],{"class":470},[453,558,559],{"class":459},"\u003C",[453,561,562],{"class":492}," 20",[453,564,496],{"class":470},[453,566,567],{"class":455,"line":499},[453,568,502],{"class":470},[418,570,572],{"id":571},"uso-de-predicados-en-java","Uso de Predicados en Java",[423,574,575,576,579,580,583,584,587],{},"En Java, contamos con las interfaces funcionales ",[427,577,578],{},"Predicate\u003CT>"," y ",[427,581,582],{},"BiPredicate\u003CT, U>"," en el paquete ",[427,585,586],{},"java.util.function",", que nos permiten trabajar con predicados de manera más flexible, especialmente en el contexto de expresiones lambda.",[418,589,591,592],{"id":590},"predicate","Predicate",[593,594],"t",{},[423,596,597,598,600,601,604],{},"La interfaz ",[427,599,578],{}," representa un predicado que toma un argumento de tipo ",[427,602,603],{},"T"," y devuelve un valor booleano. Por ejemplo:",[444,606,608],{"className":446,"code":607,"language":448,"meta":449,"style":449},"import java.util.function.Predicate;\n\npublic class PredicadoEjemplo {\n    public static void main(String[] args) {\n        Predicate\u003CInteger> esMayorQueDiez = numero -> numero > 10;\n        \n        System.out.println(esMayorQueDiez.test(15)); \u002F\u002F true\n        System.out.println(esMayorQueDiez.test(5));  \u002F\u002F false\n    }\n}\n",[427,609,610,618,624,637,667,695,701,728,750,756],{"__ignoreMap":449},[453,611,612,615],{"class":455,"line":456},[453,613,614],{"class":459},"import",[453,616,617],{"class":470}," java.util.function.Predicate;\n",[453,619,620],{"class":455,"line":480},[453,621,623],{"emptyLinePlaceholder":622},true,"\n",[453,625,626,628,631,634],{"class":455,"line":499},[453,627,460],{"class":459},[453,629,630],{"class":459}," class",[453,632,633],{"class":466}," PredicadoEjemplo",[453,635,636],{"class":470}," {\n",[453,638,640,643,646,649,652,654,657,660,664],{"class":455,"line":639},4,[453,641,642],{"class":459},"    public",[453,644,645],{"class":459}," static",[453,647,648],{"class":459}," void",[453,650,651],{"class":466}," main",[453,653,471],{"class":470},[453,655,656],{"class":459},"String",[453,658,659],{"class":470},"[] ",[453,661,663],{"class":662},"s9osk","args",[453,665,666],{"class":470},") {\n",[453,668,670,673,676,679,682,684,687,689,691,693],{"class":455,"line":669},5,[453,671,672],{"class":470},"        Predicate\u003C",[453,674,675],{"class":459},"Integer",[453,677,678],{"class":470},"> esMayorQueDiez ",[453,680,681],{"class":459},"=",[453,683,486],{"class":470},[453,685,686],{"class":459},"->",[453,688,486],{"class":470},[453,690,489],{"class":459},[453,692,493],{"class":492},[453,694,496],{"class":470},[453,696,698],{"class":455,"line":697},6,[453,699,700],{"class":470},"        \n",[453,702,704,707,710,713,716,718,721,724],{"class":455,"line":703},7,[453,705,706],{"class":470},"        System.out.",[453,708,709],{"class":466},"println",[453,711,712],{"class":470},"(esMayorQueDiez.",[453,714,715],{"class":466},"test",[453,717,471],{"class":470},[453,719,720],{"class":492},"15",[453,722,723],{"class":470},")); ",[453,725,727],{"class":726},"sAwPA","\u002F\u002F true\n",[453,729,731,733,735,737,739,741,744,747],{"class":455,"line":730},8,[453,732,706],{"class":470},[453,734,709],{"class":466},[453,736,712],{"class":470},[453,738,715],{"class":466},[453,740,471],{"class":470},[453,742,743],{"class":492},"5",[453,745,746],{"class":470},"));  ",[453,748,749],{"class":726},"\u002F\u002F false\n",[453,751,753],{"class":455,"line":752},9,[453,754,755],{"class":470},"    }\n",[453,757,759],{"class":455,"line":758},10,[453,760,502],{"class":470},[423,762,763],{},"En este ejemplo, se define un predicado que verifica si un número es mayor que 10 utilizando una expresión lambda.",[765,766,767,768,771,772,579,775,778],"note",{},"Los predicados son fundamentales para la programación funcional en Java, ya que permiten escribir código más conciso y expresivo, especialmente cuando se combinan con otras interfaces funcionales como ",[427,769,770],{},"Function",", ",[427,773,774],{},"Consumer",[427,776,777],{},"Supplier",". Además, los predicados compuestos pueden ser utilizados para crear condiciones más complejas de manera clara y legible.",[418,780,582],{"id":781},"bipredicatet-u",[423,783,597,784,786,787,579,789,604],{},[427,785,582],{}," representa un predicado que toma dos argumentos de tipos ",[427,788,603],{},[427,790,791],{},"U",[444,793,795],{"className":446,"code":794,"language":448,"meta":449,"style":449},"import java.util.function.BiPredicate;\n\npublic class BiPredicadoEjemplo {\n    public static void main(String[] args) {\n        BiPredicate\u003CInteger, Integer> esMayor = (a, b) -> a > b;\n        \n        System.out.println(esMayor.test(15, 10)); \u002F\u002F true\n        System.out.println(esMayor.test(5, 10));  \u002F\u002F false\n    }\n}\n",[427,796,797,804,808,819,839,868,872,896,918,922],{"__ignoreMap":449},[453,798,799,801],{"class":455,"line":456},[453,800,614],{"class":459},[453,802,803],{"class":470}," java.util.function.BiPredicate;\n",[453,805,806],{"class":455,"line":480},[453,807,623],{"emptyLinePlaceholder":622},[453,809,810,812,814,817],{"class":455,"line":499},[453,811,460],{"class":459},[453,813,630],{"class":459},[453,815,816],{"class":466}," BiPredicadoEjemplo",[453,818,636],{"class":470},[453,820,821,823,825,827,829,831,833,835,837],{"class":455,"line":639},[453,822,642],{"class":459},[453,824,645],{"class":459},[453,826,648],{"class":459},[453,828,651],{"class":466},[453,830,471],{"class":470},[453,832,656],{"class":459},[453,834,659],{"class":470},[453,836,663],{"class":662},[453,838,666],{"class":470},[453,840,841,844,846,848,850,853,855,858,860,863,865],{"class":455,"line":669},[453,842,843],{"class":470},"        BiPredicate\u003C",[453,845,675],{"class":459},[453,847,771],{"class":470},[453,849,675],{"class":459},[453,851,852],{"class":470},"> esMayor ",[453,854,681],{"class":459},[453,856,857],{"class":470}," (a, b) ",[453,859,686],{"class":459},[453,861,862],{"class":470}," a ",[453,864,489],{"class":459},[453,866,867],{"class":470}," b;\n",[453,869,870],{"class":455,"line":697},[453,871,700],{"class":470},[453,873,874,876,878,881,883,885,887,889,892,894],{"class":455,"line":703},[453,875,706],{"class":470},[453,877,709],{"class":466},[453,879,880],{"class":470},"(esMayor.",[453,882,715],{"class":466},[453,884,471],{"class":470},[453,886,720],{"class":492},[453,888,771],{"class":470},[453,890,891],{"class":492},"10",[453,893,723],{"class":470},[453,895,727],{"class":726},[453,897,898,900,902,904,906,908,910,912,914,916],{"class":455,"line":730},[453,899,706],{"class":470},[453,901,709],{"class":466},[453,903,880],{"class":470},[453,905,715],{"class":466},[453,907,471],{"class":470},[453,909,743],{"class":492},[453,911,771],{"class":470},[453,913,891],{"class":492},[453,915,746],{"class":470},[453,917,749],{"class":726},[453,919,920],{"class":455,"line":752},[453,921,755],{"class":470},[453,923,924],{"class":455,"line":758},[453,925,502],{"class":470},[423,927,928,929,932],{},"En este ejemplo, se define un ",[427,930,931],{},"BiPredicate"," que verifica si el primer número es mayor que el segundo número utilizando una expresión lambda.",[418,934,936],{"id":935},"function-consumer-y-supplier","Function, Consumer y Supplier",[423,938,939,940,579,942,944,945,771,948,579,951,954],{},"Además de ",[427,941,591],{},[427,943,931],{},", Java proporciona otras interfaces funcionales como ",[427,946,947],{},"Function\u003CT, R>",[427,949,950],{},"Consumer\u003CT>",[427,952,953],{},"Supplier\u003CT>",", que se utilizan para representar funciones que toman argumentos y devuelven resultados, consumen argumentos sin devolver resultados, o suministran resultados sin tomar argumentos, respectivamente. Estas interfaces son esenciales para la programación funcional en Java y se pueden combinar con predicados para crear código más flexible y reutilizable.",[436,956,947],{"id":957},"functiont-r",[423,959,597,960,962,963,965,966,969],{},[427,961,947],{}," representa una función que toma un argumento de tipo ",[427,964,603],{}," y devuelve un resultado de tipo ",[427,967,968],{},"R",". Por ejemplo:",[444,971,973],{"className":446,"code":972,"language":448,"meta":449,"style":449},"import java.util.function.Function;\n\npublic class FunctionEjemplo {\n    public static void main(String[] args) {\n        Function\u003CInteger, String> convertirAString = numero -> \"Número: \" + numero;\n        \n        System.out.println(convertirAString.apply(10)); \u002F\u002F Número: 10\n    }\n}\n",[427,974,975,982,986,997,1017,1047,1051,1072,1076],{"__ignoreMap":449},[453,976,977,979],{"class":455,"line":456},[453,978,614],{"class":459},[453,980,981],{"class":470}," java.util.function.Function;\n",[453,983,984],{"class":455,"line":480},[453,985,623],{"emptyLinePlaceholder":622},[453,987,988,990,992,995],{"class":455,"line":499},[453,989,460],{"class":459},[453,991,630],{"class":459},[453,993,994],{"class":466}," FunctionEjemplo",[453,996,636],{"class":470},[453,998,999,1001,1003,1005,1007,1009,1011,1013,1015],{"class":455,"line":639},[453,1000,642],{"class":459},[453,1002,645],{"class":459},[453,1004,648],{"class":459},[453,1006,651],{"class":466},[453,1008,471],{"class":470},[453,1010,656],{"class":459},[453,1012,659],{"class":470},[453,1014,663],{"class":662},[453,1016,666],{"class":470},[453,1018,1019,1022,1024,1026,1028,1031,1033,1035,1037,1041,1044],{"class":455,"line":669},[453,1020,1021],{"class":470},"        Function\u003C",[453,1023,675],{"class":459},[453,1025,771],{"class":470},[453,1027,656],{"class":459},[453,1029,1030],{"class":470},"> convertirAString ",[453,1032,681],{"class":459},[453,1034,486],{"class":470},[453,1036,686],{"class":459},[453,1038,1040],{"class":1039},"sU2Wk"," \"Número: \"",[453,1042,1043],{"class":459}," +",[453,1045,1046],{"class":470}," numero;\n",[453,1048,1049],{"class":455,"line":697},[453,1050,700],{"class":470},[453,1052,1053,1055,1057,1060,1063,1065,1067,1069],{"class":455,"line":703},[453,1054,706],{"class":470},[453,1056,709],{"class":466},[453,1058,1059],{"class":470},"(convertirAString.",[453,1061,1062],{"class":466},"apply",[453,1064,471],{"class":470},[453,1066,891],{"class":492},[453,1068,723],{"class":470},[453,1070,1071],{"class":726},"\u002F\u002F Número: 10\n",[453,1073,1074],{"class":455,"line":730},[453,1075,755],{"class":470},[453,1077,1078],{"class":455,"line":752},[453,1079,502],{"class":470},[436,1081,774,1083],{"id":1082},"consumer",[593,1084],{},[423,1086,597,1087,962,1089,1091],{},[427,1088,950],{},[427,1090,603],{}," y no devuelve ningún resultado. Por ejemplo:",[444,1093,1095],{"className":446,"code":1094,"language":448,"meta":449,"style":449},"import java.util.function.Consumer;\n\npublic class ConsumerEjemplo {\n    public static void main(String[] args) {\n        Consumer\u003CString> imprimir = mensaje -> System.out.println(mensaje);\n        \n        imprimir.accept(\"Hola, mundo!\"); \u002F\u002F Hola, mundo!\n    }\n}\n",[427,1096,1097,1104,1108,1119,1139,1164,1168,1187,1191],{"__ignoreMap":449},[453,1098,1099,1101],{"class":455,"line":456},[453,1100,614],{"class":459},[453,1102,1103],{"class":470}," java.util.function.Consumer;\n",[453,1105,1106],{"class":455,"line":480},[453,1107,623],{"emptyLinePlaceholder":622},[453,1109,1110,1112,1114,1117],{"class":455,"line":499},[453,1111,460],{"class":459},[453,1113,630],{"class":459},[453,1115,1116],{"class":466}," ConsumerEjemplo",[453,1118,636],{"class":470},[453,1120,1121,1123,1125,1127,1129,1131,1133,1135,1137],{"class":455,"line":639},[453,1122,642],{"class":459},[453,1124,645],{"class":459},[453,1126,648],{"class":459},[453,1128,651],{"class":466},[453,1130,471],{"class":470},[453,1132,656],{"class":459},[453,1134,659],{"class":470},[453,1136,663],{"class":662},[453,1138,666],{"class":470},[453,1140,1141,1144,1146,1149,1151,1154,1156,1159,1161],{"class":455,"line":669},[453,1142,1143],{"class":470},"        Consumer\u003C",[453,1145,656],{"class":459},[453,1147,1148],{"class":470},"> imprimir ",[453,1150,681],{"class":459},[453,1152,1153],{"class":470}," mensaje ",[453,1155,686],{"class":459},[453,1157,1158],{"class":470}," System.out.",[453,1160,709],{"class":466},[453,1162,1163],{"class":470},"(mensaje);\n",[453,1165,1166],{"class":455,"line":697},[453,1167,700],{"class":470},[453,1169,1170,1173,1176,1178,1181,1184],{"class":455,"line":703},[453,1171,1172],{"class":470},"        imprimir.",[453,1174,1175],{"class":466},"accept",[453,1177,471],{"class":470},[453,1179,1180],{"class":1039},"\"Hola, mundo!\"",[453,1182,1183],{"class":470},"); ",[453,1185,1186],{"class":726},"\u002F\u002F Hola, mundo!\n",[453,1188,1189],{"class":455,"line":730},[453,1190,755],{"class":470},[453,1192,1193],{"class":455,"line":752},[453,1194,502],{"class":470},[436,1196,777,1198],{"id":1197},"supplier",[593,1199],{},[423,1201,597,1202,1204,1205,969],{},[427,1203,953],{}," representa una función que no toma argumentos y devuelve un resultado de tipo ",[427,1206,603],{},[444,1208,1210],{"className":446,"code":1209,"language":448,"meta":449,"style":449},"import java.util.function.Supplier;\n\npublic class SupplierEjemplo {\n    public static void main(String[] args) {\n        Supplier\u003CString> suministrarMensaje = () -> \"Mensaje suministrado\";\n        \n        System.out.println(suministrarMensaje.get()); \u002F\u002F Mensaje suministrado\n    }\n}\n",[427,1211,1212,1219,1223,1234,1254,1276,1280,1298,1302],{"__ignoreMap":449},[453,1213,1214,1216],{"class":455,"line":456},[453,1215,614],{"class":459},[453,1217,1218],{"class":470}," java.util.function.Supplier;\n",[453,1220,1221],{"class":455,"line":480},[453,1222,623],{"emptyLinePlaceholder":622},[453,1224,1225,1227,1229,1232],{"class":455,"line":499},[453,1226,460],{"class":459},[453,1228,630],{"class":459},[453,1230,1231],{"class":466}," SupplierEjemplo",[453,1233,636],{"class":470},[453,1235,1236,1238,1240,1242,1244,1246,1248,1250,1252],{"class":455,"line":639},[453,1237,642],{"class":459},[453,1239,645],{"class":459},[453,1241,648],{"class":459},[453,1243,651],{"class":466},[453,1245,471],{"class":470},[453,1247,656],{"class":459},[453,1249,659],{"class":470},[453,1251,663],{"class":662},[453,1253,666],{"class":470},[453,1255,1256,1259,1261,1264,1266,1269,1271,1274],{"class":455,"line":669},[453,1257,1258],{"class":470},"        Supplier\u003C",[453,1260,656],{"class":459},[453,1262,1263],{"class":470},"> suministrarMensaje ",[453,1265,681],{"class":459},[453,1267,1268],{"class":470}," () ",[453,1270,686],{"class":459},[453,1272,1273],{"class":1039}," \"Mensaje suministrado\"",[453,1275,496],{"class":470},[453,1277,1278],{"class":455,"line":697},[453,1279,700],{"class":470},[453,1281,1282,1284,1286,1289,1292,1295],{"class":455,"line":703},[453,1283,706],{"class":470},[453,1285,709],{"class":466},[453,1287,1288],{"class":470},"(suministrarMensaje.",[453,1290,1291],{"class":466},"get",[453,1293,1294],{"class":470},"()); ",[453,1296,1297],{"class":726},"\u002F\u002F Mensaje suministrado\n",[453,1299,1300],{"class":455,"line":730},[453,1301,755],{"class":470},[453,1303,1304],{"class":455,"line":752},[453,1305,502],{"class":470},[418,1307,1309],{"id":1308},"conclusión","Conclusión",[423,1311,1312,1313,771,1315,771,1317,771,1319,579,1321,1323],{},"Los predicados simples y compuestos son herramientas poderosas en Java para evaluar condiciones y tomar decisiones en el código. Las interfaces funcionales como ",[427,1314,591],{},[427,1316,931],{},[427,1318,770],{},[427,1320,774],{},[427,1322,777],{}," permiten trabajar con funciones de manera flexible y expresiva, facilitando la programación funcional en Java. Al combinar predicados simples con operadores lógicos, podemos crear condiciones más complejas de manera clara y legible, mejorando la calidad y mantenibilidad del código.",[1325,1326,1327],"style",{},"html pre.shiki code .snl16, html code.shiki .snl16{--shiki-default:#F97583}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html pre.shiki code .s95oV, html code.shiki .s95oV{--shiki-default:#E1E4E8}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}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 .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}",{"title":449,"searchDepth":480,"depth":480,"links":1329},[1330,1334,1335,1336,1337,1342],{"id":420,"depth":480,"text":421,"children":1331},[1332,1333],{"id":438,"depth":499,"text":439},{"id":505,"depth":499,"text":506},{"id":571,"depth":480,"text":572},{"id":590,"depth":480,"text":591},{"id":781,"depth":480,"text":582},{"id":935,"depth":480,"text":936,"children":1338},[1339,1340,1341],{"id":957,"depth":499,"text":947},{"id":1082,"depth":499,"text":774},{"id":1197,"depth":499,"text":777},{"id":1308,"depth":480,"text":1309},"En este artículo, se explica qué son los predicados simples y compuestos en Java, cómo se utilizan para evaluar condiciones y tomar decisiones en el código, y se proporcionan ejemplos de cómo implementar y usar predicados en diferentes contextos, como en estructuras de control y expresiones lambda.","md",null,{"editButton":42},{"title":157,"description":1343},"LVz-go1jXB-uuiFao35qUPVkpwAE6WGMtv14hs5xJqo",[1350,1352],{"title":153,"path":154,"stem":155,"description":1351,"children":-1},"En este artículo, se explica la clase `Arrays` en Java, que proporciona métodos estáticos para manipular arreglos, incluyendo cómo ordenar, buscar y comparar arreglos, así como ejemplos de cómo utilizar estos métodos para realizar operaciones comunes con arreglos.",{"title":166,"path":162,"stem":163,"description":1353,"children":-1},"La herencia es un concepto fundamental en la programación orientada a objetos que permite crear nuevas clases basadas en clases existentes, facilitando la reutilización de código y la creación de jerarquías de clases.",1779479569590]