java基础知识点07_文件与IO流

àì夳堔傛蜴生んèń 2022-12-20 01:58 223阅读 0赞

**java基础知识点07\_文件与IO流**

**File类的四个静态成员变量：**

public static void main(String[] args) { 
    	//路径分隔符，windows系统为; linux系统为:
    	String pathseparator = File.pathSeparator;
    	char pathseparatorchar = File.pathSeparatorChar;
    	//文件分隔符, windows系统为\ linux系统为/
    	String separator = File.separator;
    	char separatorchar = File.separatorChar;
    	
    	System.out.println(pathseparator);
    	System.out.println(pathseparatorchar);
    	System.out.println(separator);
    	System.out.println(separatorchar);
    	
    }

**运行结果：**

;
    ;
    \
    \

pathSeparator		路径分隔符 ; 	String类型
    pathSeparatorChar	路径分隔符 ; 	char类型
    separator			文件分隔符 \		String类型
    separatorChar		文件分隔符 \		char类型

**获取功能的方法：**

public String getAbsolutePath()		获取绝对路径
    public String getPath()				获取构造路径（构造方法中传递的路径）
    public String getName()				获取文件名称
    public String length()				获取文件大小（单位：字节）

**判断功能的方法：**

public boolean exists()				判断文件或目录是否存在
    public boolean isDirectory()		判断是否是目录（不要求一定要存在）
    public boolean isFile()				判断是否是文件（不要求一定要存在）

**创建和删除功能的方法：**

public boolean createNewFile()		创建新文件（若文件已存在，则不会创建并返回false）
    public boolean delete()				删除文件或目录
    public boolean mkdir()				创建单级文件夹                                     
    public boolean mkdirs()				创建多级文件夹

**遍历目录（文件夹）的方法：**

public String[] list()			返回String数组，存储该文件夹中所有的子文件和子目录的名称
    public File[] listFiles()		返回File数组，存储该文件夹中所有的子文件和子目录的File对象

--------------------

**IO流**

<table> 
 <thead> 
  <tr> 
   <th>流</th> 
   <th>输入流</th> 
   <th>输出流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>字节流</strong></td> 
   <td>InputStream</td> 
   <td>OutputStream</td> 
  </tr> 
  <tr> 
   <td><strong>字符流（1个字符=2个字节）</strong></td> 
   <td>Reader</td> 
   <td>Writer</td> 
  </tr> 
 </tbody> 
</table>

**抽象类 字节输出流 OutputStream 的方法：**

close()
    flush()
    write(byte[] b)
    write(byte[] b,int off,int len)
    write(int b)

**最常用子类 FileOutputStream**

构造方法1（直接传递文件路径字符串）：
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt");
    
    构造方法2（传递文件对象）：
    File myfile = new File("D:\\temp\\a.txt");
    FileOutputStream fos = new FileOutputStream(myfile);
    
    写数据时，会将10进制的整数97转换成2进制1100001存入文件，用文本编辑器打开时，其会根据编码表将字节转换为字符a
    fos.write(97);
    释放资源，清空内存
    fos.close();
    
    数据追加写（在构造方法中添加一个true的boolean参数，就实现了数据追加写，参数为false则会覆盖源文件）
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
    fos.write("你好，BLU".getBytes());
    fos.close();
    
    数据换行写
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
    fos.write("\r\n".getBytes());
    fos.write("你好，BLU".getBytes());
    fos.close();

**抽象类 字节输入流 InputStream 的方法：**

int read()
    int read(byte[] b)
    void close()

**最常用子类 FileInputStream**

//文件内容：abc 读取结果：97 98 99 -1
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    //read方法每一次读取都只会读取1个字节，下一次会读取下一个字节，末尾之后读取到的值都为-1
    int len1 = fis.read();
    System.out.println(len1);
    int len2 = fis.read();
    System.out.println(len2);
    int len3 = fis.read();
    System.out.println(len3);
    int len4 = fis.read();
    System.out.println(len4);
    fis.close();
    
    循环优化：
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    int len = 0;
    while((len = fis.read())!=-1) { 
    	System.out.println((char)len);
    }

//文件复制（每次复制一个字节）
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
    int len = 0;
    while((len = fis.read())!=-1) { 
    	fos.write(len);
    }
    fos.close();
    fis.close();

//文件加密
    package com.blu.file01;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Test01 { 
    	
    	public static void main(String[] args) throws IOException { 
    		FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    		FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
    		jiami(fis,fos);
    		fos.close();
    		fis.close();
    	}
    	
    	public static void jiami(FileInputStream fis,FileOutputStream fos) throws IOException { 
    		byte[] bytes = new byte[204800];
    		int len = 0;
    		while((len=fis.read(bytes))!=-1) { 
    			for(int i=0;i<204700;i++) { 
    				bytes[i]++;
    			}
    			fos.write(bytes, 0, len);
    		}
    		
    	}
    	
    	public static void jiemi(FileInputStream fis,FileOutputStream fos) throws IOException { 
    		byte[] bytes = new byte[204800];
    		int len = 0;
    		while((len=fis.read(bytes))!=-1) { 
    			for(int i=0;i<204700;i++) { 
    				bytes[i]--;
    			}
    			fos.write(bytes, 0, len);
    		}
    	}
    
    }