I/O

文件、File类、java.io包

文件可以认为是相关记录或存放在一起的数据的集合;
文件一般是存放在磁盘上的,例如:硬盘、光盘和软盘等。

File文件类提供了文件和目录管理的功能,主要包括:

  • 文件及目录的创建;
  • 文件名、文件大小、最后修改日期等文件属性的查询;
  • 文件目录管理、文件夹创建等操作。
  • File类位于java.io包中。

注意,File类并不能直接对文件内容进行读/写操作,只能查看文件的属性

文件操作

文件对象(即,File类对象)不但可以表示文件,还可以表示目录,在程序中一个File类对象可以代表一个文件或目录。

  • 文件路径的几种表达形式
    File f1 = new File( “c:/ java123/abc.txt” );
    File f1 = new File( “c:// java123// abc.txt” );
  • 创建文件对象并非创建文件本身,而是创建一个File类的对象所具有的存储空间,为后续文件的管理、文件的读写做好准备
    File f1 = new File( “c:/ java123/abc.txt“ );
1
2
3
创建文件:
File f=new File("C:/java123/input.txt"); //开辟存储空间
f.createNewFile(); //创建文件




FilenameFilter : 是一个接口,该接口有唯一方法 boolean accept(File dir, String name) 用于判断dir、name指定文件是否为需要类型。
只要创建一个类,实现此接口即可实现文件过滤功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package io流;
import java.io.*;
public class MyFile3 {

public static void main(String[] args) {
// TODO 自动生成的方法存根
File newwj=new File("c:/java123/a.txt");
if(newwj.exists()) {
try {
newwj.createNewFile();//创建文件
System.out.println("文件已创建");
}catch(IOException e) {
e.printStackTrace();
}
}
System.out.println("名称:"+newwj.getPath());
System.out.println("绝对路径:"+newwj.getAbsolutePath());
System.out.println("文件父路径:"+newwj.getParent());
System.out.println();

}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package io流;
import java.io.*;
import java.text.*;
import java.util.Date;
public class MyFile {
private static final String FilePath="c:/java123/媒体文件夹/图片.jpg";
//private static final String FilePath="c:"+File.pathSeparator+"java123"+File.pathSeparator+"abc.txt";
//pathseparator 文件路径分隔符

public static void main(String[] args) throws IOException {
// TODO 自动生成的方法存根
//当前工程所在的根目录 new File(".")
//方法1
File wj=new File(FilePath);
//方法2
//File wj=new File("c:/java123","abc.txt");
//方法3
//File dir=new File("c:/java123");
//File wj=new File(dir,"abc.txt");
System.out.println("文件或目录是否存在:"+wj.exists());
System.out.println("是文件吗:"+wj.isFile());
System.out.println("是目录吗:"+wj.isDirectory());
System.out.println("名称:"+wj.getName());
System.out.println("绝对路径:"+wj.getAbsolutePath());
System.out.println("文件大小:"+wj.length()); //文件的长度,以字节为单位
System.out.println("是否为可读:"+wj.canRead());
System.out.println("是否被写入:"+wj.canWrite());
System.out.println("文件名字:"+wj.getName());
System.out.println("文件父路径:"+wj.getParent());
System.out.println();

SimpleDateFormat sj=new SimpleDateFormat("yyyy-MM-dd");
Date a=new Date(wj.lastModified());
System.out.println("最后修改日期:"+wj.lastModified()+" "+sj.format(a));

//使用createNewFile类创建文件
File f1=new File("c:/java123/新建文件.txt");
boolean b= f1.createNewFile();
System.out.println("创建文件成功:"+ b);


//使用mkdir创建单级空文件夹 mkdir可以创建多级空文件夹,单级也行
File f2=new File("C:/java123/新建文件夹");
boolean b1=f2.mkdir();
System.out.println("创建文件夹成功:"+b1);
//多级
File f3=new File("c:/java123/新建多级文件夹/1/2/3");
boolean b3=f3.mkdirs();
System.out.println("创建多级文件夹成功:"+b3);


//list 返回文件下所以文件 及名称 隐藏文件也可以查看
File f4=new File("c:/java123");
String arr[]=f4.list();
for(String fileName:arr) {
System.out.println(fileName);
}

//listFiles
File f5=new File("c:/java123");
File [] files=f5.listFiles();
for(File f:files) {
System.out.println(f);
}

//使用delete删除文件或文件夹
//文件夹中有内容 不会删除返回false 从硬盘中删除 不走回收站,谨慎
/*if(f1.exists()&&f1.isFile()) {
boolean b4=f1.delete();//文件删除
System.out.println("删除成功"+b4);
} */
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package io流;
import java.io.*;
//列出指定目录下的所有java源文件和满足条件的文件
class FileAccept implements FilenameFilter{
String extName="";
FileAccept(String extName){ //构造方法赋值过滤条件
this.extName=extName;
}
public boolean accept(java.io.File file,String fileName) {
return fileName.endsWith(extName);//过滤条件w

}
}


public class MyFile5 {

public static void main(String[] args) {
// TODO 自动生成的方法存根
File dir=new File("c:/java123");
String[] fileNames=dir.list();//返回目录dir中的文件和目录的名称所组成的字符串数组
System.out.println("所有文件数:"+fileNames.length);
for(int i=0;i<fileNames.length;i++) {
System.out.println(fileNames[i]);
}
System.out.println("\n\n");

//
FileAccept con=new FileAccept("mp3");//过滤条件
fileNames=dir.list(con);
System.out.println("所有mp3文件:"+fileNames.length);
for(int i=0;i<fileNames.length;i++) {
System.out.println(fileNames[i]);
}

//

System.out.println("\n\n");
FileAccept con1=new FileAccept("txt");
fileNames=dir.list(con1);
System.out.println("所有txt文件:"+fileNames.length);
for(int i=0;i<fileNames.length;i++) {
System.out.println(fileNames[i]);
}

}
}

流的概念

  • File类不负责文件的读写。Java中文件读写是通过“”的形式完成的。
  • 流是一组有序的数据序列,也称“数据流”。
  • 流是以先进先出的方式完成数据的发送接收
  • 根据数据的流向不同,分为输入流输出流,如果数据的流向是从外设读取到内存中的程序称为“输入流”(Input Stream) ,反之称为输出流( Output Stream )。输入流类名以In开始,输出流类名以Out开始。
  • 输入流: 只能从中读取数据,而不能向其写入数据。
  • 输出流:只能向其写入数据,而不能向其读取数据。

输入输出是相对于计算机而言的,输入in就是进来,进入CPU中,所以是读取,而输出out,是计算机往外输出,就是写。

注:如果从硬盘的角度来考虑,图15.1所示的数据流应该是输入流才对;但划分输入/输出流时是从程序运行所在的内存的角度来考虑的,因此如图15.1所在的流时输出流。而不是输入流。

    对于如图15.2所示的数据流向,数据从服务器通过网络流向客户端,在这种情况下,Server端的内存负责将数据输出到网络里,因此Server端的程序使用输出流;Client端的内存负责从网络中读取数据,因此Client端的程序应该使用输入流。

流的分类

  • 按照数据处理的方式不同,流又可分为字节流字符流。字节流类名以Stream结尾,字符流类名以Reader或Writer结尾。

  • 字节流是指8位的通用字节流,以字节为基本单位处理,适合处理二进制文件(音频文件、图片、歌曲等),对于字节流进行操作的类大部分继承于InputStream(输入字节流)类和OutputStream(输出字节流)类;

  • 字符流是指16位的Unicode字符流,以字符(两个字节)为基本单位处理,非常适合处理字符串和文本,对于字符流进行操作的类大部分继承于Reader(读取流)类和Writer(写入流)类。

  • 字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串

分类 字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 InputStream OutputStream Reader Writer
访问文件 FileInputStream FileOutputStream FileReader FileWriter
访问数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter
访问管道 PipedInputStream PipedOutputStream PipedReader PipedWriter
访问字符串 StringReader StringWriter
缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流 InputStreamReader OutputStreamWriter
对象流 ObjectInputStream ObjectOutputStream
抽象基类 FilterInputStream FilterOutputStream FilterReader FilterWriter
打印流 PrintStream PrintWriter
推回输入流 PushbackInputStream PushbackReader
特殊流 DataInputStream DataOutputStream

注:表中粗体字所标出的类代表节点流,必须直接与指定的物理节点关联:斜体字标出的类代表抽象基类,无法直接创建实例。

字节流

字节流——适于读写二进制文件.
InputStream(字节输入流)OutputStream(字节输出流)是字节流的两个顶层父类,提供了输入流类与输出流类的通用API。

InputStream

InputStream是抽象类,所有字节输入流类都直接或间接继承此类。
字节输入流类很多,使用较多有3个:FileInputStreamBufferedInputStreamDataInputStream
(1)FileInputStream(字节文件输入流):此类用于从本地文件读取内容。
(2)BufferedInputStream:此类本身带有一个缓冲区,在读取数据时,先放到缓冲区中,可以减少对数据源的访问,提高运行的效率。
(3)DataInputStream:此类提供一些基于多字节读取方法,从而可以读取基本数据类型的数据,如,readDouble()、readInt()

在InputStream里面包含如下3个方法:

  • int read(); 从输入流中读取单个字节(相当于从图15.5所示的水管中取出一滴水),返回所读取的字节数据(字节数据可直接转换为int类型)。
  • int read(byte[] b)从输入流中最多读取b.length个字节的数据,并将其存储在字节数组b中,返回实际读取的字节数。
  • int read(byte[] b,int off,int len); 从输入流中最多读取len个字节的数据,并将其存储在数组b中,放入数组b中时,并不是从数组起点开始,而是从off位置开始,返回实际读取的字节数。

    OutputStream

OutputStream是抽象类,所有字节输出流类都直接或间接继承此类。
字节输出流类很多,使用较多有3个:FileOutputStreamBufferedOutputStreamDataOutputStream
(1)FileOutputStream(字节文件输出流):此类用于向本地文件写入数据。
(2)BufferedOutputStream:此类本身带有一个缓冲区,在写取数据时,先放到缓冲区中,实现缓冲的数据流。
(3)DataOutputStream(OutputStream out) :创建一个新的数据输出流,将数据写入指定的基础输出流

提供如下三个方法:

  • void write(int c); 将指定的字节/字符输出到输出流中,其中c即可以代表字节,也可以代表字符。
  • void write(byte[]/char[] buf); 将字节数组/字符数组中的数据输出到指定输出流中。
  • void write(byte[]/char[] buf, int off,int len ); 将字节数组/字符数组中从off位置开始,长度为len的字节/字符输出到输出流中。

字符流

字符流——适于读写文本文件
Reader和Writer是java.io包中的两个字符流类的顶层抽象父类,定义了在I/O流中读写字符数据的通用API。
在Java中,字符采用是16位的Unicode字符编码。常见字符输入/输出流是由Reader和Writer抽象类派生出来的。处理数据时是以字符为基本单位的。

Reader

字符输入流
FileReader:用来读取字符文件的便捷类。
BufferedReader类:是Reader类的子类,为Reader 对象添加字符缓冲器,为数据输入分配内存存储空间,存取数据更为有效。

在Reader中包含如下3个方法:

  • int read(); 从输入流中读取单个字符(相当于从图15.5所示的水管中取出一滴水),返回所读取的字符数据(字节数据可直接转换为int类型)。
  • int read(char[] b)从输入流中最多读取b.length个字符的数据,并将其存储在字节数组b中,返回实际读取的字符数。
  • int read(char[] b,int off,int len); 从输入流中最多读取len个字符的数据,并将其存储在数组b中,放入数组b中时,并不是从数组起点开始,而是从off位置开始,返回实际读取的字符数。

Writer

字符输出流
Writer写入字符类型
字符输出流类很多,使用较多的有:FileWriter、BufferedWriter
(1)FileWriter:用来写入字符文件的便捷类。FileWriter 用于写入字符流。要写入原始字节流。
(2)BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。除非要求提示输出,否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer。

提供如下方法:

  • void write(int c); 将指定的字节/字符输出到输出流中,其中c即可以代表字节,也可以代表字符。
  • void write(byte[]/char[] buf); 将字节数组/字符数组中的数据输出到指定输出流中。
  • void write(byte[]/char[] buf, int off,int len ); 将字节数组/字符数组中从off位置开始,长度为len的字节/字符输出到输出流中。
  • void write(String str); 将str字符串里包含的字符输出到指定输出流中。
  • void write (String str, int off, int len); 将str字符串里面从off位置开始,长度为len的字符输出到指定输出流中。

文件流

FileInputStream

读文件

使用FileInputStream类 读文件
FileInputStream类称为文件输入流,继承于InputStream类,是进行文件读操作的最基本类;
它的作用是将文件中的数据输入到内存中,我们可以利用它来读文件
由于它属于字节流,因此在读取Unicode字符(如中文)的文件时可能会出现问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*编写Java程序,使用FileInputStream读取文件“c:\java123\test.txt”的内容,并输出到控制台。一次读1个字节。*/
package io流;
import java.io.*;
public class FileInputStreamDemo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
try {
File file=new File("C:/java123/test.txt");//创建文件对象
FileInputStream fis=new FileInputStream(file);
//使用文件对象创建文件输入流对象,相对于打开文件
for(int i=0;i<file.length();i++) {
char ch=(char)(fis.read()); //循环读取字符
System.out.println(ch);
}
System.out.println();
fis.close();//关闭流
}catch(FileNotFoundException e) {
System.out.println("文件打开失败");
}catch(IOException e1) {
e1.printStackTrace();
}
}

}

手动创建C:/java123/test.txt文件,test.txt文件里内容为123;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*编写Java程序,使用FileInputStream读取文件“c:\java123\test.txt”的内容,并输出到控制台。读到的数据存放到byte型数组中*/
package io流;
import java.io.*;
public class MyFile1 {
///文件读取 FileInputStream read 方法
public static void main(String[] args) {
// TODO 自动生成的方法存根
try {
File wj=new File("c:/java123/abc.txt"); //创建文件对象
FileInputStream f=new FileInputStream(wj);
/*//单个字节的读取/*
for(int i=0;i<wj.length();i++) {
char ch=(char)f.read();
System.out.print(ch);
} */
//
//
//多个字节读取 字节数组
byte buy[]=new byte[(int)(wj.length())]; //根据文件字节长度创建字节数组
f.read(buy); //读取文件中的数据放入字节数组中
String str=new String(buy); //字节转换成字符
System.out.println(str);
f.close();
//
}catch(FileNotFoundException fnfe) {
System.out.println("文件打开失败");
}catch(IOException e) {
e.printStackTrace();
}
}

}

写文件

使用FileOutputStream类 写文件
FileOutputStream类称为文件输出流,继承于OutputStream类,是进行文件写操作的最基本类;
它的作用是将内存中的数据输出到文件中,我们可以利用它来写文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*编写Java程序,使用FileInputStream写文件“c:\java123\test.txt”。一次写一个字节。*/
package io流;
import java.io.*;
public class FileOutputStreamDemo1 {

public static void main(String[] args) throws IOException{
// TODO Auto-generated method stub
String str="Hello World!";
File file=new File("C:/java123/test.txt");//创建文件对象
//通过文件对象创建文件输出流对象
//附加第二个参数true,指定进行文件追加,默认为不追加
FileOutputStream fos=new FileOutputStream(file,true);

//将逐个字符写入文件中
for(int i=0;i<str.length();i++){
fos.write(str.charAt(i)); //charAt返回指定索引位置的char值
}
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*编写Java程序,使用FileInputStream写文件“c:\java123\test.txt”。一次写一个字节数组。*/
package io流;
import java.io.*;
public class FileOutputStreamDemo2 {
//在函数内部不进行异常处理,将异常抛出函数外部
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String str="I Love Java";
//通过文件名创建文件输出流对象
FileOutputStream fos=new FileOutputStream("C:/java123/test.txt");
byte buffer[]=str.getBytes(); //将字符串转换为字节数组
//将字节数组中包含的数据一次性写入到文件中
fos.write(buffer);
fos.close();
}

}

复制文件

FileInputStream类和FileOutputStream类是成对出现的,一个进行输入(读文件)操作,一个进行输出(写文件)操作;
由于采用字节方式进行数据传输,不必考虑数据的格式问题,这两个类对文件操作的效率较高;
可以使用这两个类完成复制文件的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package io流;

import java.io.*;
//文件的复制
public class MyFile7 {
public static void main(String[] args) throws IOException {
File f=new File("c:/java123/abc.txt");
File destination =new File("c:/java123/abccopy.txt");

try {
//1.创建文件 输入流从系统文件获取字节
FileInputStream fis=new FileInputStream(f);
//2.创建文件输出流将数据写入系统文件
FileOutputStream fos=new FileOutputStream(destination);
///3.保存字节数g
System.out.println("文件长度:"+fis.available()); //返回文件的大小2
//4.输入流读取字节数,并保存到字节数组中
byte []buy=new byte[fis.available()];
//5.将字节数组写入目标文件中
fis.read(buy);
fos.write(buy);
System.out.println("成功复制文本");
//6.最后关闭输入输出流,释放连接资源
fis.close();
fos.close();
} catch (FileNotFoundException e) {
System.out.println("FileNotFoundException");
e.printStackTrace();
} catch (IOException e) {
System.out.println("IOException ");
e.printStackTrace();
}

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package io流;
//*****************图片的复制*****************
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class MyFile8 {

public static void main(String[] args) {

File f=new File("c:/java123/媒体文件夹/图片.jpg");
File destination =new File("c:/java123/图片copy.jpg");
try {
//1.创建文件 输入流从系统文件获取字节
FileInputStream fis=new FileInputStream(f);
//2.创建文件输出流将数据写入系统文件
FileOutputStream fos=new FileOutputStream(destination);
System.out.println("文件大小"+fis.available());
///3.保存字节数
byte[] b=new byte[fis.available()];
//4.输入流读取字节数,并保存到字节数组中
fis.read(b);
//5.将字节数组写入目标文件中
fos.write(b);
System.out.println("成功复制图片");
//6.最后关闭输入输出流,释放连接资源
fis.close();
fos.close();
} catch (FileNotFoundException e) {
System.out.println("FileNotFoundException");
e.printStackTrace();
} catch (IOException e) {
System.out.println("IOException ");
e.printStackTrace();
}

}

}

````
```java
package io流;
//*****************歌曲的复制*****************
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class MyFile9 {

public static void main(String[] args) {

File f=new File("c:/java123/媒体文件夹/歌曲.mp3");
File destination =new File("c:/java123/歌曲copy.mp3");

try {
//1.创建文件 输入流从系统文件获取字节
FileInputStream fis=new FileInputStream(f);
//2.创建文件输出流将数据写入系统文件
FileOutputStream fos=new FileOutputStream(destination);
System.out.println("文件大小"+fis.available());
///3.保存字节数
byte[] b=new byte[fis.available()];
//4.输入流读取字节数,并保存到字节数组中
fis.read(b);
//5.将字节数组写入目标文件中
fos.write(b);
System.out.println("成功复制音频");
//6.最后关闭输入输出流,释放连接资源
fis.close();
fos.close();
} catch (FileNotFoundException e) {
System.out.println("FileNotFoundException");
e.printStackTrace();
} catch (IOException e) {
System.out.println("IOException ");
e.printStackTrace();
}

}

}

FileReader

  • FileReader类称为文件读取流,允许以字符流的形式对文件进行读操作,其构造方法有3种重载方式,以下是常用的几种:

  • 该类将从文件中逐个地读取字符,效率比较低下,因此一般将该类对象包装到缓冲流中进行操作。

BufferedReader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**FileReader配合BufferedReader读文件“c:\java123\test.txt”。逐行读取数据,并在控制台显示。*/
package io流;
import java.io.*;
public class MyFile10 {
//字符流读取 FileReader 中文
public static void main(String[] args)throws IOException {
// TODO 自动生成的方法存根
File f=new File("C:/java123/abc.txt");
//通过文件对象创建文件读取流对象
FileReader fr=new FileReader(f);
//将文件读取流包装成缓冲读取流
BufferedReader br=new BufferedReader(fr);
String str;
while((str=br.readLine())!=null) { //逐行读取数据
System.out.println(str);
}
br.close(); //关流要要反着关
fr.close();
}

}

FileWriter

与FileReader类相似,FileWriter类同样需要使用缓冲流进行包装。

BufferedWriter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*FileWriter配合BufferedWriter写文件“c:\java123\test3.txt”。逐行写数据。*/
package io流;
import java.io.*;
public class WriterDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File f=new File("C:/java123/test.txt");
//通过文件对象创建文件输出字符流对象
FileWriter fw=new FileWriter(f);
//将文件输出字符流包装成缓冲流
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大家好!");
bw.write("我正在学习java");
bw.newLine();
bw.write("请多多指教!");
bw.newLine();
bw.write("Luckybug@21cn.com");
bw.close();
fw.close();
}

}

控制台输入

控制台输入System.in实际上是一个InputStream类的对象;
System.in 的read方法可以从控制台接受输入,它只能以字节形式接收数据,并且一次只能接受一个字节,这使输入操作很不便;
必须将System.in进行处理,才可以顺利地从控制台接受输入,这将使用到:
InputStreamReader
BufferedReader类.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package io流;
import java.io.*;
public class ConsoleInput {

public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
//将System.in转化为字符流对象
InputStreamReader isr=new InputStreamReader(System.in);
//用缓冲流包装
BufferedReader br=new BufferedReader(isr);
System.out.println("请输入你的姓名:");
String name=br.readLine();//接受输入
System.out.println("请输入你的年龄:");
int age=Integer.parseInt(br.readLine());//接受输入
System.out.println("你的姓名:"+name);
System.out.println("你的年龄:"+name);
br.close();
isr.close();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package io流;
/* 通过控制台输入内容写入文件**/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

//写入文件
public class MyFile6 {
public static void main(String[] args) throws IOException {
Scanner sca=new Scanner(System.in);

//写文件
System.out.print("请输入文件名:");
String name=sca.next();
File file=new File(name+".txt");//文件名 相对路径(项目名根目录下)
// FileOutputStream fs=new FileOutputStream(file); //如果文件存在 覆盖
FileOutputStream fos=new FileOutputStream(file,true);//true表示追加,如果文件存在 向里面继续添加内容
System.out.println("请输入写入的内容:");
String str=sca.next();
byte bytes[]=str.getBytes(); //FileOutputStream 是基于字节流 把要写入的信息 保存到字节数组中
fos.write(bytes,0,bytes.length);//将字节数组中全部内容写到文件中 从0—数组的长度
fos.close();//关闭流
System.out.println("文件写入成功!");

//读文件
FileInputStream fis=new FileInputStream(file);
byte bt[]=new byte[1024];//1KB 每次最多读取的1KB 根据文件大小而定
int temp=0;
while((temp=fis.read(bt))!=-1){ //将数据保存到数组(缓冲区)中 并返回读取的字节数 -1表示读完了
System.out.println(new String(bt,0,temp));//输出数组中保存内容 按照每次读取的字节数
}
fis.close();
}
}