io sistema de archivos basado en Java y siete

Información del equipo reglas de codificación
de acuerdo con los siguientes principios en ordenador escribe los datos leídos
números arábigos 9, por ejemplo, el proceso de escritura, la primera de su transformación de cronómetro ASC2 "contar", y luego traducirlos en números binarios almacenados en el archivo, el proceso de lectura, por el proceso inverso del proceso antes mencionado.

El más utilizado es de ocho bytes de bytes, es decir, que contiene ocho números binarios, es decir, los ocho símbolos se denomina byte de binarios
GBK caracteres alfabéticos de dos bytes 1 byte
UTF. 8- grande en todo el mundo parte de la lengua con niños, letras a byte, la mayor parte de los tres bytes chino

generalmente de acuerdo con esta semana y su mecanismo para almacenar datos de texto

Operación del documento

Crear una carpeta

File f = new File("f:/xx");
		boolean mkdir = f.mkdir(); // 不能创建多级目录
		System.out.println(mkdir);

Crear una carpeta

File fs = new File("f:/xx1/yy1");
boolean mkdirs = fs.mkdirs();
System.out.println(mkdirs);

Crear un archivo

	File file3 = new File("d:/xx/yy/cls.avi");
	boolean createNewFile = file3.createNewFile();
	System.out.println(createNewFile);

Determinar si el archivo archivo

File file = new File("f:/xx/yy/124.txt");
		boolean ifFile = file.isFile();
		System.out.println(ifFile);  // false

Determinar si la carpeta de archivos

boolean directory = f.isDirectory();
	System.out.println(directory);   

Obtener la ruta absoluta al archivo

String absolutePath = f.getAbsolutePath();
		System.out.println(absolutePath);
		System.out.println("----------------------------------------");

Obtiene el nombre del archivo

	String fName = file.getName();
System.out.println(fName);  // false

Obtiene objetos de archivo en un directorio

File parentFile = file.getParentFile();
System.out.println(parentFile.getAbsolutePath());

Obtiene la cadena de ruta del directorio padre

String parent = file.getParent();
System.out.println(parent);

Obtener byte de longitud del archivo (8 bits bit--)

long length = file.length();
	System.out.println(length);

Obtiene nodos secundarios del directorio especificado

File f2 = new File(c);
String[] listFilesString = f2.list();
for(String f1:listFilesString) {
	System.out.println(f1);
}

Descripción del archivo de los nodos de objetos secundarios para obtener el directorio especificado

File[] listFiles = f2.listFiles();
for(File f1:listFiles) {
	System.out.println(f1.getAbsolutePath());

Crear un archivo

	File file3 = new File("d:/xx/yy/cls.avi");
	boolean createNewFile = file3.createNewFile();
	System.out.println(createNewFile);

Cambie el nombre del archivo: De hecho, se puede dar el camino cambió

	file3.renameTo(new File("d:/xx/yy/bdls.avi"));

Eliminar archivos

boolean delete = file3.delete();
	System.out.println(delete);

El concepto y el papel corriente

Concepto de un flujo de
corriente es un conjunto de secuencial, comenzando y terminando con una colección de bytes, que es el término general para la transmisión de datos o abstracto. Esta transmisión de datos entre dos dispositivos se denomina flujo, la naturaleza de la transmisión de datos del flujo, las características de transmisión de datos de los diferentes tipos de flujos de manipulación de datos abstracta, conveniente más intuitivo.
Clasificación IO arroyos

El proceso se divide en diferentes tipos de datos: un flujo de caracteres y flujo de bytes

El flujo de datos divididos en: la entrada y salida de flujos de
flujo de caracteres y flujo de bytes

El personaje origen arroyos: codificado como diferentes datos y la transmisión de objetos con el funcionamiento eficiente del personaje. Cuando en realidad, esencialmente basado en el flujo de bytes de lectura, para comprobar la tabla de códigos especificada. La diferencia entre los flujos de bytes y flujos de caracteres:

Diferentes (1) unidad de escritura: unidades de bytes byte de flujo (8 bits) de la secuencia de caracteres en caracteres, los caracteres de acuerdo con la asignación de tabla de códigos, una pluralidad de bytes pueden ser leídos.

Diferente (2) a procesar: flujo de bytes puede manejar todos los tipos de datos (por ejemplo, imágenes, AVI, etc.), el flujo de caracteres puede manejar el tipo de datos de carácter.

(3) Cuando no se utiliza el flujo de bytes funcionamiento del propio tampón, el propio archivo es accionado directamente, y cuando se opera en el flujo de caracteres después de la memoria intermedia se utilizará, a través de tampón para las operaciones de archivo, se verificarán por debajo.

Conclusión: El flujo de bytes preferido. En primer lugar, porque todos los archivos en los discos duros son en forma de bytes transmitidos o almacenados, incluyendo fotos y otros contenidos. Sin embargo, los caracteres se forman sólo en la memoria, por lo que en el desarrollo, de bytes, ampliamente utilizado.
Los flujos de entrada y de salida

Basta con leer el flujo de entrada, el flujo de salida puede ser escrito, el programa tiene que utilizar diferentes corrientes en función de las características de los datos a transmitir.

Dentro de un sistema tan grande, común a tan pocos, ponemos ellos extraen, como se muestra a continuación

De lectura y escritura de archivos mediante FileInputStream

FileInputStream es un flujo de bytes, byte a byte de lectura

  //		先构造一个fileinputstream的对象
		FileInputStream fis =new FileInputStream( "f:/a.txt");

//	是一个字节流，一个字节一个字节读取
//		用int声明则表示读出的是编译表中的数字，当读的字节读出的int是-1时，则表示读到文件的末尾
		int read=fis.read();
		System.out.println(read);
//		若想得到是实际数据，则应该根据编码规则对其进行转码,用char声明，char代表一个英文字符
		char read1=(char)fis.read();
		System.out.println(read1);

Con FileInputStream y FileOutputStream matriz de bytes y leer y escribir archivos

Leer

byte[] buf=new byte[9];   //指的是byte数组即字节数组，可以装入6个字节

//	fis.read(buf)	一次读取部分长度的数据，并且读到的数据直接填入buf数组中，返回值是真实读到的字节数量

int num =fis.read(buf);   //返回值num是真实读到的字节数量，当读到文件末尾时候读到的是-1，可用该性质写while循环，不包括换行和空格
String string =new String(buf,0,num);  //将读出的数据转为字符串格式,String(buf,2,4)参数分别为要转为字符串的数组，初始位置，和结束位置
System.out.println(string);
System.out.println(num);
		
//-------------用byte数组和while反复读取------------------------------------------------
/*		byte[] buf=new byte[8];  
		int num=0;
		while( (num=fis.read(buf))!=-1){             //返回值num是真实读到的字节数量，当读到文件末尾时候读到的是-1，可用该性质写while循环，不包括换行和空格
    	String string =new String(buf,0,num);                          //打印的东西包括换行和空格
    	System.out.println(string);
    }
    

    fis.close();

Comentario

FileOutputStream fos=new FileOutputStream("f:/a.txt",true); //加个参数true，则覆盖变为追加
	String string="a你好";
	byte[] bytes=string.getBytes();       //将字符串按指定编码规则--》将信息转化为指定字符串，默认gbk编码
		fos.write(bytes);
		fos.close();

DataOutputStream archivos de lectura y escritura y DataInputStream

DataOutputStream es un flujo de paquetes, que se puede convertir en diversos tipos de bytes de datos dentro del byte, a continuación, utilizar
DataInputStream se puede convertir directamente desde el flujo de bytes de tipo de datos específico

Escribir archivo
de escritura de archivo FileOutputStream

DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:/o.txt"));
		
		// 写入一个整数  4个字节
		int age = 18;
		//dos.writeInt(age);
		
		// 写一个long   8个字节
		//dos.writeLong(19929);
		
		// 写一个float数据  4个字节
		//dos.writeFloat(18.8f);
		
		// 写一个double数据  8个字节
		//dos.writeDouble(18.8);
		
		// 写一个boolean值，true其实写入了一个1 ，false其实写入了一个0
		//dos.writeBoolean(true);
		
		// writeutf在写真正的数据的同时，会在前面加上2个字节的长度记录
		dos.writeUTF("张铁林");
		dos.writeInt(48);
		
		dos.close();
		

Archivo de lectura
DataInputStream se puede convertir directamente desde el flujo de bytes de específico de tipo de datos
dis DataInputStream = nuevo DataInputStream (nuevo FileInputStream

	//int age = dis.readInt();
	//long readLong = dis.readLong();
	//float readFloat = dis.readFloat();
	
	//double readDouble = dis.readDouble();
	
	//boolean readBoolean = dis.readBoolean();
	
	//String readUTF = dis.readUTF();
	
	String name = dis.readUTF();
	int age = dis.readInt();
	System.out.println(name);
	System.out.println(age);
	Integer.parseInt("1"); 

archivos de lectura y escritura con BufferedWriter y BufferedRead

Para mejorar la eficiencia del flujo de caracteres de lectura, se introduce el mecanismo de amortiguación, lote leer y escribir caracteres, aumenta la eficiencia de la lectura y escritura de un solo carácter. BufferedReader para leer caracteres utilizados para acelerar la velocidad, BufferedWriter utiliza para acelerar las velocidades de escritura

BufferedWriter

Ejemplo `

public class BufferedWriterDemo {
public static void main(String[] args) throws Exception {
	 BufferedWriter bfwWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("f:/c.txt",true)));   
	 //自动识别是不是UTF-8
	 //加true参数则是追加，不加则是覆盖
	 bfwWriter.write("66666牛\n呀D！w！！");            //写入字符串
		 bfwWriter.close();            //操作完毕后记住要将流关闭
	
}
}

BufferedRead
例

`public class BufferedReadDemo {
	public static void main(String[] args) throws Exception {
		

BufferedReader fls= new BufferedReader(new InputStreamReader(new FileInputStream("f:/a.txt"),"UTF-8")); //如果文本包含中文记得加多个参数UTF-8，否则按默认GBK编码格式
//UTF-8对中英文友好，gbk对中文不友好
//BufferedReader包装了字节流，可以将指定的编码集将字节转成字符

//读取第一行
//String line=fls.readLine(); //将文本信息按行填入文件  
//System.out.println(line);    

//读取第二行
//line=fls.readLine();
//System.out.println(line);

while (true) {											//用循环的方式按行读取文件
	String line=fls.readLine();
	if (line==null){break;}
	System.out.println(line);

		
}
fls.close();                         //将流关闭

}`

Hacer un contador de palabras

package ioProject;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class Wordcount {public static void main(String[] args) throws Exception, FileNotFoundException {
	BufferedReader fls= new BufferedReader(new InputStreamReader(new FileInputStream("f:/a.txt"),"UTF-8")); //如果文本包含中文记得加多个参数UTF-8，否则按默认GBK编码格式
	HashMap<String,Integer> Wordcount=new HashMap<>();

	while (true) {											//将文本信息按行填入文件，用循环的方式
		String line=fls.readLine();
		if (line==null){break;}
		String[] wordList=line.split(" ");          
		for (String i:wordList){
			if(Wordcount.containsKey(i)){
				Integer count =Wordcount.get(i);
				Wordcount.put(i,count+1);}
			else{Wordcount.put(i,1);}
		}
		
	}
		fls.close();         
	
		Set<Entry<String,Integer>> entrySet =	 Wordcount.entrySet();
		for (Entry x:entrySet){			
			System.out.println("key="+x.getKey()+"&&value="+x.getValue());
			}

		
		
}
}

serialización de Java y de-serialización

Java medios de serialización para convertir Java secuencia objeto de bytes, y deserialización secuencia de bytes de Java se refiere al proceso de recuperación de objetos Java.

import java.io.Serializable;
//implements Serializable 告诉jdk，这个类的对象是可被序列化的

public class User  implements Serializable {
	
	
	
	String name;
	int age;
	float salary;
	long hairNum;
	
	
	public User(String name, int age, float salary, long hairNum) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.hairNum = hairNum;
	}
	


	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public float getSalary() {
		return salary;
	}
	public void setSalary(float salary) {
		this.salary = salary;
	}
	public long getHairNum() {
		return hairNum;
	}
	public void setHairNum(long hairNum) {
		this.hairNum = hairNum;
	}

	@Override
	public String toString() {
		return "[name=" + name + ", age=" + age + ", salary=" + salary + ", hairNum=" + hairNum + "]";
	}
	


}

clases de interfaz de implementar la serialización

Si los instrumentos de la clase Serializable la interfaz, se puede serializar y deserializar clase de objeto
similar a las siguientes operaciones, los implementos SERIALIZABLE dicen JDK, objetos de esta clase es de serie

public class User implements Serializable {    
private String userName; 
private String password; 
}

ObjectInputStream ObjectOutputStream y escritura con los objetos, ArrayList, HashMap tipos de datos complejos, etc.

La lectura y la escritura de objetos

public class ObjectInputStreamDemo {
	public static void main(String[] args) throws FileNotFoundException, IOException {
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/u.obj"));
		
		User user1 = new User("慕容复", 38, 2800, 8000);
		User user2 = new User("扫地僧", 58, 3800, 0);
		// writeObject(user)方法，要求user对象是可序列化的 
		oos.writeObject(user1);
		oos.writeObject(user2);
		
		oos.close();
				ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/u.obj"));
    
    		User readObject1 = (User) ois.readObject();  //声明为User类
    		User readObject2 = (User) ois.readObject();
    
    		System.out.println(readObject1);
    		System.out.println(readObject2);
    
    		ois.close();
	}

}

Leer ArrayList

public class ArrayListObject {
public static void main(String[] args) throws Exception, IOException {
	
	//  将一个list对象直接写入文件
	User user1 = new User("慕容复", 38, 2800, 8000);
	User user2 = new User("扫地僧", 58, 3800, 0);
	
	ArrayList<User> users = new ArrayList<>();
	users.add(user1);
	users.add(user2);
	
	
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/users.list"));
	oos.writeObject(users);
	oos.close();
	
	
	// 从文件中读取一个list对象
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/users.list"));
	ArrayList<User> userList = (ArrayList<User>) ois.readObject();
	System.out.println(userList);
	
	ois.close();

}
}

Leer HashMap

	/**
	 * 直接从文件中读取一个map对象
	 */
	@Test
	public void testReadMap() throws Exception {
	//从文件中写入一个对象
HashMap<String, User> users = new HashMap<>();
		
		User user1 = new User("慕容复", 38, 2800, 8000);
		User user2 = new User("扫地僧", 58, 3800, 0);
		users.put(user1.getName(), user1);
		users.put(user2.getName(), user2);
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/users.map"));
		oos.writeObject(users);
		oos.close();

		// 从文件中读取一个list对象
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/users.map"));
		HashMap<String, User> userMap = (HashMap<String, User>) ois.readObject();
		System.out.println(userMap);
	}