本文小编为大家详细介绍“JavaSE IO流常用方法有哪些”，内容详细，步骤清晰，细节处理妥当，希望这篇“JavaSE IO流常用方法有哪些”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
IO流这块知识点碎且杂，但仍然有迹可循。
内容
创建一个字节输入流管道
定义一个字节数组
循环中将字节数组转成字符串打印出来
代码
//1.直接创建一个字节输入流管道和源文件对接接通
InputStream is = new FileInputStream("Day09Demo/src/dilei02.txt");
//2.必须使用循环，但是还是无法解决中文乱码的问题
//a.定义一个字节数组代表桶
byte[] buffer = new byte[3];
int len;//存储每次读取的字节数
//3.循环，括号以及等号右边有优先级，因此is.read(buffer)拿到桶后装三滴水，返回3然后判断不等于-1
while ((len = is.read(buffer))!=-1){
//读多少倒多少！
String rs = new String(buffer,0,len);
System.out.print(rs);//不用换行
}内容
写一个字节
写一个字节数组
写部分字节数组
追加管道
关闭管道
代码
//1.创建一个字节输出流管道与目标文件接通，默认是数据覆盖管道
//追加数据管道，可以追加数据，原来数据不清掉
//OutputStream os = new FileOutputStream("Day09Demo/src/dilei04.txt",true);
OutputStream os = new FileOutputStream("Day09Demo/src/dilei04.txt");//不用自己再建文件，因为源码中已经有创建文件
//2.写一个字节出去(写一滴水出去)
os.write(97);//字节a
os.write('b');//字节b
//os.write('芬');//只会写出中文的第一个字节，写出去就是乱码了！
os.write("\r\n".getBytes());//加了\r是在哪个系统都可以换行
//3.写一个字节数组出去(写一个桶出去)
byte[] bytes = new byte[]{34,54,65,76,87,6,54};//写了一堆字节
os.write(bytes);
byte[] bytes1 = "Java是最优美的语言".getBytes();//直接拿字符串调getbytes得到字节，默认以当前编码UTF-8提取
System.out.println(bytes1.length);//看看长度
os.write(bytes1);
os.write("\r\n".getBytes());//换行
//4.写一个字节数组的一部分出去
byte[] bytes2 = "Java是最优美的语言".getBytes();
os.write(bytes2,0,19);
os.write("\r\n".getBytes());//换行
//6.刷新或者关闭下
os.flush();//立即刷新数据到文件中去，刷新后管道可以继续使用
os.close();//记得关闭资源管道，关闭包含了刷新，关闭后管道不能使用了内容：一半字节流用来做文件复制的多，因为读写文件难避免中文字符出现乱码的情况
建两根输入流和输出流管道
循环先读后写
捕获下异常
代码
public static void main(String[] args) {
//try后面小括号放置资源对象，用完会自动调用close关闭，省的finally里面写了
try(//相当于常量，只能给一次初始值
//1.创建一个字节输入流管道和源文件接通
InputStream is = new FileInputStream("C:\\Users\\CZyue\\Desktop\\壁纸\\girl.jpg");
//2.创建一个字节输出流与目标文件接通
OutputStream os = new FileOutputStream("C:\\Users\\CZyue\\Desktop\\littlegirl.jpg");
)
{
//3.创建一个字节数组作为桶
byte[] butter = new byte[1024];
//4.从字节输入流读取数据，写到字节输出流管道即可
//定义一个变量存储每次桶读取的字节数
int len;
while ((len = is.read(butter))!=-1){
//读取多少就倒出多少
os.write(butter,0,len);
}
System.out.println("复制完成！！");
}catch (Exception e){
e.printStackTrace();
}
}内容
和字节输入流差不多，把字节byte换成字符char即可
代码
//1.创建一个字符输入流管道与源文件路径接通
Reader fr = new FileReader("Day10Demo\\src\\dilei01.txt");
//2.使用循环读取
char[] chars = new char[1024];
//定义一个整数记录每次桶读取的字符数据量
int len = 0;
while((len = fr.read(chars))!=-1){
//读多少倒出多少
System.out.print(new String(chars,0,len));
}内容：
和字节输出流差不多，字符可以随意输出啦
代码
//1.创建字符输出流管道通向目标文件路径
//追加数据管道，表示不会清空数据
//Writer fw = new FileWriter("Day10Demo\\src\\dilei03.txt",true);
Writer fw = new FileWriter("Day10Demo\\src\\dilei03.txt");
//2.写一个字符出去： public void write(int a)/public void write(String c)
fw.write(97);//字符a
fw.write(98);//字符a
fw.write('芬');//字符芬
fw.write("\r\n");//换行
//3.写一个字符串出去：
fw.write("Java是最优美的语言");
fw.write("\r\n");//换行
//4.写一个字符数据数据出去：public void write(char[] butter)
fw.write("我爱中国".toCharArray());//打印成字符数组
fw.write("\r\n");//换行
//5.写字符串一部分出去：public void write(String c,int pos,int len)
fw.write("Java是最优美的语言",0,9);
fw.write("\r\n");//换行
//6.写字符数组的一部分出去
fw.write("我爱中国".toCharArray(),0,2);
fw.write("\r\n");//换行
fw.close();内容：
new 一个字节缓冲输入流，然后将原来的字节输入流对象丢进去
代码
public static void main(String[] args) throws Exception {
//1.定义一个低级的字节输入流与源文件接通
InputStream is = new FileInputStream("Day10Demo\\src\\dilei03.txt");
//2.把低级的字节输入流包装成一个高级的缓冲字节输入流，多了个缓冲池
BufferedInputStream bis = new BufferedInputStream(is);
//3.定义一个字节数组按照循环读取
byte[] buffer = new byte[3];
int len;
while((len=bis.read(buffer))!=-1){
String rs = new String(buffer,0,len);
System.out.println(rs);
}
}内容
new 一个字节缓冲输出流，然后将原来的字节输出流对象丢进去
代码
public static void main(String[] args) throws Exception {
//1.写一个原始的字节输出流
OutputStream os = new FileOutputStream("Day10Demo\\src\\dilei05.txt");
BufferedOutputStream bos = new BufferedOutputStream(os);
//2.写数据出去
bos.write('a');
bos.write(100);
bos.write("我爱中国".getBytes());
bos.close();
}内容：分别比较四种字节流的复制性能
使用一般的字节流一个一个字节形式的复制文件
使用一般的字节流一个一个字节数组形式的复制文件
使用高级的缓冲字节流一个一个字节形式的复制文件
使用高级的缓冲字节流一个一个字节数组形式的复制文件
代码
public class CopyDemo {
public static final String SRC_FILE="C:\\Users\\CZyue\\Desktop\\04_问题答疑.vip";
public static final String DEST_FILE="C:\\Users\\CZyue\\Desktop\\Hadoop\\";
public static void main(String[] args) {
//一般的字节流一个一个字节形式的复制文件耗时141.218s
//一般流一个一个字节复制，速度跟蜗牛有的一拼，直接淘汰，静止使用！
copy01();
//一般的字节流一个一个字节数组的复制文件耗时0.312s,速度较慢
copy02();
//高级的字节缓冲流一个一个字节形式的复制文件耗时0.309s，速度较慢
copy03();
//高级的字节缓冲流一个一个字节数组的复制文件耗时0.186s，速度极快，这流可以处！
copy04();
}
//1.使用一般的字节流一个一个字节形式的复制文件
public static void copy01(){
long startTimer = System.currentTimeMillis();
try{
//1.创建一个一般字节输入流与源文件接通
InputStream is = new FileInputStream(SRC_FILE);
//2.创建一个一般的字节输出流和目标文件接通
FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test1.vip");
//3.定义一个整形变量存储读取的字节
int ch;
while ((ch = is.read())!=-1){
os.write(ch);
}
long endTimer = System.currentTimeMillis();
System.out.println("一般的字节流一个一个字节形式的复制文件耗时"+(endTimer-startTimer)/1000.0);
}catch (Exception e){
e.printStackTrace();
}
}
//2.使用一般的字节流一个一个字节数组形式的复制文件
public static void copy02(){
long startTimer = System.currentTimeMillis();
try{
//1.创建一个一般字节输入流与源文件接通
InputStream is = new FileInputStream(SRC_FILE);
//2.创建一个一般的字节输出流和目标文件接通
FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test2.vip");
//3.定义一个字节数组存储字节
byte[] butter = new byte[1024];//1KB
//定义一个变量存储每次读取的字节数量
int len;
while ((len=is.read(butter))!=-1){
os.write(butter,0,len);
}
long endTimer = System.currentTimeMillis();
System.out.println("一般的字节流一个一个字节数组的复制文件耗时"+(endTimer-startTimer)/1000.0);
}catch (Exception e){
e.printStackTrace();
}
}
//3.使用高级的缓冲字节流一个一个字节形式的复制文件
public static void copy03(){
long startTimer = System.currentTimeMillis();
try{
//1.创建一个高级字节输入流与源文件接通
InputStream is = new FileInputStream(SRC_FILE);
BufferedInputStream bis = new BufferedInputStream(is);
//2.创建一个高级的字节输出流和目标文件接通
FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test3.vip");
BufferedOutputStream bos = new BufferedOutputStream(os);
//3.定义一个整形变量存储读取的字节
int ch;
while ((ch = bis.read())!=-1){
bos.write(ch);
}
long endTimer = System.currentTimeMillis();
System.out.println("高级的字节缓冲流一个一个字节形式的复制文件耗时"+(endTimer-startTimer)/1000.0);
}catch (Exception e){
e.printStackTrace();
}
}
//4.使用高级的缓冲字节流一个一个字节数组形式的复制文件
public static void copy04(){
long startTimer = System.currentTimeMillis();
try{
//1.创建一个低级字节输入流与源文件接通
InputStream is = new FileInputStream(SRC_FILE);
BufferedInputStream bis = new BufferedInputStream(is);
//2.创建一个低级的字节输出流和目标文件接通
FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test4.vip");
BufferedOutputStream bos = new BufferedOutputStream(os);
//3.定义一个字节数组存储字节
byte[] butter = new byte[1024];//1KB
//定义一个变量存储每次读取的字节数量
int len;
while ((len=is.read(butter))!=-1){
os.write(butter,0,len);
}
long endTimer = System.currentTimeMillis();
System.out.println("高级的字节缓冲流一个一个字节数组的复制文件耗时"+(endTimer-startTimer)/1000.0);
}catch (Exception e){
e.printStackTrace();
}
}内容
使用readLine()的方法：public String readLine()读取一行数据返回，读取完毕返回null
代码
public static void main(String[] args) throws Exception {
//1.定义一个原始的一般的字符输入流
Reader fr = new FileReader("Day10Demo\\src\\dilei06.txt");
//2.把一般的字符输入流包装成高级的字符缓冲输入流管道
BufferedReader br = new BufferedReader(fr);
//3.定义一个字符串变量存储每一行数据
String line;
//使用一个循环读取数据(经典代码)
while ((line = br.readLine())!=null){//有时候业务需要一行一行读
System.out.print(line);
}
br.close();//代码少直接close，规范的应该try的小括号关闭，这边简略些
}内容:同字符缓冲流，new一个BufferedWriter，然后把字符输出流对象丢进去
代码
public static void main(String[] args) throws Exception {
//1.定义一个一般的字符输出流写数据出去
//如果要追加，还是只能在原来的一般的字符输出流中操作
//Writer fw = new FileWriter("Day10Demo\\src\\dilei07.txt",true);
Writer fw = new FileWriter("Day10Demo\\src\\dilei07.txt");
//2.把一般的低级的字符输出流包装成高级的字符缓冲输出流管道
BufferedWriter bw = new BufferedWriter(fw);
//3.写字符输出,使用newLine()作为换行符
bw.write("学习IO流中~~");
bw.newLine();
//bw.write("\r\n");newLine就替代了这个呢
bw.write("今天Javase要全部结束啦，真棒！！！");
bw.close();
}内容：可以把原始的字节流按照指定编码转换成字符输入流
代码
public static void main(String[] args) throws Exception {
//代码：UTF-8 文件：GBK
//1.提取GBK文件的原始字节流
InputStream is = new FileInputStream("C:\\Users\\CZyue\\Desktop\\试试看.txt");
//2.把原始字节输入流通过转换流，转换成字符输入转换流InputStreamReader
//Reader isr = new InputStreamReader(is);//默认UTF-8
Reader isr = new InputStreamReader(is,"GBK");//默认UTF-8
//3.包装成缓冲流
BufferedReader br = new BufferedReader(isr);
//4.打印出来看看
String line;
while ((line=br.readLine())!=null){
System.out.println(line);
}
}内容：可以把原始的字节流按照指定编码转换成字符输出流
代码
public static void main(String[] args) throws Exception {
//1.创建一个一般的字节输出流
OutputStream os = new FileOutputStream("Day10Demo\\src\\dilei07.txt");
//2.把字节输出流包装成字符输出流
//Writer osw = new OutputStreamWriter(os);//默认编码字节输出流转换成字符输出流
Writer osw = new OutputStreamWriter(os,"GBK");//按照GBK编码字节输出流转换成字符输出流
//3.写看看
osw.write("abc我是中国人");
osw.close();
}内容：可以实现打印啥出去，就是啥出去
代码
public static void main(String[] args) throws Exception {
//1.打印流PrintStream
// OutputStream os = new FileOutputStream("Day10Demo\\src\\dilei08.txt");
// PrintStream ps = new PrintStream(os);
//2.可以直接打印流通向文件路径，以及两者PrintStream和PrintWriter可以混用
PrintStream ps = new PrintStream("Day10Demo\\src\\dilei08.txt");
PrintWriter pw = new PrintWriter("Day10Demo\\src\\dilei08.txt");//可以直接通向文件，但是默认覆盖了
//3.注意：不能丢给缓冲流，因为打印流底层基于缓冲流了，这流很厉害！
//4.打印看看
ps.println(97);//可以打印各种数据，写啥打啥，这边97不是字母了，直接就是97
ps.println(99.8);
ps.println(false);
ps.println('芬');
ps.close();
}内容：数据会流向打印流，打印流会流向文件
代码
public static void main(String[] args) throws Exception {
/1./这个流向控制台
System.out.println("=====java0========");
//2.即下面的内容会流向打印流，打印流会流向文件
PrintStream ps = new PrintStream("Day10Demo\\src\\log.txt");
System.setOut(ps);//让系统的输出流向打印流，java提供的静态方法
System.out.println("=====java1========");
System.out.println("=====java2========");
System.out.println("=====java3========");
System.out.println("=====java4========");读到这里，这篇“JavaSE IO流常用方法有哪些”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
