1. Escribe un programa que
escriba los 100 primeros números naturales en un archivo numNaturales.txt.
import java.io.*;
public class Main {
public
static void main(String[] args) {
//
Propiedades
FileWriter
fich = null;
int i;
//
Programa
try{
fich
= new FileWriter("numNaturales.txt");
for(i=0;i<101;i++){
fich.write(i
+ " ");
}
System.out.println("Fichero
escrito correctamente");
}
catch(Exception
e){
e.printStackTrace();
}
finally{
try{
fich.close();
}
catch(Exception
e){
e.printStackTrace();
}
}
}
}
2. Escribe un programa que reciba
el nombre de un archivo que almacena una serie de cantidades enteras positivas
e imprima su suma.
import java.io.*;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = null;
File fichero;
int total = 0;
try {
System.out.println("Escribe el fichero a leer");
sc = new Scanner(System.in); // Escaner de entrada
fichero = new File(sc.nextLine()); // Fichero = entrada del usuario
sc.close();
total = 0;
sc = new Scanner(fichero); // Escaner que leerá el fichero
// Mientras haya una nueva linea en el fichero, el scanner devolverá resultados
while (sc.hasNext()) {
total += sc.nextInt(); // Convierto linea leída a un entero
}
System.out.println("Total:" + total);
}
catch(Exception e) {
e.printStackTrace();
}
finally {
sc.close();
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = null;
File fichero;
int total = 0;
try {
System.out.println("Escribe el fichero a leer");
sc = new Scanner(System.in); // Escaner de entrada
fichero = new File(sc.nextLine()); // Fichero = entrada del usuario
sc.close();
total = 0;
sc = new Scanner(fichero); // Escaner que leerá el fichero
// Mientras haya una nueva linea en el fichero, el scanner devolverá resultados
while (sc.hasNext()) {
total += sc.nextInt(); // Convierto linea leída a un entero
}
System.out.println("Total:" + total);
}
catch(Exception e) {
e.printStackTrace();
}
finally {
sc.close();
}
}
}
3. Escribir un método que reciba
un array de cadenas de caracteres y vuelque su contenido a un archivo cuyo
nombre también se recibirá por parámetro. Las cadenas quedarán separadas en el
archivo por un asterisco.
import java.io.*;
import java.util.Scanner;
public class Main {
//
Propiedades
// Método
public
static void escribeArray(String[] palabras, String nombre){
//
Propiedades
FileWriter
fich = null;
//
Código
try{
fich
= new FileWriter(nombre);
for(int
i = 0; i < palabras.length; i++){
fich.write(palabras[i]);
// Condicion que evita
insertar un * al final del todo
if (i + 1 !=
palabras.length)
fich.write("*");
}
// Muestra por pantalla proceso
finalizado
System.out.println("Palabras
insertadas correctamente");
}
catch(IOException
e){
e.printStackTrace();
}
finally{
try{
fich.close();
}
catch(IOException
e){
e.printStackTrace();
}
}
}
public
static void main(String[] args) {
// Código de prueba ya que el ejercicio solo
pide el método
String[] palabras = new String[]{"Uno",
"Dos", "Tres"};
escribeArray(palabras,
"pruebaArrays.txt");
}
}
4. Escribir un método que reciba
por parámetro el nombre de un archivo e imprima las cadenas que dicho archivo
almacena (una cadena por línea). Se tendrá en cuenta que las distintas cadenas
se separan en el archivo por un asterisco (que no se imprimirá).
import java.io.*;
public class Main {
public
static void leerCadenas(String nombre){
// Propiedades
FileReader fich = null;
int letra;
// Código
try{
fich = new FileReader(nombre);
letra = fich.read();
while(letra != -1) { // Al no
haber más caracteres que leer, retorna un -1 para saber cuando acabar
if(letra == '*')
letra = '\n';
System.out.print((char)letra);
// Realizo la conversión de entero a caracter
letra = fich.read();
}
}
catch(IOException
e){
e.printStackTrace();
}
finally{
try{
fich.close();
}
catch(IOException
e){
e.printStackTrace();
}
}
}
public
static void main(String[] args) {
// Código de prueba ya que sólo pide el
método
leerCadenas("pruebaArrays.txt");
}
}
5. Escribir un método que reciba
por parámetro el número correspondiente a un mes del año y la letra
correspondiente al día de la semana en que cae el día 1 de ese mes (‘L’ para
Lunes, ‘M’ para Martes, ‘X’ para Miércoles…). El método escribirá en un archivo
un calendario para ese mes que estará formado por todos los días del mes
seguidos de la letra correspondiente al día de la semana en que caen. El método
comprobará que los parámetros recibidos son correctos y obtendrá el nombre
concatenando a la palabra “mes” el número de mes recibido más la extensión
“.txt”.
Ejemplo: Si el método recibe el
valor 3 (Marzo) y la letra ‘M’ indicando que el 1 de Marzo es Martes, obtendrá
el nombre de archivo “mes3.txt” y lo escribirá con un calendario que tendrá un
aspecto como éste: 1M2X3J5V6S7D8L…31J
Prueba del ejercicio 5 anterior: Realizar un
método que reciba por parámetro el número correspondiente a un mes del año e
imprima por pantalla sus valores.
import java.io.*;
public class Main {
static String nombre;
static String mesCompleto = "";
// Si no incializo o pongo null no puedo concatenar
static FileWriter fill = null;
static
String concatenaDias(int mes, String dia){
int i;
int j =
0;
String[]
semana = {"L", "M", "X", "J",
"V", "S", "D"}; // Array para control de día
String
resultado = "";
// Saber posicion del array del comienzo
switch(dia){
case
"L": j = 0;
break;
case
"M": j = 1;
break;
case
"X": j = 2;
break;
case
"J": j = 3;
break;
case
"V": j = 4;
break;
case
"S": j = 5;
break;
case
"D": j = 6;
break;
}
switch(mes){
case
1:
case
3:
case
5:
case
7:
case
8:
case
10:
case
12:
for(i
= 1; i < 32; i++){
resultado
= resultado + String.valueOf(i) + semana[j];
if(j
== 6)
j
= 0;
else
j++;
}
break;
case
4:
case
6:
case
9:
case
11:
for(i
= 1; i < 31; i++){
resultado = resultado + String.valueOf(i) +
semana[j];
if(j == 6)
j
= 0;
else
j++;
}
break;
case
2:
for(i
= 1; i < 29; i++){
resultado = resultado + String.valueOf(i) +
semana[j];
if(j == 6)
j
= 0;
else
j++;
}
break;
}
System.out.println(resultado);
return
resultado;
}
static void
crearMes(int mes, String dia){
nombre = "mes" + mes +
".txt"; // Concateno para crear el nombre del fichero
try{
fill = new FileWriter(nombre);
// Creo nuevo fichero
fill.write(concatenaDias(mes,
dia)); // Hago la llamada a la funcion que crea el String
}
catch(FileNotFoundException
e){
e.printStackTrace();
}
catch(IOException
e){
e.printStackTrace();
}
finally{
try{
fill.close();
}
catch(IOException
e){
e.printStackTrace();
}
}
}
public
static void main(String[] args) {
int
mes;
String
dia;
BufferedReader
teclado = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Escribe
número de mes");
mes =
Integer.parseInt(teclado.readLine());
System.out.println("Escribe
día del mes");
dia =
teclado.readLine().toUpperCase(); // Me aseguro de pasar el String en
mayúsculas
teclado.close();
crearMes(mes, dia);
}
catch(IOException
e){
e.printStackTrace();
}
}
}
6. Escribir un método que reciba
por parámetro un array de cadenas de caracteres y el nombre de un archivo. El
método volcará el contenido del array de cadenas en el archivo especificado.
Utilizar filtros.
Prueba del ejercicio 6 anterior:
Realizar un método que reciba por parámetro el nombre de un archivo de texto y
muestre su contenido por pantalla.
import java.io.*;
public class Main {
static void vuelcaCadena(String[] cadena, String nombre){
int i;
FileWriter fill = null;
BufferedWriter bW = null;
try{
fill = new FileWriter(nombre);
bW = new BufferedWriter(fill);
for (i = 0; i < cadena.length; i++){
bW.write(cadena[i]);
bW.newLine();
}
}
catch(FileNotFoundException e){
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
bW.close();
fill.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}
static void cargaCodigo(String nombre){
FileReader fill = null;
BufferedReader bF = null;
String linea;
try{
fill = new FileReader(nombre);
bF = new BufferedReader(fill); // Creo buffer
dependiente del fichero
linea = bF.readLine(); // Cada linea cargará el
buffer actual
while (linea != null){ // Cuando no pueda cargar
texto del buffer habrá acabado el fichero
System.out.println(linea);
linea = bF.readLine();
}
}
catch(FileNotFoundException e){
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
bF.close();
fill.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
String[] cadena = {"hola", "¿que tal?",
"y vos?"};
vuelcaCadena(cadena, "hola.txt");
cargaCodigo("hola.txt");
}
}
7. Escribir un método que reciba
por parámetro un nombre de archivo para dejar sus líneas ordenadas
alfabéticamente (no distinguir minúsculas de mayúsculas a la hora de ordenar).
import java.io.*;
import
java.text.Collator;
import
java.util.Vector;
public class Main {
static void cargarCodigo(String nombre){
// Propiedades
FileReader fill = null;
BufferedReader bF = null;
FileWriter fW = null;
BufferedWriter bW = null;
String linea;
Vector<String> cadena = new
Vector<String>(); // Uso vector en vez de array por las posiciones
variables
Collator compara =
Collator.getInstance(); // Permite un orden alfabético real
compara.setStrength(Collator.PRIMARY);
// Indicamos que trate igual a mayúsculas y minusculas lleven o no acento
// Código
try{
fill = new FileReader(nombre);
bF = new BufferedReader(fill);
linea = bF.readLine();
// Inserto lineas de fichero en
el vector
while (linea != null){
cadena.add(linea);
linea = bF.readLine();
}
for(int i = 0; i <
cadena.size(); i++){
for (int j = 0; j <
cadena.size(); j++){
/*
* Método compare devuelve:
* <0
si primero < segundo
* 0 si
iguales
* >0
si primero > segundo
*/
if
(compara.compare(cadena.get(i), cadena.get(j)) < 0){
linea =
cadena.get(j);
cadena.set(j,
cadena.get(i));
cadena.set(i,
linea);
}
} // Fin segundo for
} // Fin primer for
// Escribo el vector en el
fichero
fW = new FileWriter(nombre);
bW = new BufferedWriter(fW);
for (int i = 0; i <
cadena.size(); i++){
bW.write(cadena.get(i));
bW.newLine();
}
System.out.println("Ordenación
completada");
}
catch(FileNotFoundException e){
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}
finally{
try{
bF.close();
fill.close();
bW.close();
fW.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}
public static void main(String[] args){
cargarCodigo("ordena.txt");
}
}
8. Escribir un método que
solicite al usuario un valor entero. El método no dejará de solicitarlo hasta
que el usuario introduzca un valor entero correcto, en ese caso el método
devolverá dicho valor.
import java.util.Scanner;
public class Main {
static boolean enteroValido(String cadena){
// Propiedades
boolean r = true;
// Analizo caracter a caracter la cadena. Si no son de 0 a
9 no será cifra entera válida
for(int i = 0; i < cadena.length(); i++){
if (cadena.charAt(i) < '0' || cadena.charAt(i)
> '9'){
r = false;
}
}
return r;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String linea = null;
System.out.println("Introduzca un número
entero:");
do{
linea = sc.nextLine();
if(enteroValido(linea) == false)
System.out.println("Eso no es un entero ni
de coña. Prueba otra vez");
}while( enteroValido(linea) == false);
sc.close();
}
}
9. Escribir un método que solicite al usuario
una respuesta a una pregunta cuyo contenido se recibirá por parámetro. El
método continuará formulando la pregunta hasta que la respuesta consista en uno
de los siguientes caracteres: ‘s’, ‘S’, ‘n’, ‘N’. En caso de responder
afirmativamente (‘s’ o ‘S’) el método
devolverá el valor true, y false en caso contrario.
import
java.util.Scanner;
public class Main {
static boolean responde(String pregunta){
boolean r = false;
boolean salida = false; // Lo uso para
salir del do while
Scanner sc = new Scanner(System.in);
String linea = null;
System.out.println(pregunta);
do{
linea = sc.nextLine();
if (linea.equals("s")
|| linea.equals("S")){
r = true;
salida = true;
}
else if
(linea.equals("n") || linea.equals("N")){
r = false;
salida = true;
}
else
System.out.println("Respuesta
no válida.");
}while(salida == false );
sc.close();
return r;
}
public static void main(String[] args) {
if (responde("¿No es verdad angel
de amor que en esta apartada orilla si viene tu novio y nos pilla la ostia que
me llevo es mayor?"))
System.out.println("Cierto,
cierto");
else
System.out.println("Pues va
a ser que no");
}
}
Gracias
ResponderEliminarEjercicio 1: Ficheros de texto.
ResponderEliminarEl ejercicio consiste en leer un fichero de texto que contiene un texto, por ejemplo:
el perro se encontraba en el jardín
y vio a otro perro
y salió corriendo a jugar con él
Implementa estos dos métodos:
Public static void cuantasVecesApareceEnCadaLinea(File f, String
palabrabuscada)
El método busca en el fichero f la palabra especificada, mostrando el número de veces que
aparece dicha palabra en cada línea del fichero.
Para el ejemplo anterior se mostraría:
cuantasVecesApareceEnCadaLinea (f,“perro”) ->
línea 1 -> Perro aparece 1 veces
línea 2 -> Perro aparece 1 veces
línea 3 -> Perro aparece 0 veces
Public static boolean guardarLineasQueTenganMasLetrasQue(File f1, File
f2, int numletras)
El método guarda en el fichero f2 las líneas del fichero f1 que tienen un número de letras
superior al numletras indicado en el argumento de entrada. Por ejemplo:
Boolean guardadoOK = guardarLineasQueTenganMasLetrasQue(f1,f2, 22)-> guardaría en el
fichero f2 las siguientes líneas que tienen más de 22 letras:
el perro se encontraba en el jardín
y salió corriendo a jugar con él
Ten en cuenta que espacios cuentan como letras.
Ayuda:
String [] digitos =texto.split(" ");
Separa las palabras del texto en el array de String palabras.
Ejercicio 1: Ficheros de texto.
ResponderEliminarEl ejercicio consiste en leer un fichero de texto que contiene un texto, por ejemplo:
el perro se encontraba en el jardín
y vio a otro perro
y salió corriendo a jugar con él.
Implementa estos dos métodos:
public static void mostrarLineasConMasPalabrasQue(File f1, int
numPalabras)
El método muestra por pantalla las líneas que contienen igual o más palabras que las indicadas
en el parámetro de entrada numpalabras.
Por ejemplo, mostrarLineasConMasPalabrasQue(f1, 6) mostraría las siguientes líneas que
contienen más de 6 palabras:
el perro se encontraba en el jardín
y salió corriendo a jugar con él.
Public static boolean guardarLineasQueContenganLaPalabra(File f1, File
f2, String palabraBuscada)
El método guarda en el fichero f2 las líneas del fichero f1 que contienen la palabra pasada
como primer argumento. Por ejemplo:
Boolean guardadoOK = guardarLineasQueContenganLaPalabra(f1,f2, “perro”) guardaría en el
fichero f2 las siguientes líneas que tienen la palabra perro:
el perro se encontraba en el jardín
y vio a otro perro
Examen Tema 1 ficheros de Acceso a Datos (2DAM B)
Ayuda:
String [] digitos =texto.split(" ");
Separa las palabras del texto en el array de String palabras.
boolean locontiene = texto.contains(“palabra”);
Devuelve true si el string texto contiene la palabra y false si no lo contiene