Java中级/ I/O1

最新推荐文章于 2022-05-03 00:20:36 发布

fan__lee

最新推荐文章于 2022-05-03 00:20:36 发布

阅读量291

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/fan__lee/article/details/108559731

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

文件对象

文件和文件夹都是用File代表

创建文件对象以及文件常用方法

创建一个文件对象：

File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。

package file;
  
import java.io.File;
  
public class TestFile {
  
    public static void main(String[] args) {
        // 绝对路径
        File f1 = new File("d:/pp");
        System.out.println("f1的绝对路径：" + f1.getAbsolutePath());
        // 相对路径,相对于工作目录，如果在eclipse中，就是项目目录
        File f2 = new File("manuscript.pdf");
        System.out.println("f2的绝对路径：" + f2.getAbsolutePath());
  
        // 把f1作为父目录创建文件对象
        File f3 = new File(f1, "README.html");
        System.out.println("f3的绝对路径：" + f3.getAbsolutePath());
        System.out.println("判断是否存在："+f3.exists());
    }
}
'输出：'
f1的绝对路径是E:\pp
f2的绝对路径：E:\project\j2se\manuscript.pdf
f3的绝对路径：E:\pp\README.html
判断是否存在：false

文件常用方法1：
注意1：需要在D:\LOLFolder确实存在一个LOL.exe,才可以看到对应的文件长度、修改时间等信息。
注意2： renameTo方法用于对物理文件名称进行修改，但是并不会修改File对象的name属性。

package test;
import java.io.File;
import java.io.IOException;
public class TestFilePath {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(System.getProperty("user.dir"));
  
  try {
   System.out.println("-----默认相对路径：取得路径不同------");
   File file1 = new File("..\\src\\test1.txt");
   System.out.println(file1.getPath());
   System.out.println(file1.getAbsolutePath());
   System.out.println(file1.getCanonicalPath());
   System.out.println("-----默认相对路径：取得路径不同------");
   File file = new File(".\\test1.txt");
   System.out.println(file.getPath());
   System.out.println(file.getAbsolutePath());
   System.out.println(file.getCanonicalPath());
   
   System.out.println("-----默认绝对路径:取得路径相同------");
   File file2 = new File("D:\\workspace\\test\\test1.txt");
   System.out.println(file2.getPath());
   System.out.println(file2.getAbsolutePath());
   System.out.println(file2.getCanonicalPath());
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}
程序执行结果如下：
F:\eclipseworkspace\testejb
-----默认相对路径：取得路径不同------
..\src\test1.txt
F:\eclipseworkspace\testejb\..\src\test1.txt
F:\eclipseworkspace\src\test1.txt
-----默认相对路径：取得路径不同------
.\test1.txt
F:\eclipseworkspace\testejb\.\test1.txt
F:\eclipseworkspace\testejb\test1.txt
-----默认绝对路径:取得路径相同------
D:\workspace\test\test1.txt
D:\workspace\test\test1.txt
D:\workspace\test\test1.txt
结论：
当输入为绝对路径时，返回的都是绝对路径。
当输入为相对路径时：
getPath()返回的是File构造方法里的路径，是什么就是什么，不增不减
getAbsolutePath()返回的其实是user.dir+getPath()的内容，从上面F:\eclipseworkspace\testejb、F:\eclipseworkspace\testejb\..\src\test1.txt、F:\eclipseworkspace\testejb\.\test1.txt可以得出。
getCanonicalPath()返回的就是标准的将符号完全解析的路径

package j2se;

import java.io.File;
import java.util.Date;

public class lian {         
        public static void main(String[] args) {
        	File f = new File("E:/project/ii.txt");
        	System.out.println("当前文件是"+f);
        	//文件是否存在
        	System.out.println("判断文件是否存在"+f.exists());
        	
        	//是否是文件夹
            System.out.println("判断是否是文件夹："+f.isDirectory());
            
          //是否是文件（非文件夹）
            System.out.println("判断是否是文件："+f.isFile());
            
            //文件长度
            System.out.println("获取文件的长度："+f.length());
            
            //文件最后修改时间
            long time = f.lastModified();
            Date d = new Date(time);
            f.setLastModified(0);
            System.out.println("获取文件的最后修改时间："+d);
            
            //文件重命名
            File f1 = new File("E:/project/jj.txt");
            f.renameTo(f1);
            System.out.println("把ii.txt改名成了jj.txt");       
            System.out.println("注意： 需要在E:/project确实存在一个ii.txt,\r\n才可以看到对应的文件长度、修改时间等信息");
            System.out.println("当前文件是："+f);
        }       
}
"输出："
当前文件是E:\project\ii.txt
判断文件是否存在true
判断是否是文件夹：false
判断是否是文件：true
获取文件的长度：76
获取文件的最后修改时间：Thu Jan 01 08:00:00 CST 1970
把ii.txt改名成了jj.exe
注意： 需要在E:/project确实存在一个ii.txt,
才可以看到对应的文件长度、修改时间等信息
当前文件是：E:\project\ii.txt

文件常用方法2:

package file;
  
import java.io.File;
import java.io.IOException;
  
public class TestFile {
  
    public static void main(String[] args) throws IOException {
  
        File f = new File("d:/LOLFolder/skin/garen.ski");
  
        // 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
        f.list();
  
        // 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
        File[]fs= f.listFiles();
  
        // 以字符串形式返回获取所在文件夹
        f.getParent();
  
        // 以文件形式返回获取所在文件夹
        f.getParentFile();
        // 创建文件夹，如果父文件夹skin不存在，创建就无效
        f.mkdir();
  
        // 创建文件夹，如果父文件夹skin不存在，就会创建父文件夹
        f.mkdirs();
  
        // 创建一个空文件,如果父文件夹skin不存在，就会抛出异常
        f.createNewFile();
        // 所以创建一个空文件之前，通常都会创建父目录
        f.getParentFile().mkdirs();
  
        // 列出所有的盘符c: d: e: 等等
        f.listRoots();
  
        // 刪除文件
        f.delete();
  
        // JVM结束的时候，刪除文件，常用于临时文件的删除
        f.deleteOnExit();
  
    }
}

有些时候，程序需要读写一些临时文件，File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。

public class Main {
    public static void main(String[] args) throws IOException {
        File f = File.createTempFile("tmp-", ".txt"); // 提供临时文件的前缀和后缀
        f.deleteOnExit(); // JVM退出时自动删除
        System.out.println(f.isFile());
        System.out.println(f.getAbsolutePath());
    }
}

Path

Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：

import java.io.*;
import java.nio.file.*;
public class Main {
    public static void main(String[] args) throws IOException {
        Path p1 = Paths.get(".", "project", "study"); // 构造一个Path对象
        System.out.println(p1);
        Path p2 = p1.toAbsolutePath(); // 转换为绝对路径
        System.out.println(p2);
        Path p3 = p2.normalize(); // 转换为规范路径
        System.out.println(p3);
        File f = p3.toFile(); // 转换为File对象
        System.out.println(f);
        for (Path p : Paths.get("..").toAbsolutePath()) { // 可以直接遍历Path
            System.out.println("  " + p);
        }
    }
}

练习-遍历文件夹

一般说来操作系统都会安装在C盘，所以会有一个 C:\WINDOWS目录。
遍历这个目录下所有的文件(不用遍历子目录)
找出这些文件里，最大的和最小(非0)的那个文件，打印出他们的文件名

package j2se;

import java.io.File;

public class lian {         
    public static void main(String[] args){
        File f = new File("C:/WINDOWS");
        File[] fs = f.listFiles();
        File max = fs[0];
        File min = fs[0];
        
        for (int i=1;i<fs.length;i++){
        	if (max.length()<fs[i].length()){
        		max = fs[i];
        	}else if (min.length()>fs[i].length()){
        		min = fs[i];
        	}
        }
        System.out.println("最大文件是："+max+"最小文件是："+min);
    }
}

遍历文件下全部文件夹


import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Date;

public class Cmain {
	public static void main(String[] args) throws IOException {
		File f = new File("F:\\my");
		File[] fs = f.listFiles();
		printFiles(fs);
		File[] fs1 = f.listFiles(
				new FilenameFilter() {
					public boolean accept(File dir,String name) {
						return name.endsWith(".exe");
					}
				});
		printFiles(fs1);
	}
	private static void printFiles(File[] files) {
		System.out.println("''''''''''''");
		if (files !=null) {
			for(File ff :files) {
				if(ff.isDirectory()) {
					File[] fsFiles = ff.listFiles();
					printFiles(fsFiles);
				}
				System.out.println(ff.getName());
			}
		}
		System.out.println("'''''''''''''''''");
	}
}

流

什么是流(Stream)，流就是一系列的数据
当不同的介质之间有数据交互的时候，JAVA就使用流来实现。
数据源可以是文件，还可以是数据库，网络甚至是其他的程序
比如读取文件的数据到程序中，站在程序的角度来看，就叫做输入流
输入流： InputStream
输出流：OutputStream
文件输入流
如下代码，就建立了一个文件输入流，这个流可以用来把数据从硬盘的文件，读取到JVM(内存)。
目前代码只是建立了流，还没有开始读取

package stream;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
 
public class TestStream {
 
    public static void main(String[] args) {
        try {
            File f = new File("d:/lol.txt");
            // 创建基于文件的输入流
            FileInputStream fis = new FileInputStream(f);
            // 通过这个输入流，就可以把数据从硬盘，读取到Java的虚拟机中来，也就是读取到内存中
 
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}

文件输出流：

package file;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
 
public class TestStream {
    public static void main(String[] args) {
        File f =new File("d:/lol.txt");
        try {
            FileOutputStream fos = new FileOutputStream(f);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
 
    }
}

字节流

InputStream字节输入流
OutputStream字节输出流
用于以字节的形式读取和写入数据

ASCII码：所有的数据存放在计算机中都是以数字的形式存放的。所以字母就需要转换为数字才能够存放。
比如A就对应的数字65，a对应的数字97. 不同的字母和符号对应不同的数字，就是一张码表。 ASCII是这样的一种码表。
只包含简单的英文字母，符号，数字等等。不包含中文，德文，俄语等复杂的。

以字节流的形式读取文件内容：

InputStream是字节输入流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。
FileInputStream 是InputStream子类，以FileInputStream 为例进行文件读取

package j2se;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class lian {         
    public static void main(String[] args){
    	try{
    	    //准备文件
    		File f = new File("E:/jj.txt");
    		 //创建基于文件的输入流
    		FileInputStream fis = new FileInputStream(f);
    		//创建字节数组，其长度就是文件的长度，用来存放文件内容
    		byte[] all = new byte[(int)f.length()];
    		//以字节流的形式读取文件所有内容
    		fis.read(all);
    		for (byte j : all){
    			System.out.println(j);
    		}
    		//每次使用完流，都应该进行关闭
    		fis.close();
    	}catch(IOException e){
    		e.printStackTrace();
    	}
    }
}

以字节流的形式向文件写入数据：
OutputStream是字节输出流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。
FileOutputStream 是OutputStream子类，以FileOutputStream 为例向文件写出数据
注: 如果文件d:/lol2.txt不存在，写出操作会自动创建该文件。
但是如果是文件 d:/xyz/lol2.txt，而目录xyz又不存在，会抛出异常

package j2se;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class lian {         
    public static void main(String[] args){
    	try{
    		File f = new File("E:/tt.txt");
    		// 创建基于文件的输出流，如果文件不存在就会自动创建，但是不会创建父文件夹
    		FileOutputStream fos = new FileOutputStream(f);
    		byte[] all = {99,88};
    		fos.write(all);
    		for (byte j : all){
    			System.out.println(j);
    		}
    		fos.close();
    	}catch(IOException e){
    		e.printStackTrace();
    	}
    }
}

但是，如果是写入数据到d:/xyz/lol2.txt，而目录xyz又不存在的话，就会抛出异常。那么怎么自动创建xyz目录？

f.getParentFile().mkdir();

拆分文件：
找到一个大于100k的文件，按照100k为单位，拆分成多个子文件，并且以编号作为文件名结束。
比如文件 eclipse.exe，大小是309k。
拆分之后，成为
eclipse.exe-0
eclipse.exe-1
eclipse.exe-2
eclipse.exe-3

package j2se;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class lian {         
    public static void main(String[] args){
    	try{
    		File f = new File("E:/jj.txt");
    		FileInputStream fis = new FileInputStream(f);	
    		byte[] b = new byte[102400];
    		long len = f.length();
    		for (int i = 0;len>0;i++){
    			if(len<102400){
    				b = new byte[(int)len];
    			}
    			fis.read(b);
    			File f2 = new File("e:/jj"+i+".txt");
    			FileOutputStream fos = new FileOutputStream(f2);
    			fos.write(b);
    			len = len-102400;
    			fos.close();
    		}
    	}catch(IOException e){
    		e.printStackTrace();
    	}
    }
}

合并文件：
把上述拆分出来的文件，合并成一个原文件。

关闭流的方式

所有的流，无论是输入流还是输出流，使用完毕之后，都应该关闭。如果不关闭，会产生对资源占用的浪费。当量比较大的时候，会影响到业务的正常开展

在try中关闭
在try的作用域里关闭文件输入流，在前面的示例中都是使用这种方式，这样做有一个弊端；
如果文件不存在，或者读取的时候出现问题而抛出异常，那么就不会执行这一行关闭流的代码，存在巨大的资源占用隐患。不推荐使用
在finally中关闭
这是标准的关闭流的方式

首先把流的引用声明在try的外面，如果声明在try里面，其作用域无法抵达finally.
在finally关闭之前，要先判断该引用是否为空
关闭的时候，需要再一次进行try catch处理
这是标准的严谨的关闭流的方式，但是看上去很繁琐，所以写不重要的或者测试代码的时候，都会采用上面的有隐患try的方式，因为不麻烦~

        File f = new File("d:/lol.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(f);
            byte[] all = new byte[(int) f.length()];
            fis.read(all);
            for (byte b : all) {
                System.out.println(b);
            }
 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 在finally 里关闭流
            if (null != fis)
                try {
 
                    fis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }

使用try()的方式
把流定义在try()里,try,catch或者finally结束的时候，会自动关闭
这种编写代码的方式叫做 try-with-resources 这是从JDK7开始支持的技术
所有的流，都实现了一个接口叫做 AutoCloseable，任何类实现了这个接口，都可以在try()中进行实例化。并且在try, catch, finally结束的时候自动关闭，回收相关资源。

实际上，编译器并不会特别地为InputStream加上自动关闭。编译器只看try(resource = …)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。

package stream;
  
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
  
        //把流定义在try()里,try,catch或者finally结束的时候，会自动关闭
        try (FileInputStream fis = new FileInputStream(f)) {
            byte[] all = new byte[(int) f.length()];
            fis.read(all);
            for (byte b : all) {
                System.out.println(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
  
    }
}

字符流

Reader字符输入流
Writer字符输出流
专门用于字符的形式读取和写入数据
使用字符流读取文件 ：
FileReader 是Reader子类，以FileReader 为例进行文件读取：

package stream;
 
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
 
public class TestStream {
 
    public static void main(String[] args) {
        // 准备文件lol.txt其中的内容是AB
        File f = new File("d:/lol.txt");
        // 创建基于文件的Reader
        try (FileReader fr = new FileReader(f)) {
            // 创建字符数组，其长度就是文件的长度
            char[] all = new char[(int) f.length()];
            // 以字符流的形式读取文件所有内容
            fr.read(all);
            for (char b : all) {
                // 打印出来是A B
                System.out.println(b);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}

使用字符流把字符串写入到文件：

package stream;
  
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        // 准备文件lol2.txt
        File f = new File("d:/lol2.txt");
        // 创建基于文件的Writer
        try (FileWriter fr = new FileWriter(f)) {
            // 以字符流的形式把数据写入到文件中
            String data="abcdefg1234567890";
            char[] cs = data.toCharArray();
            fr.write(cs);
  
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

练习：

package j2se;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class lian {         
    public static void main(String[] args){
    	File sourceFile = new File("E:/tt.txt");
    	File destFile = new File("E:/ii.txt");
    	encodingFile(sourceFile,destFile);
    }
   public static void encodingFile(File sourceFile, File destFile){
	   //创建字符数组chars存储读取的源文件内容
	   char[] chars = new char[(int) sourceFile.length()];
	   try(FileReader fr = new FileReader(sourceFile)){
		   fr.read(chars);
	   }catch(IOException e){
		   e.printStackTrace();
	   }
	   System.out.println("源文件内容为：");
	   for(char i : chars){
		   System.out.print(i+" ");
	   }
	   for (int i = 0; i < chars.length; i++) {
           if (chars[i] > '0' && chars[i] <= '9') {
               chars[i] -= 1;
           } else if (chars[i] == '0') {
               chars[i] = '9';
           } else if (chars[i] > 'a' && chars[i] <= 'z') {
               chars[i] -= 1;
           } else if (chars[i] == 'a') {
               chars[i] = 'z';
           } else if (chars[i] > 'A' && chars[i] <= 'Z') {
               chars[i] -= 1;
           } else if (chars[i] == 'A') {
               chars[i] = 'Z';
           }
       }
	   System.out.println("加密后文件内容为：");
	   for (char ch : chars) {
           System.out.print(ch + "");
       }
	   try (FileWriter fw = new FileWriter(destFile)) {
           fw.write(chars);
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

中文

计算机存放数据只能存放数字，所有的字符都会被转换为不同的数字。
常见编码：

工作后经常接触的编码方式有如下几种：
ISO-8859-1 ASCII 数字和西欧字母
GBK GB2312 BIG5 中文
UNICODE (统一码，万国码)
其中
ISO-8859-1 包含 ASCII
GB2312 是简体中文，BIG5是繁体中文，GBK同时包含简体和繁体以及日文。
UNICODE 包括了所有的文字，无论中文，英文，藏文，法文，世界所有的文字都包含其中

== Java采用的是Unicode==
写在.java源代码中的汉字，在执行之后，都会变成JVM中的字符。
而这些中文字符采用的编码方式，都是使用UNICODE. "中"字对应的UNICODE是4E2D,所以在内存中，实际保存的数据就是十六进制的0x4E2D, 也就是十进制的20013。

字符在文件中的保存
字符保存在文件中肯定也是以数字形式保存的，即对应在不同的棋盘上的不同的数字
用记事本打开任意文本文件，并且另存为，就能够在编码这里看到一个下拉。
ANSI 这个不是ASCII的意思，而是采用本地编码的意思。如果你是中文的操作系统，就会使GBK，如果是英文的就会是ISO-8859-1
Unicode UNICODE原生的编码方式
Unicode big endian 另一个 UNICODE编码方式
UTF-8 最常见的UTF-8编码方式，数字和字母用一个字节，汉字用3个字节。
用FileInputStream 字节流正确读取中文
为了能够正确的读取中文内容

必须了解文本是以哪种编码方式保存字符的
使用字节流读取了文本后，再使用对应的编码方式去识别这些数字，得到正确的字符
如本例，一个文件中的内容是字符中，编码方式是GBK，那么读出来的数据一定是D6D0。
再使用GBK编码方式识别D6D0，就能正确的得到字符中
(我敲的是UTF-8的)，输出是

文件中读粗来的数据是：
27
e4
b8
ad
27
d
a
把这个数字，放在GBK的棋盘上去：
'中'

package j2se;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileInputStream;
import java.io.IOException;

public class lian {         
    public static void main(String[] args){
    	File f = new File("E:/tt.txt");
    	try(FileInputStream fis = new FileInputStream(f);){
    		byte[] all = new byte[(int)f.length()];
    		fis.read(all);
    		System.out.println("文件中读粗来的数据是：");
    		for(byte i : all){
    			int j = i&0x000000ff;//只取16进制的后两位
    			System.out.println(Integer.toHexString(j));
    		}
    		 System.out.println("把这个数字，放在GBK的棋盘上去：");
    		 String str = new String(all,"UTF-8");
             System.out.println(str);
    	}catch(IOException e){
			e.printStackTrace();
		}
   }
}

用FileReader 字符流正确读取中文
FileReader得到的是字符，所以一定是已经把字节根据某种编码识别成了字符了
而FileReader使用的编码方式是Charset.defaultCharset()的返回值，如果是中文的操作系统，就是GBK
FileReader是不能手动设置编码方式的，为了使用其他的编码方式，只能使用InputStreamReader来代替，像这样：

new InputStreamReader(new FileInputStream(f),Charset.forName("UTF-8"));

在本例中，用记事本另存为UTF-8格式，然后用UTF-8就能识别对应的中文了。
解释：为什么中字前面有一个?
如果是使用记事本另存为UTF-8的格式，那么在第一个字节有一个标示符，叫做BOM用来标志这个文件是用UTF-8来编码的。

package j2se;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

public class lian {         
    public static void main(String[] args) throws UnsupportedEncodingException, FileNotFoundException {
        File f = new File("E:/tt.txt");
        System.out.println("默认编码方式:"+Charset.defaultCharset());
        //FileReader得到的是字符，所以一定是已经把字节根据某种编码识别成了字符了
        //而FileReader使用的编码方式是Charset.defaultCharset()的返回值，如果是中文的操作系统，就是GBK
        try (FileReader fr = new FileReader(f)) {
            char[] cs = new char[(int) f.length()];
            fr.read(cs);
            System.out.printf("FileReader会使用默认的编码方式%s,识别出来的字符是：%n",Charset.defaultCharset());
            System.out.println(new String(cs));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try (InputStreamReader isr = new InputStreamReader(new FileInputStream(f),Charset.forName("UTF-8"))) {
            char[] cs = new char[(int) f.length()];
            isr.read(cs);
            System.out.printf("InputStreamReader 指定编码方式UTF-8,识别出来的字符是：%n");
            System.out.println(new String(cs));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }  
}
'输出：'
默认编码方式:GBK
FileReader会使用默认的编码方式GBK,识别出来的字符是：
'涓?'
InputStreamReader 指定编码方式UTF-8,识别出来的字符是：
'中'

练习找出 E5 B1 8C 这3个十六进制对应UTF-8编码的汉字

package j2se;

import java.io.UnsupportedEncodingException;

public class lian {         
    public static void main(String[] args) throws UnsupportedEncodingException{
    	byte[] cs = new byte[]{(byte) 0xE5,(byte) 0xB1,(byte) 0x8C};
    	String str = new String(cs,"UTF-8");
    	System.out.println(str);
        }  
}

fan__lee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中级/ I/O1

文章目录文件对象创建文件对象以及文件常用方法练习-遍历文件夹流字节流以字节流的形式读取文件内容：关闭流的方式字符流中文文件对象文件和文件夹都是用File代表创建文件对象以及文件常用方法创建一个文件对象：package file; import java.io.File; public class TestFile { public static void main(String[] args) { // 绝对路径 File f1 = new
复制链接

扫一扫