java实现 word 要实现换行换行符号是什么 java里换行怎么写

转载

deanyuancn 2024-07-03 09:36:22

文章标签 javaee java System Desktop 文章分类 Java 后端开发

一.File类

1. 概述

File表示文件或文件夹的路径。

注意事项：File对象只表示一个路径，不表示文件，所以不管文件存不存在，File对象都不会报错。

2. 构造方法

方法	说明
public File(String pathname)	给定路径名称创建File对象
public File(String parent, String child)	给定父路径和子路径创建File对象
public File(File parent, String child)	给定父路径的File类型和子路径创建File对象

代码演示

import java.io.File;
public class Test01 {
    public static void main(String[] args) {
        //File的构造方法
        //  \是一个转义字符,能让有意义的字符变成没意义的,能没意义的字符变成有意义的
        //System.out.println("\t");
        //System.out.println("\\a");
        //结论：在""中如果想写\   就一定要写成\\
        System.out.println( " \" ");
        //public File(String pathname)
        //给定路径名称创建File对象
        File f1 = new File("C:\\Users\\jin\\Desktop\\文件复制.java");
        //File f2 = new File("C:/Users/jin/Desktop/文件复制.java");


        //public File(String parent, String child)
        //给定父路径和子路径创建File对象
        File f2 = new File("C:\\Users\\jin\\Desktop","文件复制.java");


        //public File(File parent, String child)
        //给定父路径的File类型和子路径创建File对象
        File f4 = new File(new File("C:\\Users\\jin\\Desktop"),"文件复制.java");
        
    }
}

3. 获取方法

方法介绍

方法	说明
getAbsolutePath()	获取绝对路径
getName()	获取文件名
length()	获取文件大小(不能获取目录(文件夹)的大小)

代码演示

import java.io.File;
public class Test02 {
    public static void main(String[] args) {
        //File的获取方法
        //创建对象
        File f = new File("C:\\Users\\jin\\Desktop\\文件复制.java");

        //getAbsolutePath()
        //获取绝对路径
        String s1 = f.getAbsolutePath();
        System.out.println(s1);     //C:\User\jin\Desktop\文件复制.java

        //getName()
        //获取文件或文件夹名
        String name = f.getName();
        System.out.println(name);   //文件复制.java

        //length()
        //获取文件大小(不能获取文件夹的大小)
        //如果获取文件夹的大小返回的是0或4096这个结果没有意义
        long length = f.length();
        System.out.println(length); //850 代表文件的字节个数
    }
}

4. 绝对路径和相对路径

绝对路径：绝对路径就是从盘符开始的路径。

相对路径：不从盘符开始的路径，相对于当前项目。

import java.io.File;
public class Test03 {
    public static void main(String[] args) {

        //如果我要表示123.txt这个文件
        //路径怎么写？

        //相对路径：
        //不以盘符开始,系统会默认在前面补全当前项目路径
        File f1 = new File("day10\\123.txt");
        
        //绝对路径：
        File f2 = new File("C:\\soft\\IdeaProjects\\SE143\\day10\\123.txt");
        
        //这两个写法此时表示的是同一个文件
    }
}

5. 判断方法

方法介绍

方法	说明
exists()	判断路径是否存在
isFile()	判断是否是文件
isDirectory()	判断是否是文件夹(目录)

import java.io.File;

public class Test04 {
    public static void main(String[] args) {

        File f = new File("day10\\123.txt");

        //exists()
        //判断路径是否存在
        System.out.println(f.exists());  //true

        //isFile()
        //判断是否是文件
        System.out.println(f.isFile());  //true

        //isDirectory()
        //判断是否是文件夹
        System.out.println(f.isDirectory()); //false
    }
}

6. 创建删除方法

方法介绍

方法	说明
createNewFile()	创建一个文件
delete()	删除一个文件或空文件夹(不能删除有文件的文件夹)
mkdir()	创建单层文件夹
mkdirs()	创建任意层文件夹

代码演示

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

public class Test05 {
    public static void main(String[] args) throws IOException {
        //File创建和删除方法
        File f = new File("C:\\Users\\jin\\Desktop\\abc");

        //createNewFile()
        //创建一个文件
        f.createNewFile();

        //delete()
        //删除一个文件或空文件夹(不能删除有文件的文件夹)
        //注意事项：删除方法不走回收站
        f.delete();

        //mkdir()[不用]
        //创建单层文件夹
        f.mkdir();

        //mkdirs()
        //创建任意层文件夹
        f.mkdirs();
    }
}

7. 遍历文件夹方法

方法介绍

方法	说明
list()	获取目录下所有内容的名称
listFiles()	获取目录下所有内容的File对象形式

import java.io.File;
public class Test06 {
    public static void main(String[] args) {
        //File的遍历文件夹方法

        File f = new File("C:\\Users\\jin\\Desktop\\day09");

        //list()
        //获取目录下所有内容的String名称
        String[] strs = f.list();
        //遍历数组
        for (String str : strs) {
            System.out.println(str);
        }
        
        //listFiles()
        //获取目录下所有内容的File对象形式
        File[] files = f.listFiles();
        //遍历数组
        for (File file : files) {
            System.out.println(file.getName());
        }
    }
}

练习
统计文件夹下java文件的个数
如果只需要使用名字就可以使用list(), 如果要调用File的方法就需要使用listFiles()

import java.io.File;
public class Test07 {
    public static void main(String[] args) {
        //统计文件夹下java文件的个数
        File f = new File("C:\\Users\\jin\\Desktop\\abc");
        //定义计数器
        int count = 0;
        //遍历文件夹
        File[] files = f.listFiles();
        //遍历数组
        for (File file : files) {
            //判断是否是文件 并且是否是.java结尾
            if(file.isFile() && file.getName().endsWith(".java")){
                count++;
            }
        }
        System.out.println("java文件的个数是" + count);
    }
}

二. 递归

1. 概述

递归就是把大问题变成同类型的小问题去解决。

在java中递归体现在方法调用自己。

递归必须要有出口

从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，他讲的故事是
从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，他讲的故事是
从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，他讲的故事是

2. 求5的阶乘

n! = 1×2×3×...×(n-1)×n

n! = (n-1)! * n;
5！= 4！* 5；
4！= 3! * 4;
3! = 2! * 3;
2! = 1! * 2;
1! = 1;

public class Test01 {
    public static void main(String[] args) {
        //调用方法
        int result = method(5);
        System.out.println("结果是" + result);
    }


    //java中的递归需要定义一个方法
    public static int method(int n){
        //判断
        if(n == 1){
            return 1;
        }else {
            //求n-1的阶乘
            int r = method(n - 1);
            //n-1的阶乘*n就是n的阶乘
            return r * n;
        }
    }
}

3.删除文件夹

注意：删除不走回收站，所以千万不要删除重要的内容！

import java.io.File;
public class Test02 {
    public static void main(String[] args) {
        //删除文件夹
        //创建File对象
        File f = new File("C:\\Users\\jin\\Desktop\\day07");
        //调用方法
        method(f);
    }

    //定义方法
    public static void method(File f){
        //遍历文件夹
        File[] files = f.listFiles();
        
        //遍历数组
        for (File file : files) {
            //判断file是文件还是文件夹
            if(file.isFile()){
                //直接删除
                file.delete();
            }else{
                //如果是文件夹
                method(file);
            }
        }

        //for循环结束文件夹就已经是一个空文件夹了
        f.delete();
    }
}

三. IO流

1. 什么是IO

I是In的缩写，代表输入。O是Out的缩写，代表输出。

2. IO的分类

java实现 word 要实现换行换行符号是什么 java里换行怎么写_java

3. 字节流

计算机上的任何数据都是字节数据，字节流可以操作所有数据。

1.输出流父类OutputStream

常用方法

方法	说明
close()	关闭流资源
write(byte[] b)	输出字节数组
write(byte[] b, int off, int len)	输出字节数组的一部分。off表示开始索引,len表示个数
write(int b)	输出一个字节

2.输出流子类FileOutputStream

构造方法

方法	说明
public FileOutputStream(File file)	向指定文件位置输出数据
public FileOutputStream(String name)*	向指定字符串路径输出数据
public FileOutputStream(File file，boolean b)	创建对象的同时指定是否续写true表示是
public FileOutputStream(String name,boolean b)*	创建对象的同时指定是否续写true表示是

代码演示
构造方法演示

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Test01 {
    public static void main(String[] args) throws FileNotFoundException {
        //字节输出流 构造方法

        /*
            注意事项：
                1.如果文件不存在,输出流会自动创建文件
                2.如果文件已存在,输出流会覆盖原有文件
                3.流中的路径只能写文件,不能写文件夹,如果写了文件夹拒绝访问。
                4.如果在参数加一个true,表示不覆盖原有文件,续写
         */
        //public FileOutputStream(File file)
        //向指定文件位置输出数据
        //FileOutputStream fis = new FileOutputStream(new File("day10\\123.txt"));

        //public FileOutputStream(String name)*
        //向指定字符串路径输出数据
        //FileOutputStream fis2 = new FileOutputStream("day10\\123.txt");

        //public FileOutputStream(File file，boolean b)
        //创建对象的同时指定是否续写true表示是
        //FileOutputStream fis = new FileOutputStream(new File("day10\\123.txt"),true);

        //public FileOutputStream(String name,boolean b)*
        //创建对象的同时指定是否续写true表示是
        FileOutputStream fis2 = new FileOutputStream("day10\\123.txt",true);
    }
}

常用方法的演示

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test02 {
    public static void main(String[] args) throws IOException {
        //字节输出流的常用方法

        //创建字节输出流对象
        FileOutputStream fis = new FileOutputStream("day10\\123.txt");


        //write(int b)
        //输出一个字节(代码上是数值,文件中是对应的ASCII码)
        //'A'- 65   'a'-97   '0'-48
        fis.write(97);
        fis.write(65);
        fis.write(49);

        //write(byte[] b)
        //输出字节数组
        byte[] arr = {97,98,99,100,101,102};
        fis.write(arr);

        //write(byte[] b, int off, int len)
        //输出字节数组的一部分。off表示开始索引,len表示个数
        //输出数组中从2索引开始的3个字节
        fis.write(arr,2,3);

        //close()
        //关闭流资源,这个方法在我们使用完流最后调用
        fis.close();

    }
}

输出换行

在不同的操作系统中，换行符号不一样, 在windows中换行符号就是\r\n

把字符串使用getBytes()方法转成字节数组,然后输出
fis.write("\r\n".getBytes());

3.输入流父类InputStream

常用方法

方法	说明
close()	关闭流资源
read()	每次读取一个字节，返回值代表的是字节
read(byte[] b)	每次读取一个数组的字节，返回值代表读取到的字节个数

4.输入流子类FileInputStream

构造方法

方法	说明
FileInputStream(File file)	从指定的File文件读取数据
FileInputStream(String name)	从指定字符串路径位置读取数据

代码演示

构造方法演示

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Test03 {
    public static void main(String[] args) throws FileNotFoundException {
        //字节输入流构造方法
        /*
            注意事项：
                1.输入流如果文件不存在,会报错(系统找不到指定的文件。)
                2.所有流只能写文件,不能写文件夹,如果写了文件夹(拒绝访问。)
         */
        //FileInputStream(File file)
        //从指定的File文件读取数据
        //FileInputStream fis = new FileInputStream(new File("day10\\123.txt"));

        //FileInputStream(String name)*
        //从指定字符串路径位置读取数据
        FileInputStream fis2 = new FileInputStream("day10\\123.txt");

    }
}

输入流的常用方法演示

一次读取一个字节

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test04 {
    public static void main(String[] args) throws IOException {
        //字节输入流的长衣服方法

        //创建对象
        FileInputStream fis = new FileInputStream("day10\\123.txt");

        //read()
        //每次读取一个字节，返回值代表的是字节
        //每次读取会自动读取后一个字节内容
        //在读取到文件的末尾时,会得到-1,-1代表文件已经结束了
        /*
            循环的解释：
                fis.read()              读取一个字节
                i=fis.read()            把读到的字节赋值给i
                i != -1                 判断是否读到了末尾
         */
        int i;
        while((i=fis.read()) != -1){
            System.out.println((char)i);
        }
        
        //close()
        //关闭流资源 使用完流之后关流
        fis.close();
    }
}

一次读取多个字节

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test05 {
    public static void main(String[] args) throws IOException {
        //字节输入流的长衣服方法

        //创建对象
        FileInputStream fis = new FileInputStream("day10\\123.txt");

        //read(byte[] b)
        //每次读取一个数组的字节，返回值代表读取到的字节个数
        //如果读到了文件的末尾,返回的是-1
        byte[] bys = new byte[5];
        int len;
        while((len=fis.read(bys)) != -1){
            //0代表从0索引开始,len代表的是读取到了几个就打印几个
            System.out.println(new String(bys,0,len));
        }

        /*
        int len = fis.read(bys);
        System.out.println("读到的个数是" + len);
        System.out.println("读到的数据是" + new String(bys,0,len));


        len = fis.read(bys);
        System.out.println("读到的个数是" + len);
        System.out.println("读到的数据是" + new String(bys,0,len));

        len = fis.read(bys);
        System.out.println("读到的个数是" + len);
        */

        //close()
        //关闭流资源 使用完流之后关流
        fis.close();
    }
}

5.案例：文件复制

文件的底层都是字节，字节流可以复制任何类型的文件。

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

public class Test06 {
    public static void main(String[] args) throws IOException {
        //创建输入流
        FileInputStream fis = new FileInputStream("C:\\Users\\Gray\\Desktop\\timg.jpg");
        //创建输出流
        FileOutputStream fos = new FileOutputStream("day10\\复制.jpg");

		//写法一：
        //一次读取一个字节
        //int i;
        //while((i=fis.read()) != -1){
        //    //一次输出一个字节
        //    fos.write(i);
        //}

		//写法二：
        byte[] arr = new byte[1024];
        int len;
        //一次读取多个字节
        while((len=fis.read(arr)) != -1){
            //一次写出多个字节
            fos.write(arr,0,len);
        }


        //关闭资源
        fos.close();
        fis.close();
    }
}

4.字符流

所有的文件都是字节文件，而只有文本文件的数据可以称为字符。

1.字符输入流父类Reader

方法	说明
close()	关闭流资源
read()	读取一个字符
read(char[] chs)	读取一个字符数组的内容

2.FileReader类

构造方法

方法	说明
FileReader(File file)	使用File对象的路径创建输入流
FileReader(String fileName)	使用字符串路径创建输入流

代码演示

构造方法演示

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class Test01 {
    public static void main(String[] args) throws FileNotFoundException {
        //字符输入流构造方法
        /*
            注意事项：
                1.如果文件不存在,输入流会报错(系统找不到指定的文件。)
                2.如果写的是文件夹,流对象都会报错(拒绝访问。)
         */
        //FileReader(File file)
        //使用File对象的路径创建输入流
        //FileReader fr = new FileReader(new File("day10\\123.txt"));

        //FileReader(String fileName)
        //使用字符串路径创建输入流
        FileReader fr2 = new FileReader("day10\\123.txt");
    }
}

常用读取方法演示

一次读取一个字符和一次读取字符数组

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test02 {
    public static void main(String[] args) throws IOException {
        //字符输入流的常用方法
        FileReader fr = new FileReader("C:\\Users\\jin\\Desktop\\文件复制.java");
//        FileInputStream fr = new FileInputStream("C:\\Users\\jin\\Desktop\\文件复制.java");

        //read() :读取一个字符
        //返回的是字符对应的数值
        //如果读到了文件的末尾会返回-1
        //int i;
        //while((i=fr.read()) != -1){
        //    System.out.println((char)i);
        //}

        //read(char[] chs): 读取一个字符数组的内容
        //读取返回的是读取到的字符个数，如果读到了末尾会返回-1
        char[] chs = new char[5];
        int len;
        while((len=fr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }


        //close()
        //关闭流资源
        fr.close();
    }
}

3.字符输出流父类Writer

常用方法

方法	说明
close()	关闭流资源
flush()	刷新
write(int c)	写出一个字符
write(char[] cbuf)	写出一个字符数组的内容
write(char[] b, int off, int len)	写出一个字符数组的一部分
write(String str)	写出一个字符串

4.FileWriter类

构造方法

方法	说明
FileWriter(File file)	用File对象所表示的路径创建输出流对象
FileWriter(String fileName)	File字符串所表示的路径创建输出流对象
FileWriter(File file,boolean b)	用File对象所表示的路径创建输出流对象,true表示续写
FileWriter(String fileName,boolean b)	File字符串所表示的路径创建输出流对象,true表示续写

代码演示

构造方法演示

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

public class Test03 {
    public static void main(String[] args) throws IOException {
        //字符输出流构造方法
        /*
            注意事项：
                1.如果文件不存在,输出流会创建文件
                2.如果文件已存在,输出流会覆盖文件
                3.所有流只能操作文件,不能操作文件夹(拒绝访问。)
                4.如果构造加了参数true 表示不清空文件 续写
         */
        //FileWriter(File file)
        //用File对象所表示的路径创建输出流对象
        //FileWriter fw = new FileWriter(new File("day10\\123.txt"));


        //FileWriter(String fileName)
        //File字符串所表示的路径创建输出流对象
        //FileWriter fw2 = new FileWriter("day10\\123.txt");

        //FileWriter(File file,boolean b)
        //用File对象所表示的路径创建输出流对象,true表示续写
        //FileWriter fw = new FileWriter(new File("day10\\123.txt"),true);

        //FileWriter(String fileName,boolean b)
        //File字符串所表示的路径创建输出流对象,true表示续写
        FileWriter fw2 = new FileWriter("day10\\123.txt",true);
    }
}

常用方法演示

常用方法

import java.io.FileWriter;
import java.io.IOException;

public class Test05 {
    public static void main(String[] args) throws IOException {
        //创建对象
        FileWriter fw = new FileWriter("day10\\123.txt");

        //write(int c)
        //写出一个字符
        fw.write(97);
        fw.write('a');
        fw.write('我');

        //write(char[] cbuf)
        //写出一个字符数组的内容
        char[] chs = {'a','b','c','我','爱','你'};
        fw.write(chs);

        //write(char[] b, int off, int len)
        //写出一个字符数组的一部分
        //输出“我爱你”这部分，3索引开始输出3个
        fw.write(chs,3,3);

        //write(String str)
        //写出一个字符串
        fw.write("石原里美");
        
        //关闭资源
        fw.close();
    }
}

关闭和刷新
字符输出流底层有一个缓冲区，输出的字符会被先放在缓冲区。
当调用刷新或者是缓冲区放满时才会真正的输出到文件中。
close()方法自带刷新功能,只要最后记得关流，中间可以不做刷新。

import java.io.FileWriter;
import java.io.IOException;

public class Test04 {
    public static void main(String[] args) throws IOException {
        //字符输出流的常用方法
        FileWriter fw = new FileWriter("day10\\123.txt");

        //输出
        fw.write(97);
        fw.write(97);

        //flush()
        //刷新(可以把缓冲区的数据刷新到文件中)
        //close()
        //关闭方法其实自带了刷新功能
        //在最后只要调用了关闭就可以把缓冲区的内容全部放到文件中
        //关闭流资源
        fw.close();
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。