// 创建字节缓冲输入流 BufferedInputStream bis = new BufferedInputStream ( new FileInputStream ( "bis.txt" )); // 创建字节缓冲输出流 BufferedOutputStream bos = new BufferedOutputStream ( new FileOutputStream ( "bos.txt" ));

public static void test_copy_speed () { String src = "D:\\01-io-test\\w1.bin" ; String dest = "D:\\01-io-test\\w1-copy.bin" ; long start = System.currentTimeMillis(); try ( FileInputStream is = new FileInputStream (src); FileOutputStream fos = new FileOutputStream (dest);){ int len; while ((len = is.read()) >= 0 ) { fos.write(len); } System.out.println( "传统+单字节，耗时：" +(System.currentTimeMillis()-start)+ "ms" ); } catch (Exception e) { System.out.printf( "拷贝文件异常：" +e.getMessage()); e.printStackTrace(); } } // 耗时20分钟+，直接关了程序；单个字节的读取，非常慢

public static void test_copy_speed_buffer () { String src = "D:\\01-io-test\\w1.bin" ; String dest = "D:\\01-io-test\\w2-copy.bin" ; long start = System.currentTimeMillis(); try ( BufferedInputStream is = new BufferedInputStream ( new FileInputStream (src)); BufferedOutputStream fos = new BufferedOutputStream ( new FileOutputStream (dest));){ int len; while ((len = is.read()) >= 0 ) { fos.write(len); } System.out.println( "缓冲流+单字节，耗时：" +(System.currentTimeMillis()-start)+ "ms" ); } catch (Exception e) { System.out.printf( "拷贝文件异常：" +e.getMessage()); e.printStackTrace(); } } // 输出，4分钟不到 缓冲流+单字节，耗时：205811ms

public static void test_copy_speed () { String src = "D:\\01-io-test\\w1.bin" ; String dest = "D:\\01-io-test\\w1-copy.bin" ; long start = System.currentTimeMillis(); try ( FileInputStream is = new FileInputStream (src); FileOutputStream fos = new FileOutputStream (dest);){ byte [] cache = new byte [ 1024 ]; int len; while ((len = is.read(cache)) >= 0 ) { fos.write(cache, 0 ,len); } System.out.println( "传统+字节数组，耗时：" +(System.currentTimeMillis()-start)+ "ms" ); } catch (Exception e) { System.out.printf( "拷贝文件异常：" +e.getMessage()); e.printStackTrace(); } } // 输出,66秒 传统+字节数组，耗时：66029ms

public static void test_copy_speed_buffer () { String src = "D:\\01-io-test\\w1.bin" ; String dest = "D:\\01-io-test\\w3-copy.bin" ; long start = System.currentTimeMillis(); try ( BufferedInputStream is = new BufferedInputStream ( new FileInputStream (src)); BufferedOutputStream fos = new BufferedOutputStream ( new FileOutputStream (dest));){ byte [] buffer = new byte [ 1024 ]; int len; while ((len = is.read(buffer)) >= 0 ) { fos.write(buffer, 0 ,len); } System.out.println( "缓冲流+数组，耗时：" +(System.currentTimeMillis()-start)+ "ms" ); } catch (Exception e) { System.out.printf( "拷贝文件异常：" +e.getMessage()); e.printStackTrace(); } } // 输出 缓冲流+数组，耗时：14833ms

// 创建字符缓冲输入流 BufferedReader br = new BufferedReader ( new FileReader ( "br.txt" )); // 创建字符缓冲输出流 BufferedWriter bw = new BufferedWriter ( new FileWriter ( "bw.txt" ));

public class BufferedReaderDemo { public static void main (String[] args) throws IOException { // 创建流对象 BufferedReader br = new BufferedReader ( new FileReader ( "in.txt" )); // 定义字符串,保存读取的一行文字 String line = null ; // 循环读取,读取到最后返回null while ((line = br.readLine())!= null ) { System.out.print(line); System.out.println( "------" ); } // 释放资源 br.close(); } }

public class BufferedWriterDemo throws IOException { public static void main (String[] args) throws IOException  { // 创建流对象 BufferedWriter bw = new BufferedWriter ( new FileWriter ( "out.txt" )); // 写出数据 bw.write( "学习" ); // 写出换行 bw.newLine(); bw.write( "工具" ); bw.newLine(); bw.write( "太多" ); bw.newLine(); // 释放资源 bw.close(); } } 输出效果: 学习 工具 太多

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。 8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。 4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。 2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。 1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。 9.今当远离，临表涕零，不知所言。 6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。 7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。 5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

public class Demo05Test { public static void main (String[] args) throws IOException { //1.创建ArrayList集合,泛型使用String ArrayList<String> list = new ArrayList <>(); //2.创建BufferedReader对象,构造方法中传递FileReader对象 BufferedReader br = new BufferedReader ( new FileReader ( "10_IO\\in.txt" )); //3.创建BufferedWriter对象,构造方法中传递FileWriter对象 BufferedWriter bw = new BufferedWriter ( new FileWriter ( "10_IO\\out.txt" )); //4.使用BufferedReader对象中的方法readLine,以行的方式读取文本 String line; while ((line = br.readLine())!= null ){ //5.把读取到的文本存储到ArrayList集合中 list.add(line); } //6.使用Collections集合工具类中的方法sort,对集合中的元素按照自定义规则排序 Collections.sort(list, new Comparator <String>() { /* o1-o2:升序 o2-o1:降序 */ @Override public int compare (String o1, String o2) { //依次比较集合中两个元素的首字母,升序排序 return o1.charAt( 0 )-o2.charAt( 0 ); } }); //7.遍历ArrayList集合,获取每一个元素 for (String s : list) { //8.使用BufferedWriter对象中的方法wirte,把遍历得到的元素写入到文本中(内存缓冲区中) bw.write(s); //9.写换行 bw.newLine(); } //10.释放资源 bw.close(); br.close(); } }

public class ReaderDemo { public static void main (String[] args) throws IOException { FileReader fileReader = new FileReader ( "E:\\File_GBK.txt" ); int read; while ((read = fileReader.read()) != - 1 ) { System.out.print(( char )read); } fileReader.close(); } } 输出结果： ���

InputStreamReader isr = new InputStreamReader ( new FileInputStream ( "in.txt" )); InputStreamReader isr2 = new InputStreamReader ( new FileInputStream ( "in.txt" ) , "GBK" );

public class ReaderDemo2 { public static void main (String[] args) throws IOException { // 定义文件路径,文件为gbk编码 String FileName = "E:\\file_gbk.txt" ; // 创建流对象,默认UTF8编码 InputStreamReader isr = new InputStreamReader ( new FileInputStream (FileName)); // 创建流对象,指定GBK编码 InputStreamReader isr2 = new InputStreamReader ( new FileInputStream (FileName) , "GBK" ); // 定义变量,保存字符 int read; // 使用默认编码字符流读取,乱码 while ((read = isr.read()) != - 1 ) { System.out.print(( char )read); // ��Һ� } isr.close(); // 使用指定编码字符流读取,正常解析 while ((read = isr2.read()) != - 1 ) { System.out.print(( char )read); // 大家好 } isr2.close(); } }

OutputStreamWriter isr = new OutputStreamWriter ( new FileOutputStream ( "out.txt" )); OutputStreamWriter isr2 = new OutputStreamWriter ( new FileOutputStream ( "out.txt" ) , "GBK" );

public class OutputDemo { public static void main (String[] args) throws IOException { // 定义文件路径 String FileName = "E:\\out.txt" ; // 创建流对象,默认UTF8编码 OutputStreamWriter osw = new OutputStreamWriter ( new FileOutputStream (FileName)); // 写出数据 osw.write( "你好" ); // 保存为6个字节 osw.close(); // 定义文件路径 String FileName2 = "E:\\out2.txt" ; // 创建流对象,指定GBK编码 OutputStreamWriter osw2 = new OutputStreamWriter ( new FileOutputStream (FileName2), "GBK" ); // 写出数据 osw2.write( "你好" ); // 保存为4个字节 osw2.close(); } }

public class TransDemo { public static void main (String[] args) { // 1.定义文件路径 String srcFile = "file_gbk.txt" ; String destFile = "file_utf8.txt" ; // 2.创建流对象 // 2.1 转换输入流,指定GBK编码 InputStreamReader isr = new InputStreamReader ( new FileInputStream (srcFile) , "GBK" ); // 2.2 转换输出流,默认utf8编码 OutputStreamWriter osw = new OutputStreamWriter ( new FileOutputStream (destFile)); // 3.读写数据 // 3.1 定义数组 char [] cbuf = new char [ 1024 ]; // 3.2 定义长度 int len; // 3.3 循环读取 while ((len = isr.read(cbuf))!=- 1 ) { // 循环写出 osw.write(cbuf, 0 ,len); } // 4.释放资源 osw.close(); isr.close(); } }

FileOutputStream fileOut = new FileOutputStream ( "employee.txt" ); ObjectOutputStream out = new ObjectOutputStream (fileOut);

public class Employee implements java .io.Serializable { public String name; public String address; public transient int age; // transient瞬态修饰成员,不会被序列化 public void addressCheck () { System.out.println( "Address  check : " + name + " -- " + address); } }

public class SerializeDemo { public static void main (String [] args) { Employee e = new Employee (); e.name = "zhangsan" ; e.address = "beiqinglu" ; e.age = 20 ; try { // 创建序列化流对象 ObjectOutputStream out = new ObjectOutputStream ( new FileOutputStream ( "employee.txt" )); // 写出对象 out.writeObject(e); // 释放资源 out.close(); fileOut.close(); System.out.println( "Serialized data is saved" ); // 姓名，地址被序列化，年龄没有被序列化。 } catch (IOException i)   { i.printStackTrace(); } } } 输出结果： Serialized data is saved

public class DeserializeDemo { public static void main (String [] args) { Employee e = null ; try { // 创建反序列化流 FileInputStream fileIn = new FileInputStream ( "employee.txt" ); ObjectInputStream in = new ObjectInputStream (fileIn); // 读取一个对象 e = (Employee) in.readObject(); // 释放资源 in.close(); fileIn.close(); } catch (IOException i) { // 捕获其他异常 i.printStackTrace(); return ; } catch (ClassNotFoundException c)  { // 捕获类找不到异常 System.out.println( "Employee class not found" ); c.printStackTrace(); return ; } // 无异常,直接打印输出 System.out.println( "Name: " + e.name); // zhangsan System.out.println( "Address: " + e.address); // beiqinglu System.out.println( "age: " + e.age); // 0 } }

public class Employee implements java .io.Serializable { // 加入序列版本号 private static final long serialVersionUID = 1L ; public String name; public String address; // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值. public int eid; public void addressCheck () { System.out.println( "Address  check : " + name + " -- " + address); } }

public class SerTest { public static void main (String[] args) throws Exception { // 创建 学生对象 Student student = new Student ( "老王" , "laow" ); Student student2 = new Student ( "老张" , "laoz" ); Student student3 = new Student ( "老李" , "laol" ); ArrayList<Student> arrayList = new ArrayList <>(); arrayList.add(student); arrayList.add(student2); arrayList.add(student3); // 序列化操作 // serializ(arrayList); // 反序列化 ObjectInputStream ois = new ObjectInputStream ( new FileInputStream ( "list.txt" )); // 读取对象,强转为ArrayList类型 ArrayList<Student> list  = (ArrayList<Student>)ois.readObject(); for ( int i = 0 ; i < list.size(); i++ ){ Student s = list.get(i); System.out.println(s.getName()+ "--" + s.getPwd()); } } private static void serializ (ArrayList<Student> arrayList) throws Exception { // 创建 序列化流 ObjectOutputStream oos = new ObjectOutputStream ( new FileOutputStream ( "list.txt" )); // 写出对象 oos.writeObject(arrayList); // 释放资源 oos.close(); } }

PrintStream ps = new PrintStream ( "ps.txt" )；

public class PrintDemo { public static void main (String[] args) throws IOException { // 调用系统的打印流,控制台直接输出97 System.out.println( 97 ); // 创建打印流,指定文件的名称 PrintStream ps = new PrintStream ( "ps.txt" ); // 设置系统的打印流流向,输出到ps.txt System.setOut(ps); // 调用系统的打印流,ps.txt中输出97 System.out.println( 97 ); } }

/* *   解压缩流 * * */ public class ZipStreamDemo1 { public static void main (String[] args) throws IOException { //1.创建一个File表示要解压的压缩包 File src = new File ( "D:\\aaa.zip" ); //2.创建一个File表示解压的目的地 File dest = new File ( "D:\\" ); //调用方法 unzip(src,dest); } //定义一个方法用来解压 public static void unzip (File src,File dest) throws IOException { //解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中 //创建一个解压缩流用来读取压缩包中的数据 ZipInputStream zip = new ZipInputStream ( new FileInputStream (src)); //要先获取到压缩包里面的每一个zipentry对象 //表示当前在压缩包中获取到的文件或者文件夹 ZipEntry entry; while ((entry = zip.getNextEntry()) != null ){ System.out.println(entry); if (entry.isDirectory()){ //文件夹：需要在目的地dest处创建一个同样的文件夹 File file = new File (dest,entry.toString()); file.mkdirs(); } else { //文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放） FileOutputStream fos = new FileOutputStream ( new File (dest,entry.toString())); int b; while ((b = zip.read()) != - 1 ){ //写到目的地 fos.write(b); } fos.close(); //表示在压缩包中的一个文件处理完毕了。 zip.closeEntry(); } } zip.close(); } }

public class ZipStreamDemo2 { public static void main (String[] args) throws IOException { /* *   压缩流 *      需求： *          把D:\\a.txt打包成一个压缩包 * */ //1.创建File对象表示要压缩的文件 File src = new File ( "D:\\a.txt" ); //2.创建File对象表示压缩包的位置 File dest = new File ( "D:\\" ); //3.调用方法用来压缩 toZip(src,dest); } /* *   作用：压缩 *   参数一：表示要压缩的文件 *   参数二：表示压缩包的位置 * */ public static void toZip (File src,File dest) throws IOException { //1.创建压缩流关联压缩包 ZipOutputStream zos = new ZipOutputStream ( new FileOutputStream ( new File (dest, "a.zip" ))); //2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹 //参数：压缩包里面的路径 ZipEntry entry = new ZipEntry ( "aaa\\bbb\\a.txt" ); //3.把ZipEntry对象放到压缩包当中 zos.putNextEntry(entry); //4.把src文件中的数据写到压缩包当中 FileInputStream fis = new FileInputStream (src); int b; while ((b = fis.read()) != - 1 ){ zos.write(b); } zos.closeEntry(); zos.close(); } }

public class ZipStreamDemo3 { public static void main (String[] args) throws IOException { /* *   压缩流 *      需求： *          把D:\\aaa文件夹压缩成一个压缩包 * */ //1.创建File对象表示要压缩的文件夹 File src = new File ( "D:\\aaa" ); //2.创建File对象表示压缩包放在哪里（压缩包的父级路径） File destParent = src.getParentFile(); //D:\\ //3.创建File对象表示压缩包的路径 File dest = new File (destParent,src.getName() + ".zip" ); //4.创建压缩流关联压缩包 ZipOutputStream zos = new ZipOutputStream ( new FileOutputStream (dest)); //5.获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中 toZip(src,zos,src.getName()); //aaa //6.释放资源 zos.close(); } /* *   作用：获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中 *   参数一：数据源 *   参数二：压缩流 *   参数三：压缩包内部的路径 * */ public static void toZip (File src,ZipOutputStream zos,String name) throws IOException { //1.进入src文件夹 File[] files = src.listFiles(); //2.遍历数组 for (File file : files) { if (file.isFile()){ //3.判断-文件，变成ZipEntry对象，放入到压缩包当中 ZipEntry entry = new ZipEntry (name + "\\" + file.getName()); //aaa\\no1\\a.txt zos.putNextEntry(entry); //读取文件中的数据，写到压缩包 FileInputStream fis = new FileInputStream (file); int b; while ((b = fis.read()) != - 1 ){ zos.write(b); } fis.close(); zos.closeEntry(); } else { //4.判断-文件夹，递归 toZip(file,zos,name + "\\" + file.getName()); //     no1            aaa   \\   no1 } } } }

public class ProDemo { public static void main (String[] args) throws FileNotFoundException { // 创建属性集对象 Properties properties = new Properties (); // 添加键值对元素 properties.setProperty( "filename" , "a.txt" ); properties.setProperty( "length" , "209385038" ); properties.setProperty( "location" , "D:\\a.txt" ); // 打印属性集对象 System.out.println(properties); // 通过键,获取属性值 System.out.println(properties.getProperty( "filename" )); System.out.println(properties.getProperty( "length" )); System.out.println(properties.getProperty( "location" )); // 遍历属性集,获取所有键的集合 Set<String> strings = properties.stringPropertyNames(); // 打印键值对 for (String key : strings ) { System.out.println(key+ " -- " +properties.getProperty(key)); } } } 输出结果： {filename=a.txt, length= 209385038 , location=D:\a.txt} a.txt 209385038 D:\a.txt filename -- a.txt length -- 209385038 location -- D:\a.txt

filename=a.txt length=209385038 location=D:\a.txt

public class ProDemo2 { public static void main (String[] args) throws FileNotFoundException { // 创建属性集对象 Properties pro = new Properties (); // 加载文本中信息到属性集 pro.load( new FileInputStream ( "read.txt" )); // 遍历集合并打印 Set<String> strings = pro.stringPropertyNames(); for (String key : strings ) { System.out.println(key+ " -- " +pro.getProperty(key)); } } } 输出结果： filename -- a.txt length -- 209385038 location -- D:\a.txt

// 第一步：Path接口 public static Path of (String first, String... more) { return FileSystems.getDefault().getPath(first, more); } // 第二步：FileSystems类 public static FileSystem getDefault () { if (VM.isModuleSystemInited()) { return DefaultFileSystemHolder.defaultFileSystem; } else { // always use the platform's default file system during startup return DefaultFileSystemProvider.theFileSystem(); } } // 第三步：JDk对平台的实现，如这里是：windows /** * Creates this platform's default FileSystemProvider. */ public class DefaultFileSystemProvider { private static final WindowsFileSystemProvider INSTANCE = new WindowsFileSystemProvider (); private DefaultFileSystemProvider () { } /** * Returns the platform's default file system provider. */ public static WindowsFileSystemProvider instance () { return INSTANCE; } /** * Returns the platform's default file system. */ public static FileSystem theFileSystem () { return INSTANCE.theFileSystem(); } } // 第四步：该系统的提供者WindowsFileSystemProvider @Override public Path getPath (URI uri) { return WindowsUriSupport.fromUri(theFileSystem, uri); } // 第五步：从文件系统中将标准的uri转换为Path路径 static WindowsPath fromUri (WindowsFileSystem fs, URI uri) { // 省略 return WindowsPath.parse(fs, path); // Path的实现类，其内部静态方法 } // 第六步：创建该系统的Path实例 /** * Creates a Path by parsing the given path. */ static WindowsPath parse (WindowsFileSystem fs, String path) { WindowsPathParser. Result result = WindowsPathParser.parse(path); return new WindowsPath (fs, result.type(), result.root(), result.path()); }

Path path = Paths.get( "data" , "input.txt" ); // 多参数自动拼接

Path path = Paths.get( "/home/user/data/input.txt" );

URI uri = new URI ( "file:/home/user/data/input.txt" ); Path path = Path.of(uri);

Path dir = Paths.get( "/home/user" ); Path file = dir.resolve( "data.txt" ); // /home/user/data.txt

Path relative = Paths.get( "data.txt" ); Path absolute = relative.toAbsolutePath(); // 当前工作目录 + data.txt

Path path = Paths.get( "/home/user/./docs/../data.txt" ).normalize(); // 结果为 /home/user/data.txt

Path parent = path.getParent(); // 返回上一级目录

if (Files.exists(path)) { System.out.println( "File exists." ); }

if (Files.isDirectory(path)) { System.out.println( "It's a directory." ); }

if (Files.isRegularFile(path)) { System.out.println( "It's a regular file." ); }

List<String> lines = Files.readAllLines(path);

List<String> content = List.of( "Line 1" , "Line 2" ); Files.write(path, content, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);

Path source = Paths.get( "source.txt" ); Path target = Paths.get( "dest.txt" ); // 复制 Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING); // 移动（重命名） Files.move(source, target, StandardCopyOption.ATOMIC_MOVE); // 删除 Files.deleteIfExists(target);

Files.walk(path) .filter(p -> p.toString().endsWith( ".txt" )) .forEach(System.out::println);

try (DirectoryStream<Path> stream = Files.newDirectoryStream(path, "*.txt" )) { for (Path entry : stream) { System.out.println(entry.getFileName()); } }

try ( BufferedReader reader = Files.newBufferedReader(path)) { String line; while ((line = reader.readLine()) != null ) { System.out.println(line); } } catch (IOException e) { e.printStackTrace(); }

Path path = Paths.get( "data" + File.separator + "input.txt" );

Path path = Paths.get( "data/input.txt" );

URI uri = path.toUri();

URL url = path.toUri().toURL();

public class TodayTest { public static void main (String[] args) throws Exception { //        test_currentDir(); //        test_path(); //        test_write("ts.txt"); //        test_read("ts.txt"); //        test_copy_move_del(); //        test_write_option(StandardOpenOption.APPEND); } public static void test_uri_url () throws MalformedURLException { Path path = Paths.get( "testdata" , "wsj" , "a.txt" ); System.out.println(path); URI uri = path.toUri(); System.out.println(uri); URL url = uri.toURL(); System.out.println(url); } // 遍历当前目录，可设置条件过滤 public static void test_newDirStream () throws IOException { Files.newDirectoryStream(Paths.get( "testdata" ), p->p.toString().endsWith( ".txt" )).forEach(System.out::println); } // 遍历子目录 public static void test_walk () throws IOException { Files.walk(Paths.get( "testdata" )) .filter(p->p.toString().endsWith( ".txt" )) .forEach(System.out::println); } public static void test_currentDir () { String projectDir = System.getProperty( "user.dir" ); System.out.println( "项目当前目录： " +projectDir); } public static void test_path () throws Exception { // 各种方式创建path实例 // 系统自适配连接符，避免人工出错 Path p1 = Paths.get( "data" , "doc" , "a.txt" ); System.out.println( "path1: " +p1); System.out.println( "path1-绝对路径: " +p1.toAbsolutePath()); Path p2 = Paths.get( "/data/b.txt" ); System.out.println( "path2: " +p2); URI uri = new URI ( "file:/data/c.txt" ); Path p3 = Paths.get(uri); System.out.println( "path3: " +p3); Path p4 = Path.of(uri); System.out.println( "path4: " +p4); // 拼接路径，新实例 Path p5 = Paths.get( "home" , "data" , "doc" ); Path p6 = p5.resolve( "d.txt" ); System.out.println( "p5: " +p5); System.out.println( "p6: " +p6); // 转换为绝对路径 Path absolutePath = p6.toAbsolutePath(); System.out.println( "absolutePath: " +absolutePath); Path p7 = Paths.get( "/home/data/doc/./../g.txt" ); System.out.println( "p7: " +p7); Path p8 = p7.normalize(); System.out.println( "p8: " +p8); Path p9 = p8.getParent(); System.out.println( "p8的parent为p9: " +p9); // 返回上一级 System.out.println( "p9存在？" +Files.exists(p9)); // 存在且为目录 System.out.println( "p9是目录？" +Files.isDirectory(p9)); System.out.println( "p8是文件？" +Files.isRegularFile(p8)); } public static void test_copy_move_del () throws IOException { Path path = Paths.get( "testdata" , "wsj" , "a.txt" ); Path pathParent = path.getParent(); if (Files.notExists(pathParent)) { Files.createDirectories(pathParent); } Files.writeString(path,demoTxt); Files.writeString(path, LocalDateTime.now().toString(),StandardOpenOption.APPEND); Path dest = Paths.get( "a-back.txt" ); Files.copy(path, dest, StandardCopyOption.REPLACE_EXISTING); System.out.println( "文件拷贝成功！" +dest.toAbsolutePath()); } public static void test_read (String fileName) throws IOException { Path path = Paths.get(fileName); List<String> readAllLines = Files.readAllLines(path); readAllLines.forEach(System.out::println); } public static void test_write (String fileName) throws IOException { Path path = Paths.get(fileName); System.out.println(path); Path p1 = Files.writeString(path.toAbsolutePath(), demoTxt); System.out.println( "写出成功：" +p1.toAbsolutePath()); } public static void test_write_option (StandardOpenOption option) throws IOException { Path path = Files.writeString(Paths.get( "my.txt" ), "hello\n" , option); System.out.println( "文件写入成功：" +path); } static String demoTxt = """ you are such a good boy! yes! thank you! That is cool. """ ; }

file:///D:/gitcode/icp-server/testdata/wsj/a.txt

<scheme>:[//<authority>][/<path>][?<query>][#<fragment>]

file:///<path>

file:///D:/project/file.txt

https://example.com/images/photo.jpg

import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; public class RemoteFileReader { public static void main (String[] args) { try { URL url = new URL ( "https://example.com/files/demo.txt" ); try ( BufferedReader reader = new BufferedReader ( new InputStreamReader (url.openStream()))) { String line; while ((line = reader.readLine()) != null ) { System.out.println(line); } } } catch (Exception e) { e.printStackTrace(); } } }

import java.io.InputStream; import java.io.FileOutputStream; import java.net.URL; public class ImageDownloader { public static void main (String[] args) { try { URL url = new URL ( "https://example.com/images/photo.jpg" ); try ( InputStream in = url.openStream(); FileOutputStream out = new FileOutputStream ( "downloaded_photo.jpg" )) { byte [] buffer = new byte [ 1024 ]; int bytesRead; while ((bytesRead = in.read(buffer)) != - 1 ) { out.write(buffer, 0 , bytesRead); } System.out.println( "图片已保存！" ); } } catch (Exception e) { e.printStackTrace(); } } }

import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; import java.util.Base64; public class AuthenticatedRequest { public static void main (String[] args) { try { String user = "username" ; String pass = "password" ; String auth = Base64.getEncoder().encodeToString((user + ":" + pass).getBytes()); URL url = new URL ( "https://api.example.com/secure/data.txt" ); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod( "GET" ); conn.setRequestProperty( "Authorization" , "Basic " + auth); if (conn.getResponseCode() == 200 ) { try ( BufferedReader reader = new BufferedReader ( new InputStreamReader (conn.getInputStream()))) { String line; while ((line = reader.readLine()) != null ) { System.out.println(line); } } } else { System.out.println( "访问失败，状态码：" + conn.getResponseCode()); } } catch (Exception e) { e.printStackTrace(); } } }

URL url = new URL ( "ftp://anonymous@ftp.example.net/pub/file.txt" ); try ( BufferedReader reader = new BufferedReader ( new InputStreamReader (url.openStream()))) { String line; while ((line = reader.readLine()) != null ) { System.out.println(line); } }

import org.springframework.web.client.RestTemplate; public class SpringRemoteFetcher { public static void main (String[] args) { RestTemplate restTemplate = new RestTemplate (); String result = restTemplate.getForObject( "https://example.com/api/data" , String.class); System.out.println(result); } }