java 的输入/输出
java的 I/O是通过java.io包下的类和接口支持，
其中最重要的是5个类,分别是
File,OutputStream,InputStream, Write,Reader
及一个接口Serializable.
File类:可以对文件进行操作
字节流：(OutputStream/InputStream)，
可以使用字节流读取文件内容
字符流：(Writer/Reader)
转换流：(InputStreamReader/OutputStreamWriter)
将字节流转换为字符流
缓冲流:(BufferedReader),
读取缓冲区的内容
内存操作流：(ByteArrayInputStream/ByteArrayOutputStream),可以与内存的数据时行交互
打印流：
Scanner类：对输入的输入，还可以验证数据
合并流：(SequenceInputStream)
类可以将两个文件内容合并成一个文件
压缩流：对文件压缩操作
Serializable接口：对象序列化
输入字节流层次：
InputStream(父类):ByteArrayInputStream,FileInputStream,
StringBufferInputStream,SequenceInputStream,
ObjectInputStream,
FilterInputStream(BufferedInputStream,DataInputStream,LineNumberInputStream,PushbackInputStream) [子类]
输出字节流层次：
OutputStream(父类):ByteArrayOutputStream,
FileOutputStream,ObjectOutputStream,PipedOutputStream,
FilterOutputStream(BufferedOutputStream,DataOutputStream,PintStream)[子类]
输入字符流类的层次：
Reader(父类):BufferedReader(LineNumberReader),
CharArrayReader,FilterReader(PushbackReader),
InputStreamReader(FileReader), PipedReader,StringReader
输出字符流类的层次：
Writer(父类):BufferedWriter,CharArrayWriter,
FilterWrite,OutputStreamWrite(FileWriter),
PipedWriter,PrintWriter,StringWriter
/**
除了在 java.io包中的"流"外,
还有一个内置的流位于java.lang包中,
就是 System类，
System类包含了3个预定义的流变量，
分别是 in,out和err,它们为 public和 static，
这就意味着可以不通过 System类的对象就可以直接调用.
System.out是标准的输出流，
默认的情况是向显示器输出。
System.in是标准输入流，在默认下是输入键盘的数据。
System.err是标准错误流，默认的是向显示器输出.
*/
/**
文件类:File类
对文件和文件夹的基本操作（增删改查...）
*/
//File类的常量，构造方法和常用方法
public static String pathSeparator;
public static String separator;
public File(String pathname){}
public File(String parent, String child){}
public File(File parent, String child){}
public boolean canRead(){}
public boolean canWrite(){}
public int compareTo(File pathname)
public boolean createNewFile() throws IOException
public boolean delete()
public boolean exists()
public File getAbsolutePath()
public String getName()
public String getParent()
public String getPath()
public boolean isAbsolute()
public public boolean isDirectory()
public boolean isFile();
public boolean isHidden()
public long lastModified()
public long length()
public String[] list()
public File[] list(FilenameFilter filter)
public File[] listFiles()
public File[] listFiles(FilenameFilter filter)
public static File[] listRoots()
public boolean mkdir()
public boolean mkdirs();
public boolean renameTo(File dest)
public boolean setReadOnly()
// ==============
import java.io.File;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
//File file = new File("E:\\javap", "ok.txt"); // 创建File类实例
// 创建 File类实例还可以这样
File file = new File("E:"+File.separator+"javap", "lin3615.txt");
try // 处理异常
{
file.createNewFile(); // 新建文件
System.out.println("创建成功！"); // 输出提示信息
}catch(IOException e) // 抓捕异常
{
System.out.println("创建失败！");
e.printStackTrace();
}
}
}
// ===========
import java.io.File;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\ok.txt");
if(file.exists())
{
file.delete();
System.out.println("删除成功！！");
}else
{
createFile(file);
}
}
public static void createFile(File file)
{
try
{
file.createNewFile();
System.out.println("创建成功！！");
}catch(IOException e)
{
System.out.println("创建失败！！");
e.printStackTrace();
}
}
}
// ==========
// 文件的相关属性
import java.io.File;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10", "test.java");
if(file.exists())
{
System.out.println("文件名为："+file.getName() // 名称
+", 文件路径："+file.getPath() // 路径
+", 文件大小："+file.length() // 大小
+",文件最后修改时间："+
file.lastModified()+",文件可读:" // 最后修改日期
+file.canRead()+", 文件可写:" // 可读?
+file.canWrite()); // 可写
}else
{
File file1 = new File("F:\\javap\\10\\test.java");
newFile(file1);
System.out.println("文件不存在");
}
}
public static void newFile(File file)
{
try
{
file.createNewFile();
System.out.println("文件创建成功");
}
catch (Exception e)
{
System.out.println("Error:"+e);
}
}
}
/**
文件名为：test.java,
文件路径：F:\javap\10\test.java,
文件大小：0,
文件最后修改时间：1423090681750,
文件可读:true, 文件可写:true
*/
// ============
// list() / listFiles() 输出目录中所有文件
import java.io.File;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap");
String list[] = file.list();
File listFiles[] = file.listFiles();
System.out.println("以下是 list()方法，只列出文件名：");
for(int i=0; i<list.length; i++)
{
System.out.println(list[i]);
}
System.out.println("以下是 listFiles()方法，包含路径和文件名：");
for(int i=0; i<listFiles.length; i++)
{
System.out.println(listFiles[i]);
}
}
}
// =============
// 目录生成， mkdir()只能生成单级目录/mkdirs()可生成多级目录
import java.io.File;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\test");
if(file.mkdir())
{
System.out.println("生成目录成功");
}else
{
System.out.println("mkdir 生成目录失败");
}
File ff = new File("F:\\javap\\ok\\yes");
if(ff.mkdirs())
{
System.out.println("mkdirs 生成成功");
}else
{
System.out.println("mkdirs 生成失败");
}
}
}
// ==============
/*
所有的字节输入流都是 InputStream的子类，
InputStream是抽象类，所以只能实例化其子类
常用方法：
*/
// 取得输入流中读取的字节数
public int available() throws IOException{}
// 关闭输入流
public void close() throws IOException(){}
// 在此输入流中标记当前的位置
public void mark(int readlimit){}
//判断当前输入流是否允许标记,若是，则true,否则为 false
public boolean makrSupported(){}
/**
从输入流读取下一个数据字节作为返回值，
但是以 int 类型的值显示
*/
public abstract int read() throws IOException{}
/*
从输入流中读取一定数量的字节并将其存储在缓冲区数组b中,
然后以缓冲区数组 b 的 int 值返回
*/
public int read(byte[] b) throw IOException{}
/*
从输入流中读取一定数量的字节并将其存储在缓冲区
数组 b指定的字节数组中，然后以数组 b 中的
int值返回.其中，off指定在字节数组中开始保存
数据的起始下标，len指定读取的字节数
*/
public int read(byte[] b, int off, int len) throws IOException{}
/*
将输入流的指针返回到设置标志的起始处
*/
public void reset() throws IOException{}
//从输入流中跳过 n个指定的字节，返回跳过的字节数
public long skip(long n) throws IOException{}
// 使用 read()读取文本内容
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10", "java.txt"); // 创建 Ffile类实例
InputStream input = null; // 声明InputStream对象
byte b[] = new byte[100]; // 声明大小为 100的字节数组
try
{
// 使用FileInputStream为InputStream实例化
input = new FileInputStream(file);
input.read(b); // 读取内容并存放到 b数组中
input.close(); // 关闭输入流
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println(new String(b)); // 输出读取的内容
}
}
// 以上数组大小过大时，会浪费空间，所以可以改进
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10", "java.txt");
InputStream input = null;
byte b[] = new byte[(int)file.length()];
try
{
input = new FileInputStream(file);
input.read(b);
input.close();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println(new String(b));
}
}
// =============
// 读文件
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10", "test.java");
InputStream input = null;
byte b[] = new byte[(int)file.length()];
int temp = 0;
int len = 0;
try
{
input = new FileInputStream(file);
while((temp = input.read()) != -1)
{
b[len] = (byte)temp;
len++;
}
input.close();
}
catch (Exception e)
{
e.printStackTrace();
}
System.out.println(new String(b));
}
}
// =============
// 字节输出流： OutputStream 类
//关闭此输出流
public void close() throws IOException{}
// 刷新缓冲区
public void flush() throws IOException{}
// 将b数组的数据写到输出流
public void write(byte[] b) throws IOException{}
// 将 b数组的部分写到输出流中
public void write(byte[] b, int off, int len) throws IOException{}
// 将一个 b 数字写到输出流，但代表 b 值的参数 为 int 值
public abstract void write(int b) throws IOException{}
// =============
/*
字符流
*/
// 关闭字符流
public abstract void close() throws IOException{}
//标志字符流的当前位置
public void mark(int readAheadLimit) throws IOException{}
// 判断此流是否支持 mark操作
public boolean markSupported(){}
//读取单个字符，并转为整数
public int read() throws IOException{}
// 读入字符到数组中，并返回字符数
public int read(char[] cbuf) throw IOException{}
//读入指定的字符数，并返回字符的数
public int read(char[] cbuf, int off, int len) throws IOException{}
// 重置字符流
public void reset() throws IOException{}
//跳过字符数，并返回跳过的字符数
public long skip() throws IOException{}
// 读入字符串
import java.io.File;
import java.io.Reader;
import java.io.IOException;
import java.io.FileReader;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10", "java.txt");
Reader read = null;
char c[] = new char[(int)file.length()];
try
{
read = new FileReader(file);
read.read(c);
read.close();
}
catch (IOException e)
{
System.out.println("failer");
e.printStackTrace();
}
System.out.println(c);
}
}
// =============
// 循环读取
import java.io.File;
import java.io.Reader;
import java.io.IOException;
import java.io.FileReader;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10", "java.txt");
Reader read = null;
char c[] = new char[(int)file.length()];
int temp = 0;
int len = 0;
try
{
read = new FileReader(file);
while((temp=read.read()) != -1)
{
c[len] = (char)temp;
len++;
}
read.close();
}
catch (IOException e)
{
System.out.println("失败");
e.printStackTrace();
}
System.out.println(c);
}
}
// ==============
// 字符流输出
// 将指定的字符 c 添加到输出流中
public Writer append(char c) throws IOException{}
// 关闭输出流
public abstract void close() throws IOException{}
// 将输出流中为输出的数据强制清出
public abstract void flush() throws IOException{}
// 将字符数组中的字符写到输出流中
public void write(char[] cbuf) throws IOException{}
// 将字符数组中的部分字符写到输出流中
public abstract void write(char[] cbuf, int off, int len) throws IOException{}
// 向输出流写入一个字符
public void write(int c) throws IOException{}
// 写入字符串
public void write(String str) throws IOException{}
//将指定的部分字符串写入输出流中
public void write(String str, int off, int len) throws IOException{}
// 写数据,不存在时就创建相应的文件
import java.io.OutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10\\test.java"); // 创建 File 实例
File fileAppend = new File("F::\\javap\\10\\test.txt");
OutputStream out = null; // 声明对象
OutputStream out1 = null;
String str = "步，lin3615"; // 创建字符串
byte b[] = str.getBytes(); // 将字符串变成数组
try
{
// 使用 FileOutputStream类实例化 OutputStream
out = new FileOutputStream(file); // 每次都会重新生成新数据
out1 = new FileOutputStream(fileAppend, true); // 追加数据
out.write(b); // 写入数据
out1.write(b);
out.close();
out1.close();
System.out.println("成功");
}
catch (IOException e)
{
System.out.println("失败");
e.printStackTrace();
}
}
}
// ============
/*
向文件写入内容, write(char[] cbuf) 方法,即是以数组的形式写的
*/
import java.io.Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10\\java.txt");// 创建实例
Writer out = null; // 声明 Writer对象
String str = "hi,世界！！！"; // 创建字符串
char c[] = str.toCharArray(); // 将字符串转换为 char数组
try
{
out = new FileWriter(file);//使用 FileWriter类实例化 Writer
out.write(c); // 写入数据,以数组的形式写入
out.close(); // 关闭数据
System.out.println("写入成功"); // 提示信息
}catch(IOException e)
{
System.out.println("写入失败！");
e.printStackTrace(); // 打印错误信息
}
}
}
// ===========
/*
向文件写入内容, write(String str) 方法,即是以字符串的形式写的
*/
import java.io.Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10\\java.txt"); // 创建File实例
Writer out = null; // 声明writer对象
String str = ";小二"; // 创建字符串
try
{
out = new FileWriter(file); // 使用FileWriter类实例化Writer
out.write(str); // 写入数据，以字符串的形式写入
out.close(); // 关闭输出流
System.out.println("写入成功");
}catch(IOException e)
{
System.out.println("写入失败");
e.printStackTrace();
}
}
}
// =========
/*
追加文件内容 append()方法，此方法是每次都更新数据，每次的数据都一样
另外一个方法为 FileWriter(File file, boolean append)
*/
import java.io.Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10\\java.txt"); // 创建 File 实例
Writer out = null; // 声明 Writer对象
String str = "hi,world"; // 创建字符串
try
{
out = new FileWriter(file); // 使用 FileWriter类实例化 Writer
out.write(str); // 写入数据
out.append("lin3615"); // 文件追加
out.close();
System.out.println("成功");
}catch(IOException e)
{
System.out.println("写入失败");
e.printStackTrace();
}
}
}
// =============
/*
使用 FileWriter(File file, boolean append)实现文件内容的追加
*/
import java.io.Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File file = new File("E:\\javap\\10\\java.txt");//创建 File 实例
Writer out = null; // 声明 Writer对象
String str = "\r\nhi,lin3615"; // 创建字符串
try
{
// 使用 FileWriter类实例化 Writer,可追加
out = new FileWriter(file, true);
out.write(str); // 写入数据
out.close();
System.out.println("成功");
}catch(IOException e)
{
System.out.println("失败");
e.printStackTrace();
}
}
}
// ===========
输入字节流--字符流:InputStreamReader 类
//创建一个使用默认字符集的 InputStreamReader 对象
public InputStreamReader(InputStream in){}
//创建使用给定字符集的 InputStreamReader 对象
public InputStreamReader(InputStream in, Charset cs){}
//创建使用给定字符集解码器的 InputStreamReader 对象
public InputStreamReader(InputStream in, CharsetDecoder dec){}
//创建使用指定字符集的 InputStreamReader 对象
public InputStreamReader(InputStream in,String charsetname){}
//返回此流使用的字符编码的名称
public String getEncoding(){}
// ===============
// 转码
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
try
{
// 创建 File 实例
File file = new File("F:\\javap\\10\\test.txt");
// 创建 FileInputStream实例
FileInputStream fin = new FileInputStream(file);
// 创建 InputStreamReader 实例,并用默认的字符转码，不然会出现乱码的可能
InputStreamReader isr = new InputStreamReader(fin);
// 获取系统默认的字符集
System.out.println(isr.getEncoding());
int temp = 0;
while((temp = isr.read()) != -1)
{
System.out.print((char)temp);
}
isr.close();
fin.close();
}
catch (IOException e)
{
e.printStackTrace();
System.out.println();
}
}
}
// =============
输出字节流--字符流:OutputStreamWriter类
//创建使用默认字符编码的 OutputStreamWriter 对象
public OutputStreamWriter(OutputStream out){}
//使用指定的字符编码创建 OutputStreamWriter 对象
public OutputStreamWriter(OutputStream out, Charset cs){}
// 创建使用指定的字符编码器创建 OutputStreamWriter 对象
public OutputStreamWriter(OutputStream out, CharsetEncoder enc){}
//使用指定的字符集 创建 OutputStreamWriter 对象
public OutputStreamWriter(OutputStream out, String CharsetName){}
//返回此流使用的字符编码的名称
public String getEncoding(){}
// ========
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class Hi
{
public static void main(String[] args)
{
try
{
// 创建 File实例
File file = new File("F:\\javap\\10\\test.txt");
// 创建 FileOutputStream 实例
FileOutputStream fos = new FileOutputStream(file);
// 创建 OutputStreamWriter 实例
OutputStreamWriter osw = new OutputStreamWriter(fos);
String sr = "你好，吧...";
osw.write(sr);
osw.close();
fos.close();
}
catch (IOException e)
{
e.printStackTrace();
System.out.println();
}
}
}
// ==============
缓冲流：BufferReader 类
包括：BufferedInputStream,BufferdOutputStream,BufferReader,BufferdWriter
// BufferedReader 类
// 创建一个使用默认大小输入缓冲区的缓存字符输入流对象
public BufferedReader(Reader in){}
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流对象
public BufferedReader(Reader in, int sz){}
// 读取一个文本行
public String readLine() throws IOException{}
// bufferedReader 类实例（读取）
import java.io.File;
import java.io.Reader;
import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;
public class Hi
{
public static void main(String[] args)
{
// 创建 File 类实例
File file = new File("E:\\javap\\10", "java.txt");
// 声明 Reader 对象
Reader read = null;
// 定义字符串
String str = "";
// 声明 BufferedReader 对象
BufferedReader bin = null;
try
{
// 使用 FileReader 实例化 Reader
read = new FileReader(file);
// 实例化 BufferedReader 对象
bin = new BufferedReader(read);
// 读取内容
str = bin.readLine();
// 关闭缓冲流
bin.close();
// 关闭字符流
read.close();
}catch(IOException e)
{
System.out.println("读取失败!!");
e.printStackTrace();
}
// 输出读取的内容
System.out.println(str);
}
}
// ============
/*
BufferedReader 类可以接收来自键盘输入的字节流，但需要
使用 InputStreamReader 将键盘的字节流 System.in转化为字符流
*/
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Hi
{
public static void main(String[] args)
{
String str = "";
// 声明 BufferedReader 对象
BufferedReader bin = null;
try
{
// 实例化 BufferedReader 对象，从键盘获取数据
bin = new BufferedReader(new InputStreamReader(System.in));
// 读取内容存入 char 数组
str = bin.readLine();
bin.close();
}catch(IOException e)
{
System.out.println("读取失败");
e.printStackTrace();
}
System.out.println("你输入的内容为:\n"+str);
}
}
// ============
BufferedWriter 类
// 创建一个使用默认大小输出缓冲区的缓冲字符输出流对象
public BufferedWriter(Writer out)
// 创建一个使用指定大小输出缓冲区的新缓冲字符输出流对象
public BufferedWriter(Writer out, int sz)
// 写入一个行分隔符
public void newLine() throws IOException
// ===========
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.BufferedWriter;
public class Hi
{
public static void main(String[] args)
{
// 创建 File 对象
File file = new File("E:\\javap\\10\\test.txt");
// 声明 FileWriter 对象
FileWriter fw = null;
// 声明 BufferedWriter 对象
BufferedWriter bw = null;
// 创建字符串数组
String str[] = {"lin3615", "你好", "世界"};
try
{
fw = new FileWriter(file);
bw = new BufferedWriter(fw);
for(int i=0; i<str.length; i++)
{
// 将一行写入字符串
bw.write(str[i]);
// 写入一个结尾 '\n',以达到换行 目的
bw.newLine();
}
// 关闭缓冲流
bw.close();
// 关闭字符流
fw.close();
System.out.println("写入成功");
}catch(IOException e)
{
System.out.println("写入失败！！");
e.printStackTrace();
}
}
}
// ===========
/**
内存操作流
java有字节流和字符流之分，所以流的数据也有
byte[] 和 char[] 之分
java.io包中提供ByteArrayInputStream
和 ByteArrayOutputStream 类，用于实现
字节数组的输入/输出操作
内存输入流： ByteArrayInputStream 类
是一个把字节数组作为源的输入流的实现，可以将数据写入
内存中，常用方法如下：
*/
/*
创建一个 ByteArrayInputStream 对象，使用
buf 作为其缓冲区数组
*/
public ByteArrayInputStream(byte[] buf)
//
public ByteArrayInputStream(byte[] buf, int offset, int length){}
// ===========
import java.io.IOException;
import java.io.ByteArrayInputStream;
public class Hi
{
public static void main(String[] args)
{
// 定义字节数组
byte b[] = {'A', 'B', 'C', 'D'};
// 创建字节数组输入流
ByteArrayInputStream bis = new ByteArrayInputStream(b, 0, b.length);
//保存读取的数据
int temp = bis.read();
while(temp != -1
{
// 输出读取的内容
System.out.print((char)temp+"\t");
// 继续向下读取
temp = bis.read();
}
try
{
bis.close();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println();
}
}
// =========
/**
内存输出流：ByteArrayOutputStream类
是一个将字节数组作为源的输出流实现，
可以将内存中的数据输出。主要方法：
*/
/*创建一个新的字节数组输出流对象，输出流缓冲区的初始
容量默认为 32 字节
*/
public ByteArrayOutputStream()
//创建一个新的字节数组输出流对象，具有指定大小的缓冲区容量
public ByteArrayOutputStream(int size)
// 重置为0
public void reset()
//返回缓冲区大小
public int size()
// 创建一个新分配的字节数组，其长度和内容与输出流的数组相同
public byte[] toByteArray()
//将缓冲区的内容转换成字符串，根据平台的默认字符编码将字节转换成字符
public String toString()
//将此字节数组输出流的全部内容写入到指定的输出流参数中
public void writeTo(OutputStream out)
// ==========
// ByteArrayOutputStream 类
import java.io.IOException;
import java.io.ByteArrayOutputStream;
public class Hi
{
public static void main(String[] args)
{
// 定义字节数组
byte b[] = {'A', 'B', 'C', 'D'};
//创建字节输出流对象
ByteArrayOutputStream bos = new ByteArrayOutputStream();
// 将字节数组写入输出流
bos.write(b,0,b.length);
System.out.println("缓冲区的字节数："+bos.size());
byte bout[] = bos.toByteArray();
for(int i=0; i<bout.length; i++)
{
System.out.print((char)bout[i]+"\t");
}
System.out.println();
}
}
// ============
/**
打印流：PrintStream类
用来输出数据到各个目的地，如文件，数组等
常用方法：
*/
// 创建具有指定文件但不带自动行刷新的新打印流
public PrintStream(File file)
//创建新的打印流但不带自动行刷新
public PrintStream(OutputStream out)
//创建新的打印流，由参数 autoFlush决定是否要自动刷新
public PrintStream(OutputStream out, boolean autoFlush)
//创建新的打印流，并决定是否自动刷新，并指定流中使用的字符集
public PrintStream(OutputStream out, boolean autoFlush, String encoding)
// 使用指定格式字符串和参数，将格式化字符串写入此输出流中
public PrintStream format(Local l, String format, Object ... args)
//打印 String,然后终止执行
public void print(String s)
//使用指定格式字符串和参数，将格式化的字符串写入此输出流
public PrintStream printf(Local l, String format, Object ...args)
//根据本地格式化输出
public PrintStream printf(String format, Object ... args)
//指印 String，然后终止该行
public void println(String x)
// ============
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Date;
public class Hi
{
public static void main(String[] args)
{
// 声明 FileOutputStream对象
FileOutputStream fos = null;
//声明 PrintStream 对象
PrintStream ps = null;
try
{
fos = new FileOutputStream("E:\\javap\\10\\file.txt");
// 实例化 PrintStream
ps = new PrintStream(fos);
ps.println();
ps.println(true);
ps.println(123);
ps.println(30.125D);
ps.print('C');
ps.println("HI");
ps.close(); // 关闭打印流
fos.close(); // 关闭字节流
}catch(IOException e)
{
e.printStackTrace();
}
}
}
// =======
/**
Scanner类
可以方便地在控制台输入数据
常用方法：
*/
// 构造一个新的 Scanner 对象，从指定的文件中获取内容
public Scanner(File source)
//构造一个新的 Scanner 对象，从指定的输入流获取内容
public Scanner(InputStream source)
//判断输入数据是否符合指定的正则表达式，
//若符合，则返回 true,否则为 false
public boolean hasNext(Pattern pattern)
//判断输入的数据是否为 int值
public boolean hasNextInt()
//判断是否还有下一行，有为 true
public boolean hasNextLine()
//接收输入的内容
public String next()
// 接收输入的内容并时行正则验证
public String next(Pattern pattern)
//接收 int 型数据
public int nextInt()
//接收 long 型数据
public long nextLong()
//设置读取的分隔符
public Scanner useDelimiter(String pattern)
// =========
// 从键盘中获取输入
import java.util.Scanner;
public class Hi
{
public static void main(String[] args)
{
// 创建Scanner 实例
Scanner scan = new Scanner(System.in);
int num = 0;
float f = 0.0f;
System.out.println("请输入 int 型整数：");
if(scan.hasNextInt()) // 判断输出的数据是否为 int 型
{
num = scan.nextInt(); // 输入 int 型数据
}else
{
System.out.println("输入不是整数\n程序退出");
System.exit(0);
}
System.out.println("请输入 float型小数：");
if(scan.hasNextFloat()) // 判断是否为 float 型
{
f = scan.nextFloat();
}else
{
System.out.println("输入不是小数\n程序退出");
System.exit(0);
}
System.out.println("请输入字符串：");
String str = scan.next(); // 输入字符串
System.out.println("整数："+num+"\n小数:"+f+"\n字符串："+str);
}
}
// ==========
// 可以修改分隔符来修改
// 此时只有换行才会结束输入
import java.util.Scanner;
public class Hi
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
scan.useDelimiter("\n");
System.out.println("请输入字符串：");
String str = scan.next();
System.out.println(str);
}
}
// =========
// 使用正则验证输入的数据
import java.util.Scanner;
public class Hi
{
public static void main(String[] args)
{
// 创建 Scanner 实例
Scanner scan = new Scanner(System.in);
String pattern = "^[a-zA-Z0-9_\\.]+@[a-zA-Z0-9_\\.]+[\\.a-zA-Z]+$";
System.out.println("请输入邮箱地址：");
String mail = null;
if(scan.hasNext(pattern))
{
mail = scan.next();
System.out.println("你输入的邮箱："+mail);
}else
{
System.out.println("邮箱格式不对");
}
}
}
// ======
// 从文件中获取数据
import java.util.Scanner;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
// 创建 File对象
File file = new File("E:\\javap\\10\\test.txt");
if(!(file.exists()))
{
System.out.println("文件不存在");
System.exit(0);
}
FileInputStream fis = null;
Scanner scan = null;
try
{
fis = new FileInputStream(file);
scan = new Scanner(fis);
}catch(IOException e)
{
e.printStackTrace();
}
StringBuffer sbu = new StringBuffer();
while(scan.hasNext())
{
sbu.append(scan.next()).append("\n");
}
System.out.print(sbu);
}
}
// -------------
// 随机访问文件类
RandomAccessFile 常用方法
// 访问 file 参数指定的文件，访问形式由 mode 参数指定
public RandomAccessFile(File file, String mode)
// 访问 name 参数指定的文件，访问形式由 mode 参数指定
public RandomAccessFile(String name, String mode)
// 关闭此随机存取文件并释放与该流关联的所有系统资源
public void close() throws IOException
// 返回指定文件的长度
public long length() throws IOException
//从指定文件的当前指针位置读取一个数据字节
public int read() throws IOException
//一次性读取多个字节，读取的长度为 byte 数组b 的长度，
// 将读取的内容存放在 byte 数组中
public int read() throws IOException
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10\\random.txt");
RandomAccessFile raf = null;
try
{
// 实例化 randomAccessFile 并以 rw 模式
raf = new RandomAccessFile(file, "rw");
raf.writeInt(56);
raf.writeChar('林');
raf.writeLong(1234L);
raf.writeUTF("天朝");
raf.close();
System.out.println("写入成功");
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ===========
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
public class Hi
{
public static void main(String[] args)
{
File file = new File("F:\\javap\\10\\random.txt");
RandomAccessFile raf = null;
try
{
raf = new RandomAccessFile(file, "rw");
for(int i=0; i<10; i++)
{
raf.writeInt(i);
}
System.out.println("当前指针位置为："+raf.getFilePointer());
System.out.println("文件长度为："+raf.length()+"字节");
raf.seek(0);
System.out.println("当前位置："+raf.getFilePointer());
System.out.println("读取数据");
for(int i=0; i<6; i++)
{
System.out.println("数值："+raf.readInt()+" ------>对应的指针 "+(raf.getFilePointer()-4));
if(i==3)
{
raf.seek(32);
}
}
raf.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
/*
当前指针位置为：40
文件长度为：40字节
当前位置：0
读取数据
数值：0 ------>对应的指针 0
数值：1 ------>对应的指针 4
数值：2 ------>对应的指针 8
数值：3 ------>对应的指针 12
数值：8 ------>对应的指针 32
数值：9 ------>对应的指针 36
*/
// ============
//顺序输入流
SequenceInputStream 类
// 参数s1和s2代表两个需要被串联的输入流
public SequenceInputStream(InputStream s1, InputStream s2)
//返回当前流中可用的字节数
public int available()
// ========
import java.io.File;
import java.io.SequenceInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Hi
{
public static void main(String[] args)
{
File f1 = new File("F:\\javap\\10\\file.txt");
File f2 = new File("F:\\javap\\10\\java.txt");
File f3 = new File("F:\\javap\\10\\seqfile.txt");
FileInputStream in1 = null;
FileInputStream in2 = null;
FileOutputStream out = null;
SequenceInputStream sis = null;
int temp = 0;
byte b[] = new byte[256];
try
{
in1 = new FileInputStream(f1);
in2 = new FileInputStream(f2);
out = new FileOutputStream(f3);
sis = new SequenceInputStream(in1, in2);
while((temp = sis.read(b)) != -1)
{
out.write(b, 0, temp);
}
sis.close();
out.close();
in1.close();
in2.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ---------------
压缩流 位于 java.util.zip 包中
ZipEntry,ZipFile,ZipOutputStream, ZipInputStream
ZipEntry 类的对象是用来表示zip 文件条目，代表 zip 文件内的进入点(entry)，
常用方法如下：
//使用指定名称创建新的 ZipEntry 对象
public ZipEntry(String name)
//建立一个实例内各字段皆由 e 参数指定的 ZipEntry 对象取得
public ZipEntry(ZipEntry e)
//返回此 ZipEntry 副本
public Object clone()
//返回条目的注释字符串，如果没有，则返回 null
public String getComment()
//返回压缩条目数据的大小，如果未知，则返回 -1
public long getCompressedSize()
//
public long getCrc()
//
public byte[] getExtra()
//
public int getMethod()
//
public String getName()
public long getSize()
public long getTime()
public int hashCode()
public boolean isDirectory()
public void setComment(String comment)
public void setCompressedSize(long size)
public void setCrc(long crc)
public void setMethod(int method)
public void setTime(long time)
public String toString()
// ======================
ZipOutputStream 类
可以将一个文件或文件夹压缩为一个 zip 文件
常用方法如下：
// 创建新的 zip 输出流
public ZipOutputStream(OutputStream out)
public void close()
// 关闭当前 zipentry 并让流内适当的位置，以便定位写入下一个 entry
public void closeEntry() throws IOException
// 完成写入 zip 输出流的内容，但不关闭与其配合的 OutputStream 流
public void finish()
// =============
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class Hi
{
public static void main(String[] args)
{
File f1 = new File("F:\\javap\\10\\java.txt");
// 定义压缩文件
File f2 = new File("F:\\javap\\10\\java.zip");
FileOutputStream fout = null;
FileInputStream fis = null;
ZipOutputStream zout = null;
byte b[] = new byte[1024];
int temp = 0;
try
{
// 定义文件输入流
fis = new FileInputStream(f1);
// 定义文件输出流
fout = new FileOutputStream(f2);
// 定义压缩输出流
zout = new ZipOutputStream(fout);
// 每个被压缩的文件均用 ZipEntry 表示
zout.putNextEntry(new ZipEntry(f1.getName()));
// 设置注释
zout.setComment("use zipoutputStream compression java.txt");
// 读取内容
while((temp = fis.read(b)) !=-1)
{
// 输入出压缩文件
zout.write(b, 0, temp);
}
zout.close();
fout.close();
fis.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ------------
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class Hi
{
public static void main(String[] args)
{
// 定义要压缩的文件
File f1 = new File("zip");
// 定义压缩文件名
File f2 = new File("oks.zip");
FileInputStream fis = null;
FileOutputStream fout = null;
ZipOutputStream zout = null;
String fileName[] = null;
byte b[] = new byte[1024];
int temp = 0;
try
{
// 定义文件输出流
fout = new FileOutputStream(f2);
// 定义压缩输出流
zout = new ZipOutputStream(fout);
// 设置注释
zout.setComment("use ZipOutputStream compression zip Directory");
// 判断是否为目录
if(f1.isDirectory())
{
fileName = f1.list();
for (int i=0; i < fileName.length; i++)
{
// 定义文件输入流
fis = new FileInputStream(fileName[i]);
zout.putNextEntry(new ZipEntry(fileName[i]));
System.out.println("正在压缩"+fileName[i]+"...");
while ((temp = fis.read(b)) != -1)
{
zout.write(b, 0, temp);
}
System.out.println("压缩"+fileName[i]+"完成");
}
}
zout.close();
fout.close();
fis.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ================
ZipOutputStream 类
可以方便地读取 zip 压缩格式的文件
// 创建新的 ZipInputStream 输入流
public ZipInputStream(InputStream in)
//判断是否读完当前的 entry所指的数据.
// 若读取完毕(EOF),则返回0，否则，始终返回 1
public int available() throws IOException
// ==============
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public class Hi
{
public static void main(String[] args)
{
// 压缩的文件存放的目录
File dirFile = new File("zip");
// 需要解压的 zip 文件
File zipFile = new File("jj.zip");
// 判断目录是否存在
if(!(dirFile.exists()))
{
// 创建目录
dirFile.mkdirs();
}
FileInputStream fis = null;
FileOutputStream fout = null;
ZipInputStream zin = null;
ZipEntry z = null;
String fileName[] = null;
byte b[] = new byte[1024];
int temp = 0;
try
{
// 读取 zip 文件
fis = new FileInputStream(zipFile);
// 创建解压输入流
zin = new ZipInputStream(fis);
while((z=zin.getNextEntry()) != null)
{
System.out.println("解压缩"+z.getName());
if(z.isDirectory())
{
String name = z.getName();
name = name.substring(0, name.length()-1);
File f = new File(dirFile+File.separator+name);
// 若是目录，则创建同名的目录
f.mkdir();
}else
{
File f = new File(dirFile+File.separator+z.getName());
// 创建同名的文件
f.createNewFile();
// 创建文件输出流
fout = new FileOutputStream(f);
while((temp=zin.read(b)) != -1)
{
fout.write(b,0,temp);
}
fout.close();
}
}
zin.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ------------------
ZipFile 类
可以表示一个压缩文件，用来读取一个 zip文件含的文件的进入点。
还可以表示取得某个进入点对应文件的输入流
// 打开可读的 ZipFile，由 file 参数指定的对象
public ZipFile(File file) throws ZipException, IOException
// 打开新的 ZipFile 以使用指定模式从指定File对象读取
public ZipFile() throws IOException
// 打开 ZipFile 进行阅读，由 name参数指定的对象
public ZipFile(String name) throws IOException
// 返回 zip 文件内所有的 entry枚举对象
public Enumeration<? extends ZipEntry> entries()
// 确保不再引用此 zip 文件时调用它的 close() 方法
protected void finalize() throws IOException
// =============
import java.io.File;
import java.io.IOException;
import java.util.zip.ZipFile;
public class Hi
{
public static void main(String[] args)
{
// 创建 ZipFile 实例
File f = new File("jj.zip");
try
{
ZipFile zip = new ZipFile(f);
System.out.println("文件名称："+zip.getName());
System.out.println("压缩文件内文件数："+zip.size());
System.out.println("文件大小："+f.length());
System.out.println("文件最后修改的时间："+f.lastModified());
zip.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ------------------
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class Hi
{
public static void main(String[] args)
{
// 自定义解压缩文件
File file = new File("ok.txt");
// 需要解压的 zip 文件
File zipFile = new File("java.zip");
InputStream in = null;
FileOutputStream fout = null;
ZipEntry entry = null;
ZipFile zip = null;
byte b[] = new byte[1024];
int temp = 0;
try
{
// 创建 zipFile实例
zip = new ZipFile(zipFile);
// 创建 zipentry 实例，并取得 zipentry 对象
entry = new ZipEntry("java.txt");
// 取得 zipentry 输入流
in = zip.getInputStream(entry);
fout = new FileOutputStream(file);
while((temp = in.read(b)) !=-1)
{
fout.write(b,0,temp);
}
zip.close();
fout.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// ==============
对象序列化
public interface Serializable
对象输出流： ObjectOutputStream
public class ObjectOutputStream extends OutputStream
implements ObjectOutput,ObjectStreamConstants
{
}
// 创建写入指定 OutputStream 的 ObjectOutputStream 对象
public ObjectOutputStream(OutputStream out) throws IOException
// 重置将丢弃已写入 流中的所有对象的状态
public void reset() throws IOException
// 将指定的对象写入 ObjectOutputStream
public writeObject(Object obj) throws IOException
// 将“末共享”对象写入 ObjectOutputStream
public void writeUnshared(Object obj) throws IOException
// 对象输出流 序列化
import java.io.Serializable;
public class Student implements Serializable
{
private String name;
private int age;
private String school;
public Student(){}
public Student(String name, int age, String school)
{
this.name = name;
this.age = age;
this.school = school;
}
public void tell()
{
System.out.println("名称:"+this.name+",年龄:"+this.age+",学校："+this.school);
}
}
//
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class Hi
{
public static void main(String[] args)
{
Student stu1 = new Student("小二", 21, "WC");
Student stu2 = new Student("去你的", 22, "YES");
// 定义保存文件
File file = new File("ObjectStudent.txt");
FileOutputStream fout = null;
ObjectOutputStream oos = null;
try
{
// 实例化文件输出流
fout = new FileOutputStream(file);
// 实例化对象输出流
oos = new ObjectOutputStream(fout);
//把对象写入输出流
oos.writeObject(stu1);
oos.writeObject(stu2);
oos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
// =================
对象输入流: ObjectInputStream
用于对对象反序列化操作
public class ObjectInputStream
extends InputStream
implements ObjectInput,ObjectStreamConstants
{
}
// 创建从指定 InputStream 读取的 ObjectInputStream 对象
public ObjectInputStream(InputStream in) throws IOException
// 从 ObjectInputStream 读取对象
public final readObject() throws IOException,ClassNotFoundException
// 从 ObjectInputStream 读取 “非共享”对象
public Object readUnshared() throws IOException
// ============
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Hi
{
public static void main(String[] args)
{
// 定义读取文件
File file = new File("ObjectStudent.txt");
FileInputStream fis = null;
ObjectInputStream ois = null;
try
{
// 实例化 FileInputStream
fis = new FileInputStream(file);
// 实例化 ObjectInputStream
ois = new ObjectInputStream(fis);
// 读取 stu1对象，需要强制转换
Student stu1 = (Student)ois.readObject();
//读取 stu2对象，需要强制转换
Student stu2 = (Student)ois.readObject();
ois.close();
stu1.tell();
stu2.tell();
}
catch (IOException e)
{
e.printStackTrace();
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
}
}
// ------------
Externalizable 接口
可以部分序列化
import java.io.Externalizable;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.IOException;
public class Student implements Externalizable
{
private String name;
private int age;
private String school;
public Student(){}
public Student(String name, int age, String school)
{
this.name = name;
this.age = age;
this.school = school;
}
public void tell()
{
System.out.println("名称："+this.name+",年龄："+this.age+",学校:"+this.school);
}
// 实现 writeExternal方法
public void writeExternal(ObjectOutput out) throws IOException
{
out.writeObject(this.name);
out.writeObject(this.school);
}
// 实现 readExternal 方法
public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
{
this.name = (String)in.readObject();
this.school = (String)in.readObject();
}
}
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Hi
{
public static void main(String[] args)
{
File file = new File("Exteralizable.txt");
// 对象序列化
serialize(file);
// 对象反序列化
deserialize(file);
}
public static void serialize(File file)
{
// 创建两实例
Student stu1 = new Student("小二", 21, "EC");
Student stu2 = new Student("好的", 22, "YES");
FileOutputStream fout = null;
ObjectOutputStream oos = null;
try
{
// 实例化文件输出流
fout = new FileOutputStream(file);
// 实例化对象输出流
oos = new ObjectOutputStream(fout);
//把对象写入输出流
oos.writeObject(stu1);
// 把对象写入输出流
oos.writeObject(stu2);
oos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static void deserialize(File file)
{
FileInputStream fis = null;
ObjectInputStream ois = null;
try
{
// 实例化 FileInputStream
fis = new FileInputStream(file);
// 实例化 ObjectInputStream
ois = new ObjectInputStream(fis);
// 读取 stu1,2对象，需要强行转换
Student stu1 = (Student)ois.readObject();
Student stu2 = (Student)ois.readObject();
ois.close();
stu1.tell();
stu2.tell();
}
catch (IOException e)
{
e.printStackTrace();
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
}
}
/*
名称：小二,年龄：0,学校:EC
名称：好的,年龄：0,学校:YES
可以看到，age没有被序列化
*/
// ====================
可使用 transient 声明不需要序列化的属性
import java.io.Serializable;
public class Student implements Serializable
{
private String name;
private transient int age;
private String school;
public Student(){}
public Student(String name, int age, String school)
{
this.name = name;
this.age = age;
this.school = school;
}
public void tell()
{
System.out.println("名称："+this.name+",年龄:"+this.age+",学校："+this.school);
}
}
// =============
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
