Java基础之IO技术(一)

---恢复内容开始---

  Java基础中的IO技术可谓是非常重要,俗话说的好,万丈高楼起于垒土之间。所以学习Java一定要把基础学好,今天我们来学习IO技术的基础。

  IO无非就是输入与输出,而其中处理的数据无非是字符与字节。字符最简单的定义就是这个数据是否是纯文本组成,除此之外所有的都是字节。Java给我们提供了字符和字节的处理,其中字符的处理有Writer和Reader两个抽象父类(分别对应的是写和读),字节的处理有OutputStream和InputStream两个抽象类(分别对应的是写和读)。今天我们就看看字符的处理。

  字符的处理

  1.字符的读(FileReader)

  首先请看一段代码:

 1 import java.io.*;
 2
 3 public class FileReader1 {
 4     public static void main(String[] args){
 5         FileReader fr = null;
 6         try{
 7             fr = new FileReader("1.txt");
 8             int ch = 0;
 9             //read():字符读取,如果已经达到流的结尾,则为-1
10             //这个可以作为读取文件结束的条件
11             while((ch = fr.read()) != -1){
12                 //进行强制转换
13                 System.out.print((char)ch);
14             }
15             sop("读取结束");
16
17         }catch(FileNotFoundException e){
18             sop(e.toString());
19         }catch(IOException e){
20             sop(e.toString());
21         }finally{
22             try {
23                 if(fr != null) {
24                     fr.close();
25                 }
26             }catch(IOException e){
27                 sop(e.toString());
28             }
29         }
30     }
31     public static void sop(Object obj){
32         System.out.println(obj);
33     }
34 }

  这是文件读取的第一种方法,这种方法是将文件中的数据一个一个的读出来,这样操作比较耗资源,因此有了第二种读取方法,请看下面这段代码。

 1 import java.io.*;
 2
 3 public class FileReader2 {
 4     public static void main(String[] args){
 5         FileReader fr = null;
 6         try{
 7             fr = new FileReader("1.txt");
 8             //read(char[] cbuf):将字符读取到数组中
 9             //这个数组大小1024整数倍
10             char[] buff = new char[1024];
11             int num = 0;
12             while((num = fr.read(buff)) != -1){
13                 sop(new String(buff, 0, num));
14             }
15
16         }catch(FileNotFoundException e){
17             sop(e.toString());
18         }catch(IOException e){
19             sop(e.toString());
20         }finally{
21             try{
22                 if(fr != null) {
23                     fr.close();
24                 }
25             }catch(IOException e){
26                 sop(e.toString());
27             }
28         }
29
30     }
31     public static void sop(Object obj){
32         System.out.println(obj);
33     }
34 }

  这种方法是利用一个数组(这个数组大小一般定义为1024的整数倍),将文件中的数据传入到一个数组中,然后将数组中的数据一次性的处理。显而易见这种方法更好。

  文件打开是需要关闭的,通过close方法。

  2.字符的写(FileWriter)

  首先请看下面一段代码

 1 import java.io.*;
 2
 3 public class FileWriterDemo {
 4     public static void main(String[] args){
 5         fileWriter();
 6
 7     }
 8     public static void fileWriter(){
 9         FileWriter fw = null;
10         try {
11             fw = new FileWriter("1.txt");
12
13             fw.write("asdsadasdafd");
14             fw.flush();
15
16             fw.append("\n"+123);
17             fw.flush();
18
19         }catch(IOException e){
20             sop(e.toString());
21         }finally{
22             try{
23                 if(fw != null) {
24                     fw.close();
25                 }
26             }catch(IOException e){
27                 sop(e.toString());
28             }
29         }
30     }
31     public static void sop(Object obj){
32         System.out.println(obj);
33     }
34 }

  首先对象的创立,有多个构造函数。这里我介绍两种,FileWriter(String fileName)和FileWriter(String fileName, boolean append)。在第二个构造函数中有一个布尔型参数,为false就和第一个构造函数一样,每次向目的地中写入数据时都会覆盖原来的数据,若不想覆盖原来的数据,可以使用append方法;为true时,就不会覆盖原来的数据,而是在原数据后面追加数据。

  文件的写入是通过一个缓冲区(为了解决cpu和硬盘速度并不匹配的问题),因此在写入一段数据后,要通过flush方法刷新缓冲区,将数据送到目的地中(文件)。最后通过close方法关闭资源,在关闭之前也会刷新缓冲区。每次向目的地写入数据时,都会检测是否有目的文件,若没有则创建一个。

  为提高数据的读写效率,Java中提供了缓冲技术,对原来的FileWriter与FileReader进行修饰,其中涉及到了修饰设计模式,这里就不具体讲解。下面就对缓冲技术进行讲解。

  3.修饰后的写(BufferedWriter)

  我们还是来看看具体代码

 1 import java.io.*;
 2
 3 public class BufferedWriterDemo {
 4     public static void main(String[] args){
 5         //创建一个字符写入流对象
 6         FileWriter fw = null;
 7         BufferedWriter bw = null;
 8         try{
 9             fw = new FileWriter("2.txt", true);
10             //为提高字符写入的流效率,加入了缓冲技术。
11             //只要将需要提高效率的流对象作为参数传递给缓冲区的构造函数
12             bw = new BufferedWriter(fw);
13             for(int i=0; i<5; i++) {
14                 bw.write("sdadadas"+i);
15                 bw.newLine();
16             }
17             //记住,只要用到缓冲区就要刷新
18             bw.flush();
19
20         }catch(IOException e){
21             sop(e.toString());
22
23         }finally {
24             try{
25                 //其实关闭缓冲区,就是在关闭与缓冲区关联的流对象
26                 bw.close();
27             }catch(IOException e){
28                 sop(e.toString());
29             }
30         }
31
32
33     }
34     private static void sop(Object obj){
35         System.out.println(obj);
36     }
37 }

  这一段知识尽在代码与注释中。其中有一个newLine方法,让我们看看1.8api中解释(写一行行分隔符。 行分隔符字符串由系统属性line.separator定义,并不一定是单个换行符(‘\ n‘)字符)。在不同系统中,换行符都不同。而使用了这个方法后,同样的代码不会在不同的系统中出现乱码的问题。

  最后的close方法,有一个疑问(到底是使用流对象的close方法还是使用缓冲技术的close方法呢),首先我们回到一开始,缓冲技术是用来修饰流操作的,必然他们操作的是流。因此使用其中任何一个close方法都会关闭这个流资源。

  4.修饰后的读(BufferedReader)

  请看下一段代码

 1 import java.io.*;
 2
 3 public class BufferedReaderDemo {
 4     public static void main(String[] args){
 5         FileReader fr = null;
 6         BufferedReader br = null;
 7         try{
 8             //创建一个读取流对象并与文件关联
 9             fr = new FileReader("2.txt");
10             //为了提高效率,加入了缓冲区技术。将字符读取流对象作为参数传入到缓冲对象的构造函数
11             br = new BufferedReader(fr);
12
13             String line = null;
14             while((line = br.readLine()) != null){
15                 sop(line);
16             }
17
18         }catch(FileNotFoundException e){
19             sop(e.toString());
20         }catch(IOException e){
21             sop(e.toString());
22         }finally {
23             try{
24                 if(br != null){
25                     br.close();
26                 }
27             }catch(IOException e){
28                 sop(e.toString());
29             }
30         }
31     }
32
33     private static void sop(Object obj){
34         System.out.println(obj);
35     }
36 }

  

  这段知识的原理和上一段的知识类似,就不做具体的解释了。就说说其中的readLine方法,我们来看看api文档,public String readLine(),(读一行文字。 一行被视为由换行符(‘\ n‘),回车符(‘\ r‘)中的任何一个或随后的换行符终止),也就是说把文件中的一行数据读取出来。

  我们总结一下字符的体系

 1 /**
 2  * 读:
 3  *      Reader
 4  *          |--FileReader(两种读的方法,资源的关闭)
 5  *          |--BufferedReader(修饰设计模式,高效的处理方式,readLine方法,close方法关闭资源)
 6  *
 7  * 写:
 8  *      Writer
 9  *          |--FileWriter(两种构造方法,write方法与append方法,)
10  *          |--BufferedWriter(修饰设计模式,高效的处理方式,newLine方法,close方法关闭资源)
11  *
12  *
13  * */

  今天只讲解了字符的操作,关于字节的操作和其他IO的基础知识,在后面会相应的推出。

---恢复内容结束---

原文地址:https://www.cnblogs.com/dx520/p/10303104.html

时间: 2024-10-13 01:25:07

Java基础之IO技术(一)的相关文章

java基础篇IO流的规律

前两篇降了IO流中的字节流和字符流复制的例子,今天来总结一下IO流的规律 掌握好IO流的规律,再开发中会很好用 下面来总结一下: 1,明确源和目的 源:输入流 InputStream 和Reader 目的:输出流 OutputStream 和Writer 2,操作的数据是否是纯文本. 是:使用字符流 不是:使用字节流 3,当体系明确后,在明确要使用哪个具体的对象,通过设备来进行区分 源设备: 内存,硬盘,键盘 目的设备: 内存,硬盘,控制台 这里的源就是你想进行的操作,比如说你想从c盘复制一个文

java基础之IO

java基础之IO 1,字节流与字符流常用方法: public class testIO { /** * 字符输入输出流实现文件的复制(类比字节操作) * @throws IOException * */ @Test public void testWriterReaderFileCopy() throws IOException{ Reader read = new FileReader("cyq1.txt"); Writer write = new FileWriter("

JAVA 基础之 IO复习

一.文件: 在IO包中唯一与文件相关的类就是 File类. File类中常用的常量和方法 1.创建文件: 指定路径和将要创建的文件名字以及类型: 然后调用 createNewFile()方法 File file = new File("D:"+File.separator+"MyJavaProgram"+File.separator+"hello.java"); file.createNewFile(); 2.删除文件: 指定路径和文件,包括类型

Java基础: IO操作

最近抽了点时间回顾了java基础,昨天看了java的IO操作,把大致的总结写在这里. Java的IO操作主要是数据的输入.输出操作和文件管理,输入输出操作可以包括控制台.文件的输入输出和流的输入输出,流的输入输出可以用于文件,也可以用于网络数据. 控制台 控制台的输入输出中,输出大家最熟悉,最常用的就是System.out,那么输入操作可以用System.in,也可以System.console,区别是前者读入字节,后者读入字符串 文件处理 File类:可以实现对文件目录和文件的增删改,查看文件

java基础之IO流(一)

java基础之IO流(一)之字节流 IO流体系太大,涉及到的各种流对象,我觉得很有必要总结一下. 那什么是IO流,IO代表Input.Output,而流就是原始数据源与目标媒介的数据传输的一种抽象.典型数据源与目标媒介包括磁盘.网络.内存等等. IO流的分类: 按流向分为:输入流和输出流(本地内存为参考) 按处理数据单位:字符流和字节流 按照是否与特定的地方相连(磁盘.网络.内存):节点流和处理流 节点流:可以从或向一个特定的地方(节点)读写数据. 处理流:是对一个已存在的流的连接和封装,通过所

Java基础总结--IO总结2

1.键盘录入--Java具有特定的对象封装这些输入输出设备在System类定义 in-InputStream类型和out-PrintStream类型成员变量阻塞是方法:read()无数据就阻塞windows里面回车键对于两个字节\r-13\n-10从系统获得流对象只有一个,所以别关流InputStream in = System.in(调用的是系统的流,在Java中被定义为该中类型)不要进行关闭,因为关闭的是系统的流否则会用不了.StingBulider/StringBuffer清空用的是del

java基础之IO操作

IO操作 ·文件类的使用(File) ·IO中流的基本使用(字符流.字节流.内存流.打印流) ·System类对IO的支持 ·对象序列化的问题 在整个的IO操作中,流的操作分为两种: ·字节流 字节输出流:OutputStream 字节输入流:InputStream ·字符流 字符输出流:Writer 字符输入流:Reader IO操作的基本步骤: 在Java的使用io的话,必须要按照以下的几个步骤进行(对文件操作来说): ·使用File找到一个文件 ·使用字节流或者字符流的子类为OutputS

java基础54 IO流技术(转换流)

1.转换流 1.输入字节的转换流:InputStreamReader是字节流转为字符流的桥梁,可以把输入字节流转换为输入字符流    2.输出字节流的转换流:OutputStreamWriter是字符流通向字节流的桥梁(相对于数据来说的):可以把输出字节流转换为输出字符流 2.转换流的作用 1.如果目前获取的是一个字节流需要转换为字符流,这个时候就可以使用转换流. 字节流---->字符流       2.使用转换流可以指定编码进行读写文件 3.实例 1 package com.dhb.file;

Java 基础 - 基本 IO

基本 IO 重要接口 重要类 字节类 InputStream 特点: 读取字节流的抽象类 BufferedInputStream 特点: 用字节缓冲区来从 InputStream 中读取流 缓冲区默认大小是 8K, 可能会增长 实现了 mark() 和 reset() 方法 fill() 方法 ByteArrayInputStream 特点: 从内存中的字节数组的字节读取流 实现了 mark() 和 reset() DataInputStream 特点: 允许从下层流中以Java基本数据类型 一