java代码如何读取文件呢?

实现思路:
    按字节读取
	按字符读取
	按行读取
	。。。

package com.java265;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.list;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class fileUtill {
	
	public static void main(String[] args) {
		//要读取文件目录的绝对路径
		String filepPath="D:/test/20220907.txt";
		readFileByBytes(filepPath);
        readFileByChars(filepPath);
        readFileByLines(filepPath);
        readFileByRandomAccess(filepPath);
        testReadFile(filepPath);
        testReadFile11(filepPath); 
	}
	
	
	/**
     * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
     */
    public static void readFileByBytes(String fileName) {
        File file = new File(fileName);
        InputStream in = null;
        try {
            System.out.println("以字节为单位读取文件内容，一次读取一个字节：");
            // 一次读一个字节
            in = new FileInputStream(file);
            int tempbyte;
            while ((tempbyte = in.read()) != -1) {
                System.out.write(tempbyte);
            }
            in.close();
            System.out.println("--------------------------------------------------------------------------------------------");
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        try {
            System.out.println("以字节为单位读取文件内容，一次读取多个字节：");
            // 一次读多个字节
            byte[] tempbytes = new byte[100];
            int byteread = 0;
            in = new FileInputStream(fileName);
            showAvailableBytes(in);
            // 读入多个字节到字节数组中，byteread为一次读入的字节数
            while ((byteread = in.read(tempbytes)) != -1) {
                System.out.write(tempbytes, 0, byteread);
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e1) {
                }
            }
        }
    }
 
    /**
     * 以字符为单位读取文件，常用于读文本，数字等类型的文件
     */
    public static void readFileByChars(String fileName) {
        File file = new File(fileName);
        Reader reader = null;
        try {
            System.out.println("以字符为单位读取文件内容，一次读取一个字节：");
            // 一次读一个字符
            reader = new InputStreamReader(new FileInputStream(file));
            int tempchar;
            while ((tempchar = reader.read()) != -1) {
                // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
                // 但如果这两个字符分开显示时，会换两次行。
                // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
                if (((char) tempchar) != '\r') {
                    System.out.print((char) tempchar);
                }
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        
        try (Scanner sc = new Scanner(new FileReader(fileName))) {
            while (sc.hasNextLine()) {  //按行读取字符串
               String line = sc.nextLine();
               System.out.println("按行读取字符串："+line);
            }
         } catch (FileNotFoundException e3) {
			// TODO Auto-generated catch block
			e3.printStackTrace();
		}
 
         try (Scanner sc = new Scanner(new FileReader(fileName))) {
            sc.useDelimiter("\\|");  //按分隔符
            while (sc.hasNext()) {   //按分隔符读取字符串
               String str = sc.next();
               System.out.println("按分隔符："+str);
            }
         } catch (FileNotFoundException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}
 
         //sc.hasNextInt() 、hasNextFloat() 、基础数据类型等等等等。
         //文件内容：1|2
         try (Scanner sc = new Scanner(new FileReader(fileName))) {
            sc.useDelimiter("\\|");   //按"|"分隔符
            while (sc.hasNextInt()) {   //按分隔符读取Int
                int intValue = sc.nextInt();
               System.out.println("按\"|\"分隔符："+intValue);
            }
        
         } catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        
        
        try {
            System.out.println("以字符为单位读取文件内容，一次读多个字节：");
            // 一次读多个字符
            char[] tempchars = new char[30];
            int charread = 0;
            reader = new InputStreamReader(new FileInputStream(fileName));
            // 读入多个字符到字符数组中，charread为一次读取字符数
            while ((charread = reader.read(tempchars)) != -1) {
                // 同样屏蔽掉\r不显示
                if ((charread == tempchars.length)
                        && (tempchars[tempchars.length - 1] != '\r')) {
                    System.out.print(tempchars);
                } else {
                    for (int i = 0; i < charread; i++) {
                        if (tempchars[i] == '\r') {
                            continue;
                        } else {
                            System.out.print(tempchars[i]);
                        }
                    }
                }
            }
 
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
    }
 
    /**
     * 以行为单位读取文件，常用于读面向行的格式化文件
     */
    public static void readFileByLines(String fileName) {
        File file = new File(fileName);
        BufferedReader reader = null;
        try {
            System.out.println("以行为单位读取文件内容，一次读一整行：");
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            int line = 1;
            // 一次读入一行，直到读入null为文件结束
            while ((tempString = reader.readLine()) != null) {
                // 显示行号
                System.out.println("line " + line + ": " + tempString);
                line++;
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }
        
        
    }
    //jdk8
    public static void testReadFile(String fileName) {
    	 File file = new File(fileName);
    	 Stream<String> lines=null;
         try {
         	// 读取文件内容到Stream流中，按行读取
             lines = Files.lines(Paths.get(fileName));
 
             // 1、随机行顺序进行数据处理(forEach获取Stream流中的行数据不能保证顺序，但速度快。如果你想按顺序去处理文件中的行数据，可以使用forEachOrdered，但处理效率会下降。)
             lines.forEach(ele -> {
                System.out.println("读取文件内容到Stream流中，按行读取："+ele);
             });
             
             // 2、或按文件行顺序进行处理(使用forEachOrdered，处理效率会下降)
             lines.forEachOrdered(System.out::println);
             
            // 3、或按文件行顺序进行处理(利用CPU多和的能力，进行数据的并行处理parallel()，适合比较大的文件)
             lines.parallel().forEachOrdered(System.out::println);
             //4、也可以把Stream<String>转换成List<String>,但是要注意这意味着你要将所有的数据一次性加载到内存，要注意java.lang.OutOfMemoryError: Java heap space
             List<String> collect = lines.collect(Collectors.toList());
             for(String list : collect) {
            	 System.out.println(list);
             }
             // 5、如果我们不需要Stream<String>,我们想直接按行读取文件获取到一个List<String>, 要注意java.lang.OutOfMemoryError: Java heap space
             List<String> linestr = Files.readAllLines(Paths.get(fileName),
                         StandardCharsets.UTF_8);
             linestr.forEach(System.out::println);
             
             lines.close();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (lines != null) {
             	lines.close();
             }
         }
    }
    
  //jdk11
    public static void testReadFile11(String fileName) {
    	 
    	   // java 11 开始提供的方法，读取文件不能超过2G，与你的内存息息相关
    	   String str = Files.readString(Paths.get(fileName));
    	   System.out.println(str);
    	   //如果是JDK11用上面的方法，如果不是用这个方法也很容易
    	   byte[] bytes = Files.readAllBytes(Paths.get(fileName));
 
    	   String content = new String(bytes, StandardCharsets.UTF_8);
    	   System.out.println(content);
    }
 
    /**
     * 随机读取文件内容
     */
    public static void readFileByRandomAccess(String fileName) {
        RandomAccessFile randomFile = null;
        try {
            System.out.println("随机读取一段文件内容：");
            // 打开一个随机访问文件流，按只读方式
            randomFile = new RandomAccessFile(fileName, "r");
            // 文件长度，字节数
            long fileLength = randomFile.length();
            // 读文件的起始位置
            int beginIndex = (fileLength > 4) ? 4 : 0;
            // 将读文件的开始位置移到beginIndex位置。
            randomFile.seek(beginIndex);
            byte[] bytes = new byte[10];
            int byteread = 0;
            // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
            // 将一次读取的字节数赋给byteread
            while ((byteread = randomFile.read(bytes)) != -1) {
                System.out.write(bytes, 0, byteread);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (randomFile != null) {
                try {
                    randomFile.close();
                } catch (IOException e1) {
                }
            }
        }
    }
 
    /**
     * 显示输入流中还剩的字节数
     */
    private static void showAvailableBytes(InputStream in) {
        try {
            System.out.println("当前字节输入流中的字节数为:" + in.available());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}