io sistema de arquivo baseado em java sete

Informações sobre o computador codificação de regras
de acordo com os seguintes princípios em computador grava dados ler
algarismos arábicos 9, por exemplo, escrevendo processo, o primeiro de sua transformação de cronômetro ASC2 para "contar", e, em seguida, traduzi-los em números binários armazenados no arquivo, o processo de leitura, para o processo inverso do processo acima mencionado.

O mais vulgarmente utilizado é de oito bytes de byte, isto é, que contém oito números binários, isto é, os oito símbolos são chamados um byte de binários
GBK caracteres alfabéticos um dois byte um byte
UTF. 8- grande mundial parte dos favoráveis às línguas, letras um byte, a maioria dos três byte chinês

geralmente de acordo com esta semana e seu mecanismo para armazenar dados de texto

Operação do documento

Crie uma pasta

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

Crie uma pasta

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

Crie um arquivo

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

Determinar se o arquivo arquivo

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

Determinar se a pasta de arquivo

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

Obter o caminho absoluto para o arquivo

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

Obtém o nome do arquivo

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

Obtém objetos de arquivo em um diretório

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

Obtém o pai corda caminho do diretório

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

Obter comprimento arquivo byte (8 bits bit--)

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

String Obtém nós filhos do diretório especificado

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

Descrição do arquivo dos nós objeto filho para obter o diretório especificado

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

Crie um arquivo

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

Renomeie o arquivo: Na verdade, você pode dar o caminho mudou

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

Excluir arquivos

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

O conceito eo papel fluxo

Conceito de um fluxo de
corrente é um conjunto de sequencial, começando e terminando com uma colecção de bytes, que é o termo geral para a transmissão de dados ou abstrato. Que a transmissão de dados entre dois dispositivos é chamado de fluxo, a natureza da transmissão de dados fluxo, características de transmissão de dados dos vários tipos de fluxo abstrato, manipulação de dados conveniente mais intuitiva.
Classificação IO córregos

O processo é dividido em diferentes tipos de dados: um fluxo de caracteres e fluxo de bytes

O fluxo de dados divididos em: a entrada e saída córregos
fluxo de caracteres e fluxo de bytes

O personagem origem córregos: codificados como dados diferentes, e streaming de objetos com o bom funcionamento do personagem. Quando na verdade, essencialmente baseada no fluxo de bytes de leitura, para verificar a tabela de código especificada. A diferença entre fluxos de bytes e fluxos de caracteres:

Diferentes (1) unidade de escrita: unidades byte fluxo de bytes (8 bits) do fluxo de caracteres de caracteres, os caracteres de acordo com a tabela de mapeamento de código, uma pluralidade de bytes pode ser lido.

Diferente (2) a ser processada: fluxo de bytes pode lidar com todos os tipos de dados (tais como imagens, avi, etc.), o fluxo de caracteres pode lidar com o tipo de dados de caracteres.

(3) Quando a corrente de operação de bytes do próprio tampão não é utilizado, o próprio arquivo é directamente accionada; e quando se opera no fluxo de caracteres após o tampão será utilizado, através de tampão de operações de arquivo, vamos verificar abaixo disso.

Conclusão: O fluxo de bytes preferida. Primeiro, porque todos os arquivos nos discos rígidos são na forma de bytes transmitidos ou armazenados, incluindo fotos e outros conteúdos. Mas os personagens serão formados apenas na memória, assim, no desenvolvimento, fluxo de bytes, amplamente utilizado.
Os fluxos de entrada e de saída

Para ler somente o fluxo de entrada, o fluxo de saída pode ser escrito, o programa precisa usar diferentes correntes dependendo das características dos dados a serem transmitidos.

Dentro de um sistema tão grande, comum a tão poucos, nós colocá-los extraído, como mostrado abaixo

Ler e escrever arquivos usando FileInputStream

FilelnputStream é um fluxo de bytes, byte a byte de leitura

  //		先构造一个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);

Com FileInputStream e FileOutputStream matriz de bytes e ler e arquivos de gravação

Leia

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();

write

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

arquivos DataOutputStream e leitura DataInputStream e escrever

DataOutputStream é um fluxo de pacotes, que pode ser convertido em vários tipos de bytes de dados dentro do byte, em seguida, usar
DataInputStream pode ser convertido directamente a partir do fluxo de bytes de tipo de dados específicos

ficheiro de gravação
de arquivo de gravação 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();
		

leitura do ficheiro
DataInputStream pode ser convertido directamente a partir do fluxo de bytes de dados de tipo específico
de dis DataInputStream = DataInputStream novo (novo FilelnputStream

	//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"); 

arquivos de leitura e gravação com BufferedWriter e BufferedRead

Para melhorar a eficiência do fluxo de leitura de caracteres, o mecanismo de buffer é introduzida, lote ler e caráter de gravação, aumenta a eficiência da leitura e escrita de um único personagem. BufferedReader para ler caracteres utilizados para acelerar a velocidade, BufferedWriter usado para acelerar velocidades de gravação

BufferedWriter

exemplo `

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();                         //将流关闭

}`

Faça um contador de palavras

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());
			}

		
		
}
}

serialização Java e de-serialização

Java meios para a conversão de serialização Java sequcia objecto de bytes; e deserialização sequência de bytes de Java refere-se ao processo de recuperação de objectos de 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 + "]";
	}
	


}

classes de interface implementar serialização

Se os implementos classe serializável a interface, pode ser serializado e desserializado classe de objeto
semelhante para as seguintes operações, os implementos Serializável dizer JDK, objetos dessa classe é serializado

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

ObjectInputStream ObjectOutputStream e escrever com objetos, ArrayList, tipos de dados complexos HashMap, etc.

Ler e escrever 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();
	}

}

Leia 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();

}
}

Leia 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);
	}