第39节：Java当中的IO
Java当中的IO
IO的分类
第一种分：输入流和输出流
第二种分：字节流和字符流
第三种分：节点流和处理流
节点流处理数据，处理流是节点流基础上加工的。
IO中的重点：
InputStream
OutputStream
FileInputStream
FileOutputStream
InputStream
int read(byte[] b,int off,int len)
OutputStream
void write(byte[] b,int off,int len)
// 第一步，导入类
import java.io.*;
class Demo {
public static void main(String[] args){
// 声明输入流的引用
FileInputStream fis = null;
// 声明输出流的引用
FileOutputStream fos = null;
try{
// 生成输入流的对象
fis = new FileInputStream("e:/from.txt");
// 生成代表输出流的对象
fos = new FileOutputSteam("e:/to.txt");
// 生成一个字节数组
byte[] buffer = new byte[100];
// 调用输入流对象的read方法
int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
for(int i=0; i<buffer.length; i++){
System.out.println(buffer[i]);
}
}catch(Exception e){
System.out.println(e);
}
}
}
IO是为了对数据进行读写操作，数据的流向是以Java程序为参照物的，注意read方法和write方法。
流：在Java中输入和输出是通过流的类来实现的，Java提供了一套丰富的流类，可导入java.io，这样就可以完成输入和输出了，也同样可以实现网络操作等。
听到流，是不是很形象了呢？流好比一个走向，当程序中需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件，内存，网络连接等，需要写入数据时，也会开启一个通向目的地的流。流好比连接起点到终点的路。
输入流：源到程序，即读，从数据源的地方输入到程序中，读即 一个文件里的内容读到程序中。
输出流：程序中输出到目的地，输出流，即写，一个文件写到另一个文件，从这边输出到另一边。
在Java中流：字节流，字符流都要掌握
InputStream
OutputStream
Reader
Writer
重点早期的Java内容：InputStream和OutputStream，这两个都是基于字节流。
字符流：Reader和Writer
Java语言中的流分：文本流（字符序列）和二进制流
输入流和输出流
InputStream类为基本的输入流类，是抽象的类，在InputStream类中定义了read方法，用于读取数据的，读的。
OutputStream类为基本的输出类，是抽象的类，在OutputStream类中定义了write方法，用于输出数据，写的。
OutputStream类
清除缓冲区：public void flush()
关闭输出流：public void close()
其他重点：
在Java中提供了DataInputStream类与DataOutputStream类，数据输入流和数据输出流。在JDK1.1版本提供了InputStreamReader类与OutputStreamWriter类，它们是Reader、Writer类的子类，提供了字节流到字符流的转换。
字符流
BufferedReader类与BufferedWriter类分别是Reader类和Writer类的子类，输入和输出的缓冲区得以提供。
文件类
FileInputStream类为输入操作，是文件输入流类
import java.io.*;
public class Demo{
public static void main(String[] args){
byte buffer[] = new byte[1024];
try{
// 创建FileInputStream类对象
FileInputStream fis = new FileInputStream("from.txt");
int temp = fis.read(buffer,0,buffer.length);
String str=new String(buffer,0,temp);
// 输出字符串内容
System.out.println(str);
}catch(Exception e){
System.out.println(e);
}
}
}
FileOutputStream类为输出类，与FileInputStream同理即可。
FileInputStream类，FileOutputStream类
DataInputStream类，DataOutputStream类
InputStream类，OutputStream类
BufferedReader类，BufferedWriter类
说说IO
//第一种：输入流输出流
//第二种：字节流字符流
//第三种：节点流处理流
//FileInputStream
class Test{
public static void main(String args[]){
FileInputStream fis = null;
try{
fis = new FileInputStream("e:/read.txt");
byte[] buffer = new byte[100];
fis.read(buffer,0,buffer.length);
for(int i = 0;i<buffer.length;i++){
System.out.println(buffer[i]);
}
}
catch(Exception e){
System.out.println(e);
}
}
}
class Test{
public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt");
byte[] buffer = new byte[100];
int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}
}
}
class Test{
public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt");
byte[] buffer = new byte[1024];
while(true){
int temp = fis.read(buffer,o,buffer.length);
if(temp = -1){
break;
}
fos.write(buffer,0,temp);
}
}catch(Exception e){
System.out.println(e);
}finally{
try{
fis.close();
fos.close();
}catch(Excepiton e){
System.out.println(e);
}
}
}
}
//字符流
public class TextChar
public static void main(String args[]){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("e:/read.txt");
fw = new FileWriter("e:/write.txt");
char[] buffer = new char[100];
int temp = fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}finally{
try{
fr.close();
fw.close();
}
catch(Excepiton e){
System.out.println(e);
}
}
}
//FileReader和BufferedReader
class Test{
public static void main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader = null;
try{
fileReader = new FileReader("e:/read.txt");
bufferedReader = new BufferedReader(fileReader);
String line = null;
while(true){
line = bufferedReader.readLine();
if(line == null){
break;
}
System.out.println(line);
}
}catch(Exception e){
System.out.println(e);
}
finally{
try{
bufferedReader.close();
fileReader.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
public class Test{
public static void main(String[] args) throws Exception{
//字节流
FileInputStream in = new FileInputStream("c:/read.txt");
FileOutStream out = new FileOutputStream("c:/write.txt");
byte[] buffer = new byte[1024];
int len;
while( (len = in.read(buffer)) != -1){
out.write(buffer,0,len);
}
in.close();
out.close();
//字符流
BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
String str;
while( (str=bf.readLine()) != null ){
bw.write(str);
bw.newLine();
}
bf.close();
bw.close();
}
}
字节流: InputStream字节输入流,OutputStream字节输出流
字符流 : Reader字符输入流 ,Writer字符输出流
数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流
文件读写
目的
1 掌握文件读写的几种方法
2 FileOutputStream和FileInputStream类的使用。
3 基本数据类型之间的转换
实现文件读取后转换为大写后写入到目标文件中，其中src是指源文件，des是目标文件目录。
public class FileDemo {
//创建一个文件夹
public static void createFolder(String path){
File folder=new File(path);
if(folder.exists()){
System.out.println("文件夹已存在！");
}else{
//不存在时去创建
folder.mkdir();
}
}
//创建一个文件
public static void createFile(String path,String filename){
File file=new File(path,filename);
//文件判断是否已存在
if(file.exists()){
System.out.println("文件已存在！");
System.out.println(file.length());
}else{
try{
file.createNewFile();
}catch(IOException e){
System.out.println("文件创建失败！");
}
}
}
//写文件
public static void write(String path,String filename){
try{
String str="0123456789/nac";
String Upstr = str.toUpperCase();//
byte b[]=Upstr.getBytes();//
FileOutputStream fos=new FileOutputStream(new File(path,filename));
fos.write(b);
fos.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("写文件失败");
}
}
//读文件
public static void read(String path,String filename){
try{
int length=0;
String str="";
byte buffer[]=new byte[10];
FileInputStream fis=new FileInputStream(new File(path,filename));
while((length=fis.read(buffer, 0, buffer.length)) !=-1){
str+=new String (buffer, 0, length);
}
System.out.println(str);//
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
e.printStackTrace();
}
}
//
public static void FileReaderCopy(String src,String des){
try{
FileReader fr=new FileReader(src);
FileWriter fw=new FileWriter(des);
char c[]=new char[1024];
int len=0;
while((len=fr.read(c, 0, c.length)) != -1){
fw.write(c, 0, c.length);
}
fw.close();
fr.close();
} catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
}
//
public static void BufferedReaderCopy(String src,String des){
try{
BufferedReader br=new BufferedReader(new FileReader(src));
BufferedWriter bw=new BufferedWriter(new FileWriter(des));
String str="";
while((str=br.readLine()) != null){
String Upstr = str.toUpperCase();//加入大写的变换
bw.write(Upstr);//
bw.newLine();
}
bw.close();
br.close();
} catch(FileNotFoundException e){
System.out.println("文件存在");
}catch(IOException e){
System.out.println("读写失败");
}
}
//复制
public static void copy(String src,String des){
try{
FileInputStream fis=new FileInputStream(src);
FileOutputStream fos=new FileOutputStream(des);
int c;
while((c=fis.read()) != -1){
fos.write(c);
}
fos.close();
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
}
//复制文件
public static void copy1(String src,String des){
try{
FileInputStream fis=new FileInputStream(src);
FileOutputStream fos=new FileOutputStream(des);
int c;
byte buff[]=new byte[1024];
while((c=fis.read(buff,0,buff.length)) != -1){
fos.write(buff,0,c);
}
fos.close();
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("读写失败");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
FileDemo.createFolder("c:/test");
FileDemo.createFile("c:/test", "1.txt");
FileDemo.write("c:/test", "1.txt");
FileDemo.read("c:/test", "1.txt");
FileDemo.read("c:/test", "FileDemo.java");
FileDemo.BufferedReaderCopy("c:/test/FileDemo.java", "c:/test/FileDemo2.java");
FileDemo.copy1("c:/test/1.mp3", "c:/test/2.mp3");
}
}
读文件
//读文件
public static void read(String path,String filename){
try{
int length = 0;
String str = "";
byte buffer[]=new byte[10];
FileInputStream fis=new FileInputStream(new File(path,filename));
while((length=fis.read(buffer,0,buffer.length))!=-1){
str+=new String(buffer,0,length);
}
System.out.println(str);
fis.close();
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
e.printStackTrace();
}
}
文件的创建
public class FileDemo{
public static void createFolder(String path){
File folder = new File(path);
if(folder.exists()){
System.out.println("文件已存在!");
}else{
folder.mkdir();
}
}
public static void createFile(String path,String filename){
File file = new File(path,filename);
if(file.exists()){
System.out.println("文件已存在!");
System.out.println(file.length());
}else{
try{
file.createNewFile();
}catch(IOException e){
System.out.println("文件创建失败");
}
}
}
public static void main(String[] args){
FileDemo.createFolder("c:/test");
FileDemo.createFile("c:/test","1.txt");
}
}
写文件
public static void write(String path,String filename){
try{
String str = "234455";
byte b[] = str.getBytes();
FileOutputStream fos = new FileOutputStream(new File(path,filename));
fos.write(b);
}catch(FileNotFoundException e){
System.out.println("文件不存在");
}catch(IOException e){
System.out.println("写文件失败");
}
}
文件的读写
重点：
文件类主要功能：创建，读属性，写属性，删除等
文件读写操作
File类
File类的对象
用来获取文件本身的信息，如文件所在目录、文件长度、文件读写权限等，不涉及文件的读写操作。
构造函数
File(String filename)
File(String directoryPath,String filename)
File(File f,String filename)
获取文件的属性
String getName()
boolean canRead()
boolean canWrite()
long length()
boolean isFile()等
目录操作
boolean mkdir()：创建目录。
String[] list()：以字符串的形式返回目录下所有文件。
File[] listFiles()：以File对象形式返回目录下所有文件。
文件操作
boolean createNewFile()：创建一个新的文件。
boolean delete()：删除一个文件
流的概念
Java输入输出功能是借助输入输出流类来实现的。
java.io包中包含大量用来完成输入输出流的类。
Java中流的分类：
流的运动方向，可分为输入流和输出流两种。
流的数据类型，可以分为字节流和字符流。
输入流类都是抽象类InputStream（字节输入流）或抽象类Reader类（字符输入流）的子类。
输出流类都是抽象类OutputStream（字节输出流）或抽象类Writer类（字符输出流）的子类。
输入流
输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。
输入流读取数据过程如下：
（1）打开一个流。
如：FileInputStream inputFile=new FileInputStream("数据源");
（2）从信息源读取信息。
如：inputFile.read();
（3）关闭流。
如：inputFile.close();
输出流
输出流用于写入数据。只能写，不能读。
写数据到输出流过程如下：
（1）打开一个流。
如：FileOutputStream outFile=new FileOutputStream("数据源");
（2）写入信息到目的地。
如：outFile.write(inputFile.read()):
（3）关闭流。如：
如：outFile.close();
IO
I/O操作的目标IO的分类方法- 读取文件和写入文件的方法
I/O操作的目标
目标是从数据源中读取数据，将数据写入到数据目的地中。
从一个地方输入到java程序中输出到另外一个地方。
文件与数据流
写入和读出数据文件，在Java的输入/输出操作采用数据流的形式，数据流的两种形式为16位字符或8位字节
数据流的操作对象：
数据文件的读写
线程间的数据传输
网络间的数据传播
读/写步骤：
导入输入/输出包，导入java.io.*包
创建文件对象
FileReader/FileWriter类用于文本文件的读写操作
DataInputStream（用于文件读出）和DataOutputStream（用于文件写入）类文件的读写
FileInputStream（用于文件读出）和FileOutputStream对象（用于文件写入）
关闭文件
close函数关闭文件
File对象的特性
创建文件
boolean createNewFile();
创建子目录
boolean mkdir();
boolean mkdirs();
重命名/移动文件
boolean renameTo(File dest);
删除文件
boolean delete();
检查文件是否存在
boolean exists();
检查是否为文件
boolean isFile();
检查是否为文件夹
boolean isDirectory();
查询文件长度
long length();
往后余生，唯独有你
简书作者：达叔小生
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客： https://www.jianshu.com/u/c785ece603d1
结语
- 下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
- 小礼物走一走 or 点赞
第39节：Java当中的IO的更多相关文章
- 第55节:Java当中的IO流-时间api(下)-上
Java当中的IO流(下)-上 日期和时间 日期类:java.util.Date 系统时间: long time = System.currentTimeMillis(); public class ...
- 第54节:Java当中的IO流(中)
Java当中的IO流(中) 删除目录 // 简书作者:达叔小生 import java.io.File; public class Demo{ public static void main(Stri ...
- 第53节:Java当中的IO流(上)
Java当中的IO流 在Java中,字符串string可以用来操作文本数据内容,字符串缓冲区是什么呢?其实就是个容器,也是用来存储很多的数据类型的字符串,基本数据类型包装类的出现可以用来解决字符串和基 ...
- Java当中的IO流-时间api(下)-上
Java当中的IO流(下)-上 日期和时间 日期类:java.util.Date 系统时间: long time = System.currentTimeMillis(); public class ...
- Java当中的IO流(中)
Java当中的IO流(中) 删除目录 import java.io.File; public class Demo{ public static void main(String[] args){ / ...
- Java当中的IO流(上)
Java当中的IO流 在Java中,字符串string可以用来操作文本数据内容,字符串缓冲区是什么呢?其实就是个容器,也是用来存储很多的数据类型的字符串,基本数据类型包装类的出现可以用来解决字符串和基 ...
- Java当中的IO一
1.IO操作的目标 什么是IO操作的目标? 输入: 从数据源当中读取数据 输出: 将数据写入到数据目的地当中 有数据进入到程序当中,这个过程就可以被叫做输入 流:即在数据源与程序之间建立的传输通道 2 ...
- Java当中的IO三
1.处理流的使用实例 bufferedReader(处理流)介绍: buffereReader属于字符流,其次也是处理流,也是输入流,即字符输入处理流 常用方法 readLine() Buffered ...
- Java当中的IO二
1.大文件的读写方法 由于文件很大,我们不能一下子把文件内的所有内容都读取出来,所以只能一段一段的读取 注意:在关闭read()和write()的时候可能会产生IOException,需要对其进行处理 ...
随机推荐
- nginx学习笔记(一)
agentzh 的 Nginx 教程 学习笔记 nginx的变量 Nginx 变量一旦创建,其变量名的可见范围就是整个 Nginx 配置,甚至可以跨越不同虚拟主机的 server 配置块, 例子如下 ...
- Eclispe 错误：找不到或无法加载加载主类
解决办法: Project --> Clean Clean 操作会将该 project 以前的所有编译信息清空,然后默认将所有工程的所有 .java 文件都进行一次编译,这样的话就可以方便的进行 ...
- js最实用string(字符串)类型的使用及截取与拼接详解
var a = '世界上最远的距离不是天涯海角'; 一.通过字符获取位置或通过位置获取字符: //指定位置返回字符console.log(str.charAt(1));console.log(str[ ...
- UE4的委托
UE中委托的使用很广泛,许多Event的触发都有对应的虚函数和委托,虚函数不用讲,只能在派生类中使用,而委托可以在别的类或者蓝图中使用,就应用范围而言,委托的使用更灵活.以AActor的 /** * ...
- Java学习笔记：多线程（二）
与线程生命周期相关的方法: sleep 调用sleep方法会进入计时等待状态,等待时间到了,进入就绪状态. yield 调用yield方法会让别的线程执行,但是不确保真正让出.较少使用,官方注释都说 ...
- 用angular制作简单的选项卡
现在angular变得挺火热的,自己也去简单的学习了一下,学了几天下来觉得angular果然好用,但是现在只是停留在比较浅的层面上,要想学好angular还是得下一番功夫的.学了一点新知识就想和大家分 ...
- 人力资源项目中 add_account.php
add_account.php ( 文件浏览 ) <?phpinclude('db_con.php'); if(isset($_POST['save'])) { $employee_i ...
- Python Day 13 装饰器
阅读目录 内容回顾 函数嵌套的定义 global.nonlocal关键字 闭包及闭包的运用场景 开放封闭原则 装饰器 一个函数被多次装饰 ##内容回顾 1.函数对象:函数名 => 存放的是函 ...
- 使用ServletContextListener关闭Redisson连接
ServletContextListener 监听器 在 Servlet API 中有一个 ServletContextListener 接口,它能够监听 ServletContext 对象的生命周 ...
- 2019.03.09 bzoj5371: [Pkusc2018]星际穿越（主席树）
传送门 题意简述: 给一个序列,对于第iii个位置,它跟[limi,i−1][lim_i,i-1][limi,i−1]这些位置都存在一条长度为111的无向边. 称dist(u,v)dist(u,v) ...