java类file的newline方法_JavaSE——File类 及I/O操作

一. File类

1.1 概述File类是http://java.io包很重要的一个类；

File类的对象可以表示文件，也可以是目录。

File对象只可以对文件或目录的属性进行操作，不可以操作文件的具体数据，即不能对文件进行读/写操作。

1.2 构造方法

(1) parent, child)

从父抽象路径名和子路径名字符串创建新的 File实例。

(2)pathname)

通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

(3) parent, child)

从父路径名字符串和子路径名字符串创建新的 File实例。

(4) uri)

通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

代码案例：

//创建文件的方法

public class CreateFile {

public static void main(String[] args) {

// 创建文件对象。

File file = new File("D:/FileDemo/FileDemo.txt");

// 创建文件

if (!file.exists()) {

try {

if (file.createNewFile()) {

System.out.println("文件创建成功");

} else {

System.out.println("文件创建失败");

}

} catch (IOException e) {

e.printStackTrace();

}

} else {

System.out.println("文件已存在");

}

}

}

//创建目录的方法

import java.io.File;

public class CreateDirectory {

public static void main(String[] args) {

File file = new File("D:\\FileDemo");

if (!file.exists()) {

if (file.mkdirs()) {

System.out.println("创建成功");

} else {

System.out.println("创建目录失败");

}

} else {

System.out.println("目录已存在,创建失败");

}

}

}

1.3 常用方法

遍历方法：

//遍历方法

import java.io.File;

public class FileList{

public static void main(String[] args) {

// 创建目录对象。

File file = new File("E:\\");

// 使用list方法

String[] fileNameList = file.list();

// 遍历目录数组

for (String s : fileNameList) {

System.out.println(s);

}

System.out.println("------------------------------------");

// 使用listFiles方法

File[] fileList = file.listFiles();

for (File f : fileList) {

System.out.println(f.getAbsolutePath());

}

}

}

1.4 FileFilter文件过滤器

1.4.1 两个作用：

(1)过滤不符合规格的文件名文件名过滤器接口：interface FilenameFilter

需重写accept方法自定义过滤规则boolean accept(File dir, String name)

-- dir：表示文件的当前目录。

-- name：表示当前目录的子目录或者文件的名字。File类中提供了使用文件名过滤器遍历目录的方法String[] list(FilenameFilter filter)

-- 把满足指定过滤条件的文件和目录，返回到String数组中。

File[] listFiles(FilenameFilter filter)

-- 把满足指定过滤条件的文件和目录，返回到File数组中。

(2)常用于检测文件是否存在文件过滤器接口：interface FileFilter

需重写accept方法自定义过滤规则,如下：boolean accept(File pathName)

-- pathName：表示当前目录的子目录或者文件的名字。File类中提供了使用文件过滤器遍历目录的方法：File[] listFiles(FilenameFilter filter)

-- 把满足指定过滤条件的文件和目录，返回到File数组中。

代码演示：

public class FileFilterDemo {

public static void main(String[] args) {

//创建目录对象

File dir = new File("D:\\FileDemo");

//使用"匿名内部类"的方式创建过滤器

FileFilter filter = new FileFilter() {

@Override

public boolean accept(File file) {

return file.getName().toLowerCase().endsWith(".txt");

}

};

File[] files = dir.listFiles(filter);

for (File file : files) {

System.out.println(file);

}

}

}

二. 输入流与输出流

类：InputStream、OutputStream、Reader、Writer

2.1 流按着数据的传输方向分为：输入流：往内存中读叫输入流。

输出流：从内存中往外写叫输出流。

(1)所有输入流都是InputStream类或者Reader类的子类。类名以InputStream结尾的类都是InputStream的子类。

类名以Reader结尾的类都是Reader类的子类。

(3)所有输出流都是OutputStream类或者Writer类的子类。类名以OutputStream结尾的类都是OutputStream的子类。

类名以Writer结尾的类都是Writer类的子类。

2.2 从数据流编码格式上划分为：字节流：处理单元为1个字节

字符流：处理单元为2个字节

(1)InputStream和OutputStream的子类都是字节流可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。

(2)Reader和Writer的子类都是字符流主要处理字符或字符串，字符流处理单元为2个字节。

字节流将读取到的字节数据，去指定的编码表中获取对应文字。

由于上述两种分类都是针对InputStream、OutputStream、Reader、Writer四个类，所以代码案例写在一起

代码案例：

//字节输入流(FileInputStream)

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class FileInputStreamDemo {

public static void main(String[] args) {

//建立文件对象 File file=new File("C:\\Users\\25849\\Desktop\\1.txt");

try

{

//建立链接 FileInputStream fileInputStream=new FileInputStream(file);

int n=0;

StringBuffer sBuffer=new StringBuffer();

while (n!=-1) //当n不等于-1,则代表未到末尾 {

n=fileInputStream.read();//读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回

char by=(char) n; //转成字符

sBuffer.append(by);

}

System.out.println(sBuffer.toString());

}

catch (FileNotFoundException e)

{

System.out.println("文件不存在或者文件不可读或者文件是目录");

}

catch (IOException e)

{

System.out.println("读取过程存在异常");

}

}

}

结果：由于文件存的是字符类型，以字节形式读取，会把原本的字符分解为两个字节，所以乱码了

????¤§???????¤§asfsa???

sdg sgdf???dfhfh

?¤§?????????????????¨é??

?????¨é???????¨é??sf?

//字节输出流(FileOutputStream)

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputStreamDemo {

public static void main(String[] args) {

// 建立文件对象File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

try {

String content = "我生来坚强\n只要不死\n我就笑得猖狂";

FileOutputStream out = new FileOutputStream(file, true);

out.write(content.getBytes());

System.out.println("写入成功");

}

catch (FileNotFoundException e) {

System.out.println("文件不存在或者文件不可读或者文件是目录");

} catch (IOException e) {

System.out.println("读取过程存在异常");

}

}

}

结果：

写入成功

在没有实力之前，你要学会比狼能忍

在有了实力之后，你要学会比狼更狠我生来坚强我生来坚强

只要不死

我就笑得猖狂

//字符输入流(FileReader)

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

public class FileReaderDemo2 {

public static void main(String[] args) {

// 建立文件对象File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

try {

// 建立链接FileReader fileReader = new FileReader(file);

int n = 0;

char[] chars = new char[10];

String s ;

while ((n = fileReader.read(chars)) != -1) // 当n不等于-1,则代表未到末尾{

String string = new String(chars,0,n);

System.out.println(string);

}

} catch (FileNotFoundException e) {

System.out.println("文件不存在或者文件不可读或者文件是目录");

} catch (IOException e) {

System.out.println("读取过程存在异常");

}

}

}

//字符输出流(FileWriter)

import java.io.FileWriter;

import java.io.IOException;

public class FileWriterDemo2 {

public static void main(String[] args) {

FileWriter filewriter = null;

try {

filewriter = new FileWriter("C:\\Users\\25849\\Desktop\\1.txt",true);

String content = "abcdefghigklmn";

filewriter.write( content );

} catch (IOException e1) {

e1.printStackTrace();

}finally{

try {

//清空缓存区filewriter.flush();

//关闭“文件字符输出流”filewriter.close();

System.out.println("写入成功！");

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

2.3 从封装类型不同分为：节点流：如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。

处理流：如果流封装的是其它流对象，称为处理流。处理流提供了缓冲功能，提高读写效率。

(1)节点流中常用类字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter

(2)处理流中常用类缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

上面的节点流就是之前描述的，在这里着重描述处理流

2.3.1 处理流：

1.缓冲区原理：

-缓冲区的概念。

-缓冲区的作用：要对操作的数据进行临时的缓存，提高了读写效率。

-缓冲区如何提高读写效率。

2.处理流的特点：字符缓冲输入流提供了读取一行的方法readLine() 。

字符缓冲输出流提供了写入一个空行的方法newLine()。

字符缓冲输出流，把写入的数据先写入到内存，再使用flush()方法将内存数据刷到硬盘上。

注意：在使用字符缓冲输出流时，一定先flush(),然后再close(),避免数据的丢失。

代码案例：

//缓冲字节输入处理流(BufferedInputStream)

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class BufferedInputStreamDemo2 {

public static void main(String[] args) {

FileInputStream fileInputStream = null;

BufferedInputStream bufferedInputStream = null;

try {

fileInputStream = new FileInputStream("C:\\Users\\25849\\Desktop\\1.txt");

bufferedInputStream = new BufferedInputStream(fileInputStream);

byte[] bytes = new byte[16];

int length = 0;

while ((length = bufferedInputStream.read(bytes)) != -1) {

System.out.println(new String(bytes, 0, length));

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

bufferedInputStream.close();

System.out.println("读取完成！");

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//缓冲字节输出处理流(BufferedOutputStream)

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedOutputStreamDemo2 {

public static void main(String[] args) {

FileOutputStream fileOutputStream = null;

BufferedOutputStream bufferedOutputStream = null;

try {

fileOutputStream = new FileOutputStream("C:\\Users\\25849\\Desktop\\1.txt");

bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

String content = "abcdefghigklmn";

byte[] bytes = content.getBytes();

bufferedOutputStream.write(bytes);

System.out.println("写入成功！");

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

// 刷新 “缓冲字节输出处理流”

bufferedOutputStream.flush();

// 关闭 “缓冲字节输出处理流”

bufferedOutputStream.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//缓冲字符输入处理流(BufferedReader)

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class BufferedReaderDemo2 {

public static void main(String[] args) {

FileReader fileReader = null;

BufferedReader bufferedReader = null;

try {

fileReader = new FileReader("C:\\Users\\25849\\Desktop\\1.txt");

bufferedReader = new BufferedReader(fileReader);

String content = null;

int length = 0;

while ((content = bufferedReader.readLine()) != null) {

System.out.println(content);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

//关闭 “字符输入处理流”

bufferedReader.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//缓冲缓冲字符输出处理流(BufferedWriter )

2.4 节点流和处理流速度的对比

//用字节节点流复制一个视频

package com.company.project.homework.h11;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import javax.xml.crypto.Data;

//复制两个视频文件

//字节流

//用节点流

public class Demo2 {

public static void main(String[] args) throws IOException {

long now = System.currentTimeMillis();

FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");

FileOutputStream fos ;

File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");

if(!newfile.exists()) {

newfile.createNewFile();

}

fos = new FileOutputStream(newfile);

byte[] by = new byte[128];

int num = 0 ;

while ((num = fis.read(by)) != -1) {

fos.write(by,0,num);

}

System.out.println("复制完成");

System.out.println("使用时间:" + (System.currentTimeMillis() - now));

fos.close();

fis.close();

}

}

结果：

复制完成

使用时间:203

//用字节处理流复制同一个视频

package com.company.project.homework.h11;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import javax.xml.crypto.Data;

//复制两个视频文件

//字节流

//用处理流

public class Demo {

public static void main(String[] args) throws IOException {

long now = System.currentTimeMillis();

FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");

FileOutputStream fos ;

File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");

if(!newfile.exists()) {

newfile.createNewFile();

}

fos = new FileOutputStream(newfile);

BufferedInputStream bis = new BufferedInputStream(fis);

BufferedOutputStream bos = new BufferedOutputStream(fos);

byte[] by = new byte[128];

int num = 0 ;

while ((num = bis.read(by)) != -1) {

bos.write(by,0,num);

}

System.out.println("复制完成");

System.out.println("使用时间:" + (System.currentTimeMillis() - now));

bos.close();

bis.close();

fos.close();

fis.close();

}

}

结果：

复制完成

使用时间:15

明显速度提升了很多！！！！