java中的IO整理（4）

最新推荐文章于 2024-07-25 14:31:34 发布
最新推荐文章于 2024-07-25 14:31:34 发布
阅读量72 收藏
点赞数
分类专栏： java 文章标签： java 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ws04170099/article/details/84459371
版权
打印流

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
  * 使用PrintStream进行输出
  * */
import  java.io.*;
 
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         PrintStream print = new  PrintStream( new  FileOutputStream( new  File( "d:"
                 + File.separator + "hello.txt" )));
         print.println( true );
         print.println( "Rollen" );
         print.close();
     }
}

 

 

【运行结果】：

 

true

 

Rollen

 

当然也可以格式化输出

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 使用PrintStream进行输出
  * 并进行格式化
  * */
import  java.io.*;
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         PrintStream print = new  PrintStream( new  FileOutputStream( new  File( "d:"
                 + File.separator + "hello.txt" )));
         String name= "Rollen" ;
         int  age= 20 ;
         print.printf( "姓名：%s. 年龄：%d." ,name,age);
         print.close();
     }
}

 

 

【运行结果】：

 

姓名：Rollen. 年龄：20.

 

 

 

使用OutputStream向屏幕上输出内容

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
  * 使用OutputStream向屏幕上输出内容
  * */
import  java.io.*;
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         OutputStream out=System.out;
         try {
             out.write( "hello" .getBytes());
         } catch  (Exception e) {
             e.printStackTrace();
         }
         try {
             out.close();
         } catch  (Exception e) {
             e.printStackTrace();
         }
     }
}

 

 

【运行结果】：

 

hello

 

 

 

输入输出重定向

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.PrintStream;
 
/**
  * 为System.out.println()重定向输出
  * */
public  class  systemDemo{
     public  static  void  main(String[] args){
         // 此刻直接输出到屏幕
         System.out.println( "hello" );
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         try {
             System.setOut( new  PrintStream( new  FileOutputStream(file)));
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         System.out.println( "这些内容在文件中才能看到哦！" );
     }
}

 

 

【运行结果】：

eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.PrintStream;
 
/**
  * System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息
  * */
public  class  systemErr{
     public  static  void  main(String[] args){
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         System.err.println( "这些在控制台输出" );
         try {
             System.setErr( new  PrintStream( new  FileOutputStream(file)));
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         System.err.println( "这些在文件中才能看到哦！" );
     }
}

 

 

【运行结果】：

 

你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！

 

 

?
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
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileNotFoundException;
import  java.io.IOException;
 
/**
  * System.in重定向
  * */
public  class  systemIn{
     public  static  void  main(String[] args){
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         if (!file.exists()){
             return ;
         } else {
             try {
                 System.setIn( new  FileInputStream(file));
             } catch (FileNotFoundException e){
                 e.printStackTrace();
             }
             byte [] bytes = new  byte [ 1024 ];
             int  len = 0 ;
             try {
                 len = System.in.read(bytes);
             } catch (IOException e){
                 e.printStackTrace();
             }
             System.out.println( "读入的内容为："  + new  String(bytes, 0 , len));
         }
     }
}

 

 

【运行结果】：

 

前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！

 

 

 

BufferedReader的小例子

 

注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：

 

 

?
BufferedReader buf = new  BufferedReader(
                 new  InputStreamReader(System.in));

 

 

下面给一个实例：

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.BufferedReader;
import  java.io.IOException;
import  java.io.InputStreamReader;
 
/**
  * 使用缓冲区从键盘上读入内容
  * */
public  class  BufferedReaderDemo{
     public  static  void  main(String[] args){
         BufferedReader buf = new  BufferedReader(
                 new  InputStreamReader(System.in));
         String str = null ;
         System.out.println( "请输入内容" );
         try {
             str = buf.readLine();
         } catch (IOException e){
             e.printStackTrace();
         }
         System.out.println( "你输入的内容是："  + str);
     }
}

 

 

运行结果：

 

请输入内容

 

dasdas

 

你输入的内容是：dasdas

 

 

 

Scanner类

 

其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  java.util.Scanner;
 
/**
  * Scanner的小例子，从键盘读数据
  * */
public  class  ScannerDemo{
     public  static  void  main(String[] args){
         Scanner sca = new  Scanner(System.in);
         // 读一个整数
         int  temp = sca.nextInt();
         System.out.println(temp);
         //读取浮点数
         float  flo=sca.nextFloat();
         System.out.println(flo);
         //读取字符
         //...等等的，都是一些太基础的，就不师范了。
     }
}

 

其实Scanner可以接受任何的输入流

 

下面给一个使用Scanner类从文件中读出内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.util.Scanner;
 
/**
  * Scanner的小例子，从文件中读内容
  * */
public  class  ScannerDemo{
     public  static  void  main(String[] args){
 
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         Scanner sca = null ;
         try {
             sca = new  Scanner(file);
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         String str = sca.next();
         System.out.println( "从文件中读取的内容是："  + str);
     }
}

 

【运行结果】：

 

从文件中读取的内容是：这些文件中的内容哦！

 

数据操作流DataOutputStream、DataInputStream类

 

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import  java.io.DataOutputStream;
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
 
public  class  DataOutputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         char [] ch = { 'A' , 'B' , 'C'  };
         DataOutputStream out = null ;
         out = new  DataOutputStream( new  FileOutputStream(file));
         for ( char  temp : ch){
             out.writeChar(temp);
         }
         out.close();
     }
}

 

 

A B C

 

现在我们在上面例子的基础上，使用DataInputStream读出内容

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  java.io.DataInputStream;
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.IOException;
 
public  class  DataOutputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         DataInputStream input = new  DataInputStream( new  FileInputStream(file));
         char [] ch = new  char [ 10 ];
         int  count = 0 ;
         char  temp;
         while ((temp = input.readChar()) != 'C' ){
             ch[count++] = temp;
         }
         System.out.println(ch);
     }
}

 

 

【运行结果】：

 

AB

 

合并流 SequenceInputStream

 

SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：

 

 

?
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
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  java.io.SequenceInputStream;
 
/**
  * 将两个文本文件合并为另外一个文本文件
  * */
public  class  SequenceInputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file1 = new  File( "d:"  + File.separator + "hello1.txt" );
         File file2 = new  File( "d:"  + File.separator + "hello2.txt" );
         File file3 = new  File( "d:"  + File.separator + "hello.txt" );
         InputStream input1 = new  FileInputStream(file1);
         InputStream input2 = new  FileInputStream(file2);
         OutputStream output = new  FileOutputStream(file3);
         // 合并流
         SequenceInputStream sis = new  SequenceInputStream(input1, input2);
         int  temp = 0 ;
         while ((temp = sis.read()) != - 1 ){
             output.write(temp);
         }
         input1.close();
         input2.close();
         output.close();
         sis.close();
     }
}

 

 

【运行结果】

 

结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。

 

转自：http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html

ws04170099
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中的IO整理完整版
04-14
以下是对Java IO的详细整理： 首先，Java中的`File`类是操作文件和目录的基础，它提供了许多方法来创建、删除、重命名文件以及检查文件属性。在案例1中，通过`new File("D:\\hello.txt")`创建了一个`File`对象，...
socket.io 与 ws对比
热门推荐
chenguohong88的博客
08-02 1万+
node.js的websocket库目前比较热门的是ws和socket.io。我们对比一下这两个库。 一、 笔者写这篇文章时，ws的周下载量是4百多万，最近一次更新是11天前，总共98个版本。 socket.io周下载量接近2百万，最近一次更新是三个月前。总共110个版本 从npm上看，使用ws的比socket.io多很多，活跃度差不多。 二、 ws客户端不支持浏览器，需要用户...
Java中IO流简介_动力节点Java学院整理
08-30
IO流是Java中一个基本概念，理解IO流是Java开发中的一项重要技能。下面将对Java IO流进行详细的介绍。 什么是流 所谓“流”，就是一种抽象的数据的总称，它的本质是能够进行传输。流可以按照数据流向和处理数据的...
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
Java IO复用_动力节点Java学院整理
08-30
在实际应用中，Java可以通过Java NIO（Non-blocking I/O）库来实现IO复用，NIO的Selector类对应于epoll的概念，可以注册多个Channel（对应于文件描述符），并在有事件发生时唤醒，从而实现高效的并发处理。...
java中的IO流整理
05-11
Java中的IO流是Java平台核心特性之一，它用于在各种数据源之间传输数据，包括文件、设备、网络连接等。IO流分为输入流（Input Stream）和输出流（Output Stream），按照处理的数据类型又可以分为字节流和字符流。本...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1203
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 494
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 794
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 270
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2151
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1352
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 1002
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 237
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 856
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
学习笔记---java篇（0723）
m0_70630166的博客
07-23 770
java、数据类型、循环、选择等
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 726
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 203
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
19.jdk源码阅读之FutureTask
最新发布
前端、移动端、后端源码级底层原理分享
07-25 544
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
java基础中IO知识点的整理
06-01
好的，关于Java IO的知识点整理如下： 一、IO流的分类 1.按数据流向：输入流、输出流 2.按操作单元：字节流、字符流 3.按角色：节点流、处理流 二、字节流和字符流的区别 1.字节流操作的是8位字节，适用于二进制文件，如图片、音频、视频等； 2.字符流操作的是16位字符，适用于文本文件，如txt、html、xml等； 三、节点流和处理流的区别 1.节点流直接与数据源相连，读写数据源； 2.处理流不直接与数据源相连，通过节点流读写数据源，对读写过程进行包装，提供更高层次的操作。 四、File类 1.可以用来表示文件或目录 2.常用方法：创建文件、创建目录、删除文件、删除目录、判断是否存在、获取文件名、获取绝对路径等。 五、InputStream和OutputStream 1.InputStream是字节输入流的抽象类，常用方法：read()、available()、close()； 2.OutputStream是字节输出流的抽象类，常用方法：write()、flush()、close()； 六、Reader和Writer 1.Reader是字符输入流的抽象类，常用方法：read()、ready()、close()； 2.Writer是字符输出流的抽象类，常用方法：write()、flush()、close()； 七、字节流与字符流的转换 1.InputStreamReader：将字节流转换成字符流； 2.OutputStreamWriter：将字符流转换成字节流。 以上是Java IO的基础知识点，希望能对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值