Recopilación de preguntas de práctica de IO (IO realiza el cifrado de imágenes, copia archivos de acuerdo con la ruta del archivo, ingresa datos, invierte el texto, obtiene el número de bytes en el texto y crea la versión de prueba del software)

1. Cifrado de imágenes

La idea es que podamos encriptar la imagen siempre que XOR el número anterior al ingresar bytes

public static void main(String[] args) throws IOException {
    
    
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("6.jpg"));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("copy.jpg"));
		int b;
		while ((b=bis.read())!=-1) {
    
    
			bos.write(b^123);
		}
		bos.close();
		bis.close();
	}

El efecto es el siguiente:
si necesitamos descifrar, solo necesitamos cambiar el nombre del archivo de entrada y salida y estará bien. cual es

BufferedInputStream bis=new 
BufferedInputStream(new FileInputStream("copy.jpg"));
BufferedOutputStream bos=new 
BufferedOutputStream(new FileOutputStream("copy2.jpg"));

2. Copie archivos de acuerdo con el archivo Road King

Requisito: Ingrese la ruta del archivo en la consola y copie el archivo al proyecto actual.
Análisis:

1. Crear objetos de entrada de teclado

2. El método de definición juzga la ruta ingresada por el teclado y devuelve si es un archivo.

3. Acepta el archivo en el método principal.

4. Leer y escribir el archivo

Pasos: Defina un método para obtener la ruta del archivo ingresada por el teclado y encapsúlela en un objeto Archivo para regresar

1. Tipo de valor de retorno Archivo
2. Lista de parámetros ninguno

public class Test2 {
    
    

public static void main(String[] args) throws IOException {
    
    
			File file =getFile();
BufferedInputStream bufferedInputStream =
new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(newFileOutputStream(file.getName()));
			
	    int b;
while ((b=bufferedInputStream.read())!=-1) {
    
    
				 bufferedOutputStream.write(b);
			}
			bufferedInputStream.close();
			bufferedInputStream.close();
	}
	//定义一个方法获取文件路径，并封装成File对象返回
	//返回类型File
	//参数列表无
	public static File getFile() {
    
    
		Scanner scanner =new Scanner(System.in);
		System.out.println("请输入一个文件的路径");
		while(true) {
    
    
		String line =scanner.nextLine();
		File file =new File(line);
		if (!file.exists()) {
    
    
			System.out.print("您录入的文件路径不存在，请重新录入：");
		}else if(file.isDirectory()){
    
    
			System.out.println("您录入的是文件夹路径，请重新录入：");
		}else {
    
    
			return file;
		}
	}
		}
}

En este momento, ingresamos la ubicación de un archivo en la consola.
Por ejemplo:
en este momento, habrá una imagen adicional en nuestro proyecto.

3. Copie los datos de entrada al archivo

Requisitos: Copie los datos ingresados ​​por el teclado al archivo text.txt en el proyecto actual y salga cuando los datos ingresados ​​por el teclado se salgan.
análisis:

1. Crear objetos de entrada de teclado
2. Crear objeto de flujo de salida y asociar el archivo text.txt
3. Definir un bucle infinito
4. Encontrado dejar de fumar para salir del ciclo
5. Si no se deja seguir escribiendo

public class Test3 {
    
    

	public static void main(String[] args) throws IOException{
    
    
		// TODO Auto-generated method stub
		Scanner scanner =new Scanner(System.in);
		FileOutputStream fileOutputStream =new FileOutputStream("text.txt");
		System.out.print("请输入内容");
		while (true) {
    
    
			String line=scanner.nextLine();
			if (line.equals("quite")) {
    
    
				break;
			}
			else {
    
    
				fileOutputStream.write(line.getBytes());			//字符串写出必须转换成字节数组
				fileOutputStream.write("\r\n".getBytes());
			}
		}
		fileOutputStream.close();
		
	}

}

Cuarto, invierta el texto

Requisitos: Invierta el texto de un documento de texto, intercambie la primera línea con la penúltima línea y la segunda línea con la penúltima línea.
Análisis:
Paso 1: Crear objetos de flujo de entrada y salida.
Paso 2: Crear objetos de colección, almacenar datos temporalmente y escribir hacia atrás a través del recorrido.
Paso 3: Almacenar los datos leídos en la colección.
Paso 4: Invertir Recorra la colección y escriba los datos en el archivo
Paso 5: Cierre la secuencia

public class Test4 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		// TODO Auto-generated method stub
		//1.创建输入输出流对象
BufferedReader bufferedReader =new BufferedReader(new FileReader("zzz.txt"));
BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("rezzz.txt"));
		//2.创建集合对象
		List <String> list =new ArrayList<String>();
		String line;
		while ((line=bufferedReader.readLine())!=null) {
    
    
			list.add(line);
		}
		for (int i = list.size()-1; i >=0; i--) {
    
    
			bufferedWriter.write(list.get(i));
			bufferedWriter.newLine();
		}
		bufferedReader.close();
		bufferedWriter.close();
	}

}

5. Obtenga el número de ocurrencias de caracteres (cada carácter, cada palabra) en el texto.

Requisitos: Obtenga el número de apariciones de cada carácter en un texto y escriba el resultado en times.txt
Análisis:

1. Crear un objeto de flujo de entrada almacenado en búfer
2. Cree un objeto de colección de dos columnas TreeMap
3. Almacene los caracteres leídos en un conjunto de dos columnas y haga un juicio al almacenar. Si la clave no está incluida, entonces se almacenarán la clave y 1. Si la clave está incluida, la clave y el valor se almacenarán agregando 1
4. Cierre el flujo de entrada y cree un objeto de flujo de salida.
5. Recorre el contenido de la colección y escribe el contenido de la colección en times.txt,
6. Cerrar flujo de salida

public class Test2 {
    
    

	public static void main(String[] args) throws IOException {
    
    
		// TODO Auto-generated method stub
		//1.创建带缓冲的输入流对象
		BufferedReader bufferedReader =new BufferedReader(new FileReader("zzz.txt"));
		//2.创建双列集合对象TreeMap
		TreeMap<Character,Integer> treeMap =new TreeMap<Character,Integer> ();
		int ch;
		while ((ch=bufferedReader.read())!=-1) {
    
    
			char c=(char)ch;		//强制转换
			treeMap.put(c, !treeMap.containsKey(c)?1:treeMap.get(c)+1);
		}
		//4.关闭输入流
		bufferedReader.close();
		//5.创建输出流对象
		BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("times.txt"));
		//6.遍历集合将集合中的内容写到times.txt中
		for (Character key : treeMap.keySet()) {
    
    
			switch (key) {
    
    
			case '\t':
				bufferedWriter.write("\\t"+"==="+treeMap.get(key));
				break;
			case '\n':
				bufferedWriter.write("\\n"+"==="+treeMap.get(key));
			default:
				break;
			}
			bufferedWriter.write(key+"==="+treeMap.get(key));
			bufferedWriter.newLine();
		}
		//7.关闭输出流
		bufferedWriter.close();
	}

}

El efecto es el siguiente:

Seis, haz una versión de prueba del software.

Requisitos: * Cuando descarguemos una versión de prueba del software, cuando no hayamos comprado la versión original, nos recordaremos cuántas veces tenemos la oportunidad de usar el conocimiento del flujo IO aprendido cada vez que lo ejecutamos, simulamos la versión de prueba del software, probamos 10 oportunidades y ejecutamos una vez. Solo un recordatorio una vez que tenga varias oportunidades, si el número de veces ha aumentado, compre el original.
Análisis:
1. Cree un objeto de flujo de entrada almacenado en búfer porque se utiliza el método readLine. Puede garantizar la originalidad de los datos
2. Convierta la cadena de lectura en un número int
3. Juzgue el número int. Si es mayor que 0, escríbalo de nuevo. Si no es mayor que 0, se le pedirá que compre una copia genuina
. En el juicio if, imprima el resultado de - y escriba el resultado en el archivo a través del flujo de salida

public class Test3 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//1.创建带缓冲的输入流对象，因为要使用readLine方法。可以保证数据的原样性
		BufferedReader  bufferedReader =new BufferedReader(new FileReader("config.txt"));
		//2.将读到的字符串转换为int数
		String line =bufferedReader.readLine();
		int times = Integer.parseInt(line);
		if (times > 0) {
    
    
			System.out.println("您还有"+times--+"次机会");
			FileWriter fileWriter =new FileWriter("config.txt");
			fileWriter.write(times+"");
			fileWriter.close();
		}else {
    
    
			System.out.println("您的试用次数已到，请购买正版。");
		}
		bufferedReader.close();
	}
}

Si escribimos 10 veces en config.txt, cada vez que lo ejecutamos, el número de veces disminuirá.

Siete, flujo de salida de memoria

Requisito: Defina un flujo de entrada de archivo, llame al método read (byte [] b) e imprima el contenido en el archivo a.txt (el tamaño de la matriz de bytes está limitado a 5)
Análisis:
1. read (byte [] b) es un byte El método de flujo de entrada, crear FileInputStream, asociar a.txt
2. Crear una matriz de bytes con una longitud de 5
3. Convertir todos los datos en el flujo de salida de la memoria en una cadena para imprimir
4. Cerrar el flujo de entrada

     	FileInputStream fis =new FileInputStream("a.txt");
		
		ByteArrayOutputStream byteArrayOutputStream =new ByteArrayOutputStream();
		int len;
		//3.创建字节数组，长度为5
		byte[] arr=new byte[5];
		while ((len=fis.read(arr))!=-1) {
    
    
			byteArrayOutputStream.write(arr,0,len);
			//如果没有字符内存数组，
			//System.out.println(new String(arr,0,len));
		}
		//将内存输出流的数据全部转换为字符串打印
		System.out.println(byteArrayOutputStream);	//即使没有调用，底层也会默认帮我们调用toString()方法
		fis.close();