标签：java String int 输入输出 new public out
一、输入输出流介绍
IO流【输入输出流】：
按照流向划分：
输入流：外部数据 -> java程序
输出流：java程序 -> 外部数据
按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：
字节流【万能流】：
字节输出流：
OutputStream（抽象类）
- FileOutputStream（实现子类）
字节输入流：
InputStream（抽象类）
- FileInputStream（实现子类）
字符流【记事本能看懂】：
字符输入流：
字符输出流：
FileInputStream：
构造方法：
FileInputStream(File file)
FileInputStream(String name)
成员方法：
public int read()
public int read(byte[] b)
二、字节输入流
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("java/src/com/shujia/day16/a1.txt"));
FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a1.txt");
//public int read() 一次只读取一个字节
// 如果没有读到数据，返回-1
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// int i = 0;
// while ((i = fis.read()) != -1) {
// System.out.print((char) i);
// }
//public int read(byte[] b) 一次读取一个字节数组
//创建一个字节数组，用作接收读取到的字节
byte[] bytes = new byte[7];
int length = 0;
while ((length = fis.read(bytes))!=-1){
//读取到的字节在字节数组中
//返回的是实际读取到的字节数
//将字节数组转字符串
String s = new String(bytes,0,length);
System.out.print(s);
}
// 释放资源
fis.close();
}
}
使用字节输入流读取文件内容
import java.io.FileInputStream;
/*
使用字节输入流读取汉字
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a2.txt");
// 一次读取一个字节
System.out.println((char) fis.read());
//一次读取一个字节数组
// byte[] bytes = new byte[1024];
// int length = fis.read(bytes);
// String s = new String(bytes, 0, length);
// System.out.println(s);
// 释放资源
fis.close();
}
}
三、字节输出流
import java.io.File;
import java.io.FileOutputStream;
/*
IO流【输入输出流】：
按照流向划分：
输入流：外部数据 -> java程序
输出流：java程序 -> 外部数据
按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：
字节流【万能流】：
字节输出流：
OutputStream（抽象类）
- FileOutputStream（实现子类）
字节输入流：
InputStream（抽象类）
字符流【记事本能看懂】：
字符输入流：
字符输出流：
FileOutputStream：
构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
*/
public class FileOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
// FileOutputStream(File file) 将目标文件封装成File对象
// 若目标文件不存在，则会自动创建
// FileOutputStream fos = new FileOutputStream(new File("java/src/com/shujia/day16/a1.txt"));
//FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
}
}
向文件中写入数据
import java.io.FileOutputStream;
/*
public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)
思考：
1、如何实现文件内容追加写？ 使用另一个重载的构造方法传入append参数值
2、如何实现写的时候换行？写一个换行符
*/
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws Exception{
// FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
//public FileOutputStream(String name, boolean append)
FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt", true);
//public void write(int b) 写一个ASCII码值
// fos.write(97);
// public void write(byte[] b) 写一个字节数组到文件中
// byte[] bytes = {97,98,99,100,101,102};
// fos.write(bytes);
//public void write(byte[] b,int index,int len)
// fos.write(bytes,2,3);
fos.write("\r\n".getBytes());
fos.write("李刚真帅！".getBytes());
//释放资源
fos.close();
}
}
四、字节缓冲输入流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/*
InputStream:
FileInputStream【普通的字节输入流】:
BufferedInputStream【字节缓冲输入流】:
*/
public class BufferedInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//BufferedInputStream(InputStream in)
//创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java/src/com/shujia/day16/a1.txt"));
// 一次读一个字节
// int i = 0;
// while ((i=bis.read())!=-1){
// System.out.print((char) i);
// }
// 一次都一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while ((length = bis.read(bytes)) != -1) {
String s = new String(bytes, 0, length);
System.out.print(s);
}
//释放资源
bis.close();
}
}
五、字节缓冲输出流
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/*
OutputStream:
FileOutputStream【普通的字节输出流】：
BufferedOutputStream【字节缓冲输出流】：
*/
public class BufferedOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
//BufferedOutputStream(OutputStream out)
//创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
//创建一个字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java/src/com/shujia/day16/a2.txt"));
bos.write("李刚是世界上最帅的男人！".getBytes());
bos.write("好好学习".getBytes());
bos.flush();
//释放资源
bos.close(); // 关闭缓冲流的时候，会先将内存中的数据刷到磁盘中
}
}
六、字符输入流
import java.io.FileInputStream;
import java.io.InputStreamReader;
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
InputStreamReader：
构造方法：
InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
成员方法：
public int read()
public int read(char[] cbuf)
*/
public class InputStreamReaderDemo1 {
public static void main(String[] args) throws Exception {
// InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"));
//InputStreamReader(InputStream in, String charsetName)
InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"), "GBK");
// public int read() 一次都一个字符
// System.out.print((char) isr.read());
// System.out.print((char) isr.read());
// int i = 0;
// while ((i = isr.read()) != -1) {
// System.out.print((char) i);
// }
//public int read(char[] cbuf) 一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while ((length= isr.read(chars))!=-1){
String s = new String(chars, 0, length);
System.out.print(s);
}
// 释放资源
isr.close();
}
}
七、字符输出流
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.Arrays;
/*
字符流【转换流】：字节流 + 编码表
编码：加密
解码：解密
字符流：
字符输入流：
Reader
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
OutputStreamWriter：
构造方法：
OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
成员方法：
public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf,int off,int len)
public void write(String str)
public void write(String str,int off,int len)
*/
public class OutputStreamWriterDemo1 {
public static void main(String[] args) throws Exception{
// String s1 = "今天下午放假，不上课！";
//// byte[] bytes = s1.getBytes();
// byte[] bytes = s1.getBytes("GBK");
// System.out.println(Arrays.toString(bytes));
//
// String s = new String(bytes,"GBK");
// System.out.println(s);
// 创建OutputStreamWriter(OutputStream out)对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/a3.txt"),"GBK");
// public void write(int c) 一次写一个字符
// osw.write(97);
// osw.flush();
//public void write(char[] cbuf) 一次写一个字符数组
// char[] chars = {'我','爱','数','加'};
// osw.write(chars);
//public void write(char[] cbuf,int off,int len) 一次写字符数组的一部分
// osw.write(chars,1,3);
// osw.flush();
//public void write(String str) 直接写一个字符串
// osw.write("李刚是32期最帅的男人！");
// osw.flush();
//public void write(String str,int off,int len) 写字符串的一部分
// osw.write("李刚是32期最帅的男人！",6,2);
osw.write("中国");
osw.flush();
//释放资源
osw.close();
}
}
八、字符缓冲输入流
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
- FileReader【继承自InputStreamReader】
- BufferedReader 【字符缓冲输入流】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
- FileWriter【继承自OutputStreamWriter】
- BufferedWriter【字符缓冲输出流】
BufferedReader 【字符缓冲输入流】:
构造方法：
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
特殊功能：
public String readLine() 一次读取文本文件内容的一行, 不会读取换行符
*/
public class BufferedReaderDemo1 {
public static void main(String[] args) throws Exception {
//创建字符缓冲输入流对象
// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b3.txt")));
BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/day16/b3.txt"));
//一次读一个字符
// int i = 0;
// while ((i=br.read())!=-1){
// System.out.print((char) i);
// }
//一次读一个字符数组
// char[] chars = new char[1024];
// int length = 0;
// while ((length=br.read(chars))!=-1){
// String s = new String(chars, 0, length);
// System.out.print(s);
// }
//一次读取一行数据
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//释放资源
br.close();
}
}
九、字符缓冲输出流
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
- FileReader【继承自InputStreamReader】
- BufferedReader 【字符缓冲输入流】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
- FileWriter【继承自OutputStreamWriter】
- BufferedWriter【字符缓冲输出流】
BufferedWriter【字符缓冲输出流】：
构造方法：
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
特殊方法：
newLine(); // 默认会自动根据当前的系统生成一个换行符
*/
public class BufferedWriterDemo1 {
public static void main(String[] args) throws Exception{
//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day16/b3.txt"));
bw.write("落霞与孤鹜齐飞");
// bw.write("\r\n"); // 这里的换行符需要根据将来运行的系统环境来设置
bw.newLine(); // 默认会自动根据当前的系统生成一个换行符
bw.write("秋水共长天一色");
bw.flush();
//释放资源
bw.close();
}
}
标签：java,
String,
int,
输入输出,
new,
public,
out
From： https://www.cnblogs.com/ndmtzwdx/p/18475831