[{"data":1,"prerenderedAt":1269},["ShallowReactive",2],{"navigation_docs":3,"-archivos-ui-streams":412,"-archivos-ui-streams-surround":1264},[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":297,"body":414,"description":1258,"extension":1259,"links":1260,"meta":1261,"navigation":615,"path":298,"seo":1262,"stem":299,"__hash__":1263},"docs\u002F7.archivos-ui\u002F16.streams.md",{"type":415,"value":416,"toc":1248},"minimark",[417,422,426,430,433,465,468,473,512,516,559,563,572,798,816,824,964,973,981,991,995,1001,1222,1234,1238,1244],[418,419,421],"h2",{"id":420},"qué-son-los-streams-de-entrada-y-salida","¿Qué son los Streams de Entrada y Salida?",[423,424,425],"p",{},"Los Streams de Entrada y Salida en Java son una parte fundamental de la API de E\u002FS (Entrada\u002FSalida) que permite a los programadores leer y escribir datos de manera eficiente. Un Stream es una secuencia de datos que se puede leer o escribir, y se utiliza para manejar la entrada y salida de datos en diferentes formatos, como archivos, redes, memoria, etc.",[418,427,429],{"id":428},"tipos-de-streams","Tipos de Streams",[423,431,432],{},"En Java, existen dos tipos principales de Streams:",[434,435,436,453],"ol",{},[437,438,439,443,444,448,449,452],"li",{},[440,441,442],"strong",{},"Streams de Bytes",": Estos Streams manejan datos en forma de bytes. Son útiles para trabajar con archivos binarios, como imágenes o archivos ejecutables. Las clases principales para manejar Streams de Bytes son ",[445,446,447],"code",{},"InputStream"," y ",[445,450,451],{},"OutputStream",".",[437,454,455,458,459,448,462,452],{},[440,456,457],{},"Streams de Caracteres",": Estos Streams manejan datos en forma de caracteres. Son ideales para trabajar con archivos de texto. Las clases principales para manejar Streams de Caracteres son ",[445,460,461],{},"Reader",[445,463,464],{},"Writer",[423,466,467],{},"Estas categorías se dividen en varias subclases que proporcionan funcionalidades específicas para diferentes tipos de datos y fuentes de entrada\u002Fsalida.",[469,470,472],"h3",{"id":471},"subclases-de-streams-de-bytes","Subclases de Streams de Bytes",[474,475,476,485,494,503],"ul",{},[437,477,478,448,481,484],{},[445,479,480],{},"FileInputStream",[445,482,483],{},"FileOutputStream",": Para leer y escribir archivos.",[437,486,487,448,490,493],{},[445,488,489],{},"BufferedInputStream",[445,491,492],{},"BufferedOutputStream",": Para mejorar el rendimiento al leer y escribir datos al usar un buffer.",[437,495,496,448,499,502],{},[445,497,498],{},"DataInputStream",[445,500,501],{},"DataOutputStream",": Para leer y escribir datos primitivos de Java de manera eficiente.",[437,504,505,448,508,511],{},[445,506,507],{},"ObjectInputStream",[445,509,510],{},"ObjectOutputStream",": Para leer y escribir objetos Java completos.",[469,513,515],{"id":514},"subclases-de-streams-de-caracteres","Subclases de Streams de Caracteres",[474,517,518,527,535,541,550],{},[437,519,520,448,523,526],{},[445,521,522],{},"FileReader",[445,524,525],{},"FileWriter",": Para leer y escribir archivos de texto.",[437,528,529,448,532,493],{},[445,530,531],{},"BufferedReader",[445,533,534],{},"BufferedWriter",[437,536,537,540],{},[445,538,539],{},"PrintWriter",": Para escribir datos de texto de manera conveniente, con métodos para imprimir diferentes tipos de datos.",[437,542,543,448,546,549],{},[445,544,545],{},"InputStreamReader",[445,547,548],{},"OutputStreamWriter",": Para convertir entre Streams de Bytes y Streams de Caracteres.",[437,551,552,448,555,558],{},[445,553,554],{},"StringReader",[445,556,557],{},"StringWriter",": Para leer y escribir datos de texto en memoria.",[418,560,562],{"id":561},"uso-de-streams","Uso de Streams",[423,564,565,566,568,569,571],{},"Algo que debe de quedar claro es que los Streams en Java son unidireccionales, lo que significa que un Stream de Entrada solo puede ser utilizado para leer datos, mientras que un Stream de Salida solo puede ser utilizado para escribir datos. Para manejar ambos tipos de operaciones, se deben utilizar Streams separados. Por ejemplo, para leer un archivo de texto, se puede usar un ",[445,567,522],{}," junto con un ",[445,570,531],{}," para mejorar el rendimiento:",[573,574,579],"pre",{"className":575,"code":576,"language":577,"meta":578,"style":578},"language-java shiki shiki-themes github-dark","import java.io.BufferedReader;\nimport java.io.FileReader;\nimport java.io.IOException;\n\npublic class LeerArchivo {\n    void main() {\n        String rutaArchivo = \"ruta\u002Fal\u002Farchivo.txt\";\n        \n        try (BufferedReader br = new BufferedReader(new FileReader(rutaArchivo))) {\n            String linea;\n            while ((linea = br.readLine()) != null) {\n                System.out.println(linea);\n            }\n        } catch (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}\n","java","",[445,580,581,594,602,610,617,633,645,661,667,696,702,732,744,750,768,780,786,792],{"__ignoreMap":578},[582,583,586,590],"span",{"class":584,"line":585},"line",1,[582,587,589],{"class":588},"snl16","import",[582,591,593],{"class":592},"s95oV"," java.io.BufferedReader;\n",[582,595,597,599],{"class":584,"line":596},2,[582,598,589],{"class":588},[582,600,601],{"class":592}," java.io.FileReader;\n",[582,603,605,607],{"class":584,"line":604},3,[582,606,589],{"class":588},[582,608,609],{"class":592}," java.io.IOException;\n",[582,611,613],{"class":584,"line":612},4,[582,614,616],{"emptyLinePlaceholder":615},true,"\n",[582,618,620,623,626,630],{"class":584,"line":619},5,[582,621,622],{"class":588},"public",[582,624,625],{"class":588}," class",[582,627,629],{"class":628},"svObZ"," LeerArchivo",[582,631,632],{"class":592}," {\n",[582,634,636,639,642],{"class":584,"line":635},6,[582,637,638],{"class":588},"    void",[582,640,641],{"class":628}," main",[582,643,644],{"class":592},"() {\n",[582,646,648,651,654,658],{"class":584,"line":647},7,[582,649,650],{"class":592},"        String rutaArchivo ",[582,652,653],{"class":588},"=",[582,655,657],{"class":656},"sU2Wk"," \"ruta\u002Fal\u002Farchivo.txt\"",[582,659,660],{"class":592},";\n",[582,662,664],{"class":584,"line":663},8,[582,665,666],{"class":592},"        \n",[582,668,670,673,676,678,681,684,687,690,693],{"class":584,"line":669},9,[582,671,672],{"class":588},"        try",[582,674,675],{"class":592}," (BufferedReader br ",[582,677,653],{"class":588},[582,679,680],{"class":588}," new",[582,682,683],{"class":628}," BufferedReader",[582,685,686],{"class":592},"(",[582,688,689],{"class":588},"new",[582,691,692],{"class":628}," FileReader",[582,694,695],{"class":592},"(rutaArchivo))) {\n",[582,697,699],{"class":584,"line":698},10,[582,700,701],{"class":592},"            String linea;\n",[582,703,705,708,711,713,716,719,722,725,729],{"class":584,"line":704},11,[582,706,707],{"class":588},"            while",[582,709,710],{"class":592}," ((linea ",[582,712,653],{"class":588},[582,714,715],{"class":592}," br.",[582,717,718],{"class":628},"readLine",[582,720,721],{"class":592},"()) ",[582,723,724],{"class":588},"!=",[582,726,728],{"class":727},"sDLfK"," null",[582,730,731],{"class":592},") {\n",[582,733,735,738,741],{"class":584,"line":734},12,[582,736,737],{"class":592},"                System.out.",[582,739,740],{"class":628},"println",[582,742,743],{"class":592},"(linea);\n",[582,745,747],{"class":584,"line":746},13,[582,748,749],{"class":592},"            }\n",[582,751,753,756,759,762,766],{"class":584,"line":752},14,[582,754,755],{"class":592},"        } ",[582,757,758],{"class":588},"catch",[582,760,761],{"class":592}," (IOException ",[582,763,765],{"class":764},"s9osk","e",[582,767,731],{"class":592},[582,769,771,774,777],{"class":584,"line":770},15,[582,772,773],{"class":592},"            e.",[582,775,776],{"class":628},"printStackTrace",[582,778,779],{"class":592},"();\n",[582,781,783],{"class":584,"line":782},16,[582,784,785],{"class":592},"        }\n",[582,787,789],{"class":584,"line":788},17,[582,790,791],{"class":592},"    }\n",[582,793,795],{"class":584,"line":794},18,[582,796,797],{"class":592},"}\n",[799,800,801,802,805,806,809,810,812,813,815],"note",{},"Quizás te preguntes por qué el bloque ",[445,803,804],{},"try"," tiene paréntesis, esto se debe a que se está utilizando el bloque ",[445,807,808],{},"try-with-resources",", que es una forma de asegurar que los recursos se cierren automáticamente después de su uso, evitando así posibles fugas de recursos. En este caso, el Stream ",[445,811,531],{}," se cerrará automáticamente al finalizar el bloque ",[445,814,804],{},", incluso si ocurre una excepción.",[423,817,818,819,568,821,823],{},"De manera similar, para escribir en un archivo de texto, se puede usar un ",[445,820,525],{},[445,822,534],{},":",[573,825,827],{"className":575,"code":826,"language":577,"meta":578,"style":578},"import java.io.BufferedWriter;\nimport java.io.FileWriter;\nimport java.io.IOException;\n\npublic class EscribirArchivo {\n    void main() {\n        String rutaArchivo = \"ruta\u002Fal\u002Farchivo.txt\";\n        String contenido = \"Este es un ejemplo de escritura en un archivo.\";\n\n        try (BufferedWriter bw = new BufferedWriter(new FileWriter(rutaArchivo))) {\n            bw.write(contenido);\n        } catch (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}\n",[445,828,829,836,843,849,853,864,872,882,894,898,921,932,944,952,956,960],{"__ignoreMap":578},[582,830,831,833],{"class":584,"line":585},[582,832,589],{"class":588},[582,834,835],{"class":592}," java.io.BufferedWriter;\n",[582,837,838,840],{"class":584,"line":596},[582,839,589],{"class":588},[582,841,842],{"class":592}," java.io.FileWriter;\n",[582,844,845,847],{"class":584,"line":604},[582,846,589],{"class":588},[582,848,609],{"class":592},[582,850,851],{"class":584,"line":612},[582,852,616],{"emptyLinePlaceholder":615},[582,854,855,857,859,862],{"class":584,"line":619},[582,856,622],{"class":588},[582,858,625],{"class":588},[582,860,861],{"class":628}," EscribirArchivo",[582,863,632],{"class":592},[582,865,866,868,870],{"class":584,"line":635},[582,867,638],{"class":588},[582,869,641],{"class":628},[582,871,644],{"class":592},[582,873,874,876,878,880],{"class":584,"line":647},[582,875,650],{"class":592},[582,877,653],{"class":588},[582,879,657],{"class":656},[582,881,660],{"class":592},[582,883,884,887,889,892],{"class":584,"line":663},[582,885,886],{"class":592},"        String contenido ",[582,888,653],{"class":588},[582,890,891],{"class":656}," \"Este es un ejemplo de escritura en un archivo.\"",[582,893,660],{"class":592},[582,895,896],{"class":584,"line":669},[582,897,616],{"emptyLinePlaceholder":615},[582,899,900,902,905,907,909,912,914,916,919],{"class":584,"line":698},[582,901,672],{"class":588},[582,903,904],{"class":592}," (BufferedWriter bw ",[582,906,653],{"class":588},[582,908,680],{"class":588},[582,910,911],{"class":628}," BufferedWriter",[582,913,686],{"class":592},[582,915,689],{"class":588},[582,917,918],{"class":628}," FileWriter",[582,920,695],{"class":592},[582,922,923,926,929],{"class":584,"line":704},[582,924,925],{"class":592},"            bw.",[582,927,928],{"class":628},"write",[582,930,931],{"class":592},"(contenido);\n",[582,933,934,936,938,940,942],{"class":584,"line":734},[582,935,755],{"class":592},[582,937,758],{"class":588},[582,939,761],{"class":592},[582,941,765],{"class":764},[582,943,731],{"class":592},[582,945,946,948,950],{"class":584,"line":746},[582,947,773],{"class":592},[582,949,776],{"class":628},[582,951,779],{"class":592},[582,953,954],{"class":584,"line":752},[582,955,785],{"class":592},[582,957,958],{"class":584,"line":770},[582,959,791],{"class":592},[582,961,962],{"class":584,"line":782},[582,963,797],{"class":592},[423,965,966,967,969,970,972],{},"En este ejemplo, se escribe una cadena de texto en un archivo utilizando un ",[445,968,534],{},", y el bloque ",[445,971,808],{}," asegura que el Stream se cierre correctamente después de su uso.",[974,975,976,977,980],"warning",{},"Es importante manejar las excepciones de E\u002FS adecuadamente, ya que pueden ocurrir errores como la falta de permisos para acceder a un archivo, el archivo no existe, o problemas de hardware. Siempre se recomienda utilizar bloques ",[445,978,979],{},"try-catch"," para capturar y manejar estas excepciones de manera efectiva.",[982,983,984,985,988,989,452],"tip",{},"El bloque try-with-resources es una característica introducida en Java 7 que facilita la gestión de recursos, como Streams, al garantizar que se cierren automáticamente después de su uso. Esto es especialmente útil para evitar fugas de recursos y asegurar que los Streams se liberen correctamente, incluso en caso de excepciones. Y algo relevante es que este bloque se puede utilizar con cualquier clase que implemente la interfaz ",[445,986,987],{},"AutoCloseable",", lo que incluye a la mayoría de los Streams en Java. Así mismo podemos usarlo con múltiples recursos, separándolos por punto y coma dentro de los paréntesis del bloque ",[445,990,804],{},[418,992,994],{"id":993},"try-with-resources-con-múltiples-streams","try-with-resources con múltiples Streams",[423,996,997,998,1000],{},"En algunos casos, es posible que necesitemos manejar múltiples Streams al mismo tiempo, como al leer de un archivo y escribir en otro. El bloque ",[445,999,808],{}," nos permite gestionar ambos Streams de manera eficiente, asegurando que ambos se cierren correctamente después de su uso. Aquí hay un ejemplo de cómo hacerlo:",[573,1002,1004],{"className":575,"code":1003,"language":577,"meta":578,"style":578},"import java.io.BufferedReader;\nimport java.io.BufferedWriter;\nimport java.io.FileReader;\nimport java.io.FileWriter;\nimport java.io.IOException;\n\npublic class CopiarArchivo {\n    void main() {\n        String rutaArchivoOrigen = \"ruta\u002Fal\u002Farchivo_origen.txt\";\n        String rutaArchivoDestino = \"ruta\u002Fal\u002Farchivo_destino.txt\";\n\n        try (BufferedReader br = new BufferedReader(new FileReader(rutaArchivoOrigen));\n             BufferedWriter bw = new BufferedWriter(new FileWriter(rutaArchivoDestino))) {\n            \n            String linea;\n            while ((linea = br.readLine()) != null) {\n                bw.write(linea);\n                bw.newLine(); \u002F\u002F Agrega una nueva línea después de cada línea escrita\n            }\n        } catch (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}\n",[445,1005,1006,1012,1018,1024,1030,1036,1040,1051,1059,1071,1083,1087,1108,1128,1133,1137,1157,1166,1180,1185,1198,1207,1212,1217],{"__ignoreMap":578},[582,1007,1008,1010],{"class":584,"line":585},[582,1009,589],{"class":588},[582,1011,593],{"class":592},[582,1013,1014,1016],{"class":584,"line":596},[582,1015,589],{"class":588},[582,1017,835],{"class":592},[582,1019,1020,1022],{"class":584,"line":604},[582,1021,589],{"class":588},[582,1023,601],{"class":592},[582,1025,1026,1028],{"class":584,"line":612},[582,1027,589],{"class":588},[582,1029,842],{"class":592},[582,1031,1032,1034],{"class":584,"line":619},[582,1033,589],{"class":588},[582,1035,609],{"class":592},[582,1037,1038],{"class":584,"line":635},[582,1039,616],{"emptyLinePlaceholder":615},[582,1041,1042,1044,1046,1049],{"class":584,"line":647},[582,1043,622],{"class":588},[582,1045,625],{"class":588},[582,1047,1048],{"class":628}," CopiarArchivo",[582,1050,632],{"class":592},[582,1052,1053,1055,1057],{"class":584,"line":663},[582,1054,638],{"class":588},[582,1056,641],{"class":628},[582,1058,644],{"class":592},[582,1060,1061,1064,1066,1069],{"class":584,"line":669},[582,1062,1063],{"class":592},"        String rutaArchivoOrigen ",[582,1065,653],{"class":588},[582,1067,1068],{"class":656}," \"ruta\u002Fal\u002Farchivo_origen.txt\"",[582,1070,660],{"class":592},[582,1072,1073,1076,1078,1081],{"class":584,"line":698},[582,1074,1075],{"class":592},"        String rutaArchivoDestino ",[582,1077,653],{"class":588},[582,1079,1080],{"class":656}," \"ruta\u002Fal\u002Farchivo_destino.txt\"",[582,1082,660],{"class":592},[582,1084,1085],{"class":584,"line":704},[582,1086,616],{"emptyLinePlaceholder":615},[582,1088,1089,1091,1093,1095,1097,1099,1101,1103,1105],{"class":584,"line":734},[582,1090,672],{"class":588},[582,1092,675],{"class":592},[582,1094,653],{"class":588},[582,1096,680],{"class":588},[582,1098,683],{"class":628},[582,1100,686],{"class":592},[582,1102,689],{"class":588},[582,1104,692],{"class":628},[582,1106,1107],{"class":592},"(rutaArchivoOrigen));\n",[582,1109,1110,1113,1115,1117,1119,1121,1123,1125],{"class":584,"line":746},[582,1111,1112],{"class":592},"             BufferedWriter bw ",[582,1114,653],{"class":588},[582,1116,680],{"class":588},[582,1118,911],{"class":628},[582,1120,686],{"class":592},[582,1122,689],{"class":588},[582,1124,918],{"class":628},[582,1126,1127],{"class":592},"(rutaArchivoDestino))) {\n",[582,1129,1130],{"class":584,"line":752},[582,1131,1132],{"class":592},"            \n",[582,1134,1135],{"class":584,"line":770},[582,1136,701],{"class":592},[582,1138,1139,1141,1143,1145,1147,1149,1151,1153,1155],{"class":584,"line":782},[582,1140,707],{"class":588},[582,1142,710],{"class":592},[582,1144,653],{"class":588},[582,1146,715],{"class":592},[582,1148,718],{"class":628},[582,1150,721],{"class":592},[582,1152,724],{"class":588},[582,1154,728],{"class":727},[582,1156,731],{"class":592},[582,1158,1159,1162,1164],{"class":584,"line":788},[582,1160,1161],{"class":592},"                bw.",[582,1163,928],{"class":628},[582,1165,743],{"class":592},[582,1167,1168,1170,1173,1176],{"class":584,"line":794},[582,1169,1161],{"class":592},[582,1171,1172],{"class":628},"newLine",[582,1174,1175],{"class":592},"(); ",[582,1177,1179],{"class":1178},"sAwPA","\u002F\u002F Agrega una nueva línea después de cada línea escrita\n",[582,1181,1183],{"class":584,"line":1182},19,[582,1184,749],{"class":592},[582,1186,1188,1190,1192,1194,1196],{"class":584,"line":1187},20,[582,1189,755],{"class":592},[582,1191,758],{"class":588},[582,1193,761],{"class":592},[582,1195,765],{"class":764},[582,1197,731],{"class":592},[582,1199,1201,1203,1205],{"class":584,"line":1200},21,[582,1202,773],{"class":592},[582,1204,776],{"class":628},[582,1206,779],{"class":592},[582,1208,1210],{"class":584,"line":1209},22,[582,1211,785],{"class":592},[582,1213,1215],{"class":584,"line":1214},23,[582,1216,791],{"class":592},[582,1218,1220],{"class":584,"line":1219},24,[582,1221,797],{"class":592},[423,1223,1224,1225,1227,1228,1230,1231,1233],{},"En este ejemplo, se utilizan dos Streams: un ",[445,1226,531],{}," para leer el contenido de un archivo de origen y un ",[445,1229,534],{}," para escribir ese contenido en un archivo de destino. Ambos Streams se gestionan dentro del mismo bloque ",[445,1232,808],{},", lo que garantiza que se cierren automáticamente al finalizar el bloque, incluso si ocurre una excepción durante la lectura o escritura.",[418,1235,1237],{"id":1236},"conclusión","Conclusión",[423,1239,1240,1241,1243],{},"Los Streams de Entrada y Salida en Java son herramientas esenciales para manejar la lectura y escritura de datos en archivos y otros medios. Comprender cómo funcionan los diferentes tipos de Streams y cómo gestionarlos adecuadamente, especialmente utilizando el bloque ",[445,1242,808],{},", es fundamental para escribir código eficiente y seguro que maneje correctamente los recursos de E\u002FS. Al utilizar los Streams de manera adecuada, podemos evitar problemas comunes como fugas de recursos y asegurarnos de que nuestros programas manejen los datos de manera eficiente y segura.",[1245,1246,1247],"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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}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 .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}",{"title":578,"searchDepth":596,"depth":596,"links":1249},[1250,1251,1255,1256,1257],{"id":420,"depth":596,"text":421},{"id":428,"depth":596,"text":429,"children":1252},[1253,1254],{"id":471,"depth":604,"text":472},{"id":514,"depth":604,"text":515},{"id":561,"depth":596,"text":562},{"id":993,"depth":596,"text":994},{"id":1236,"depth":596,"text":1237},"En este capítulo se explican los Streams de Entrada y Salida en Java, que son fundamentales para manejar la lectura y escritura de datos en archivos y otros medios.","md",null,{"editButton":42},{"title":297,"description":1258},"InHYWzxXJf8nw2s_lvvFT6Q_H64qO2eTLpP_hqstAI8",[1265,1267],{"title":293,"path":294,"stem":295,"description":1266,"children":-1},"En esta segunda parte, continuaremos desarrollando la interfaz de usuario para nuestro RPG, enfocándonos en la implementación de Paneles, Botones y otros elementos interactivos.",{"title":301,"path":302,"stem":303,"description":1268,"children":-1},"En este capítulo se explica cómo manejar archivos de tipo objeto en Java, utilizando las clases ObjectInputStream y ObjectOutputStream para leer y escribir objetos completos en archivos.",1779479575657]