四、File类
01、概述
(1) 用来将文件或者文件夹封装成对象
(2) 方便对文件与文件夹进行操作
(3) File对象可以作为参数传递给流的构造函数
02、File类的常见方法
(1)创建。
— Boolean createNweFile();在指定位置创建文件,如果该文件已经存在,则不创建,返回false。和输出流不一样,输出流对象一建立创建文件。而且文件已经存在,会覆盖。
— boolean mkdir();创建文件夹。
— boolean mkdirs();创建多级文件夹。
(2)删除。
Booleandelete();删除失败返回false。如果文件正在被使用,则删除不了返回falsel。
VoiddeleteOnExit();在程序退出时删除指定文件。
(3)判断。
boolean exists();文件是否存在。
isFile();
isDirectory();
isHidden();
isAbsolute();
(4)获取信息。
getName();
getPath();
getParent();
getAbsolutePath();
long lastModified();
long length();
03、 练习
(1)列出目录下所有内容
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("F:\\java\\IO");
showDir(dir,0);
//thbin(6);
//int n = getSum(100);
//System.out.println("n="+n);
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("!--");
for(int x=0;x<level;x++)
{
//sb.append(" ");
sb.insert(0,"! ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}
public static int getSum(int n)
{
if(n==1)
return 1;
return n+getSum(n-1);
}
public static void toBin(int num)
{
if(num>0)
{
toBin(num/2);
System.out.println(num%2);
}
}
}
(2)删除带内容的目录
删除原理:
在Window中,删除目录从里面往外删除的。所以用到递归。
例子:
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File dir = new File("F:\\java\\IO\\3\\123");
removeDir(dir);
}
public static void removeDir(File dir)
{
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
removeDir(files[x]);
System.out.println(files[x].toString()+":"+files[x].delete());
}
System.out.println(dir+"::dir::"+dir.delete());
}
}
04、创建java文件列表
/*
练习
将一个指定目录下的java文件的绝对路径,存储到一个文本文件中。
建立一个java文件列表文件。
思路;
1,对指定的目录进行递归。
2,获取递归过程所以的java文件的路径。
3,将这些路径存储到集合中。
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args) throws IOException
{
File dir = new File("f:\\java\\IO\\3");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
File file = new File(dir,"javalist.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir,List<File> list)
{
//获取路径
File[] files = dir.listFiles();
for(File file : files)
{
//判断是否是文件夹
if(file.isDirectory())
fileToList(file,list);
else
{
//判断后缀名为.java的文件
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
public static void writeToFile(List<File> list,String javaListFile) throws IOException
{
BufferedWriter bufw = null;
try
{
bufw = new BufferedWriter(new FileWriter(javaListFile));
for(File f : list)
{
String path = f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw e;
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw e;
}
}
}
}
05、Properties
(1) 概述
Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。该对象的特点:可以用于键值对形式的配置文件。那么在加载数据时,需要数据有固定格式:键=值。
(2) Properties存取配置文件,例子
import java.io.*;
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
loadDemo();
}
public static void loadDemo() throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");
//将数据加载进集合
prop.load(fis);
//只在内在中修改数据并没有保存到文件
prop.setProperty("dashen2","98");
FileOutputStream fos = new FileOutputStream("info.txt");
//将修改的信息保存到指定的目标,并添加注释信息。
prop.store(fos,"haah");
//将属性列表输出到指定的输出流。
prop.list(System.out);
fos.close();
fis.close();
}
//演示,如何将流中的数据存储到集合中。
//想要将info.txt中键值数据丰到集合中进行操作。
/*
1,用一个流和info.txt文件关联。
2,读取一行数据,将该行数据用“=”进行切割。
3,等号左边作为键,右边作为值。存入到Properties集合中即可。
*/
public static void method_1() throws IOException
{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while ((line=bufr.readLine())!=null)
{
//读取一行数据,将该行数据用“=”进行切割。
String[] arr = line.split("=");
//等号左边作为键,右边作为值。存入到Properties集合中
prop.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(prop);
}
//设置和获取元素
public static void setAndGet()
{
Properties prop = new Properties();
prop.setProperty("laozi","23");
prop.setProperty("dashen","39");
//String value = prop.getProperty("dashen");
Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
System.out.println(s+":"+prop.getProperty(s));
}
prop.stringPropertyNames();
}
}
五、IO包中的其他类
01、打印流-可以直接操作输入流和文件。
(1)字节打印流PrintStream:
构造函数可以接收的参数类型:
— file对象。File
— 字符串路径。String
— 字节输出流。OutputStream
(2)字符打印流PrintWriter:
构造函数可以接收的参数类型:
— file对象。File
— 字符串路径。String
— 字节输出流。OutputStream
— 字符输出流。writer
02、序列流-SequenceInputStream:对多个流进行合并。实现例子如下
import java.io.*;
import java.util.*;
class SequenceDemo
{
public static void main(String[] args) throws IOException
{
//创建Vector文件集合
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
//将Vector集合转成Enumeration集合
Enumeration<FileInputStream> en = v.elements();
//将Enumeration对象传入,将多个文件的读写流合并成一个大的读写流
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("4.txt");
byte[] buf = new byte[1024];
int len = 0;
while ((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
03、操作对象-ObjctInputStream与ObjectOutputStream
(1) 被操作的对象需要实现Serializable(标记接口);
(2) 实现例子
import java.io.*;
class ObjectStreamDemo
{
public static void main(String[] args) throws Exception
{
writeObj();
readObj();
}
public static void readObj() throws Exception
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Person.object"));
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void writeObj() throws IOException
{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Person.object"));
oos.writeObject(new Person("lisi",39,"88952"));
oos.close();
}
}
04、RandomAccessFile
(1) 随机访问文件,自身具备读写的方法。
(2) 通过skipBytes(int x),seek(int x)来达到随机访问。
(3) 该类不是IO体系中子类,而是直接继承自Object。但是他是IO包中成员,因为它具备读和写功能。内部封装了一个数组,而且通过指针对数组的的元素进行操作。可以通过getFilePointer获取指针位置,同时可以通过seek改变指针的位置。其实完成读写的原理就是内部封闭了字节输入流和输出流。
(4) 通过构造函数可以看出,该类只能操作文件。而且操作文件还有模式:只读r,读写rw等。如果模式为只读 r,不会创建文件。会去读取一个已存在文件,如果该文件不存在,则会出现异常如果模式rw,操作的文件不存在,会自动创建,如果存在则不会覆盖。
(5) 实现例子
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
writeFile_2();
writeFile();
readFile();
}
public static void writeFile_2()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("haha.txt","rw");
raf.seek(8*3);
raf.write("张三".getBytes());
raf.writeInt(103);
raf.close();
}
public static void readFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("haha.txt","r");
//调整对象中指针
//raf.seek(8);
//跳过指定的字节数,不能往前跳,只能往后跳。
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
raf.close();
}
public static void writeFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("haha.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(88);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}
04、管道流
(1) PipedInputStream和PipedOutputStream
— 输入输出可以直接进行连接,通过结合线程使用
— 实现例子:
import java.io.*;
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
byte[] buf = new byte[1024];
int len = in.read(buf);
String s = new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道流读取失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
out.write("piped管道来啦!".getBytes());
out.close();
}
catch (IOException e)
{
throw new RuntimeException("管道流输出失败");
}
}
};
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
};
05、操作基本数据类型-DataInputStream与DataOutputStream
(1) 可以用于操作基本数据类型的数据的流对象。
(2) 实现例子
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args) throws IOException
{
writeData();
readData();
writeUTFDemo();
readUTFDemo();
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//osw.write("你好");
//osw.close();
}
public static void readUTFDemo()throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("utfdata.txt"));
String s = dis.readUTF();
System.out.println(s);
dis.close();
}
public static void writeUTFDemo()throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdata.txt"));
dos.writeUTF("你好");
dos.close();
}
public static void readData()throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
System.out.println("num="+num);
System.out.println("b="+b);
System.out.println("d="+d);
}
public static void writeData() throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(123);
dos.writeBoolean(true);
dos.writeDouble(98.574);
dos.close();
}
}
06、操作字节数组-ByteArrayInputStream与ByteArrayOutStream
(1) ByteArrayInputStream: 在构造时候需要接收数据源,而且数据源是一个字节数组。
(2) ByteArrayOutputStream: 在构造的时候,不用定义数据目的,因为该对象中已经内部封闭了可变长度的字节数组。这就是数据目的地。
(3) 因为这两个流对象都操作的数组,并没有使用系统资源。所以,不用进行close()关闭。
(4) 实现例子
import java.io.*;
class ByteArrayStream
{
public static void main(String[] args)
{
//数据源。
ByteArrayInputStream bis = new ByteArrayInputStream("AGSDGEWRGRE".getBytes());
//数据目的
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by = 0;
while ((by=bis.read())!=-1)
{
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
}
}
06、操作字符数组-CharArrayReader与CharArrayWrite
07、操作字符串-StringReader与StringWriter
六、字符编码
1、概述
(1)字符流的出现为了方便操作字符。
(2)更重要的是加入了编码转换。
(3)通过子类转换流来完成。
—InputStreamReader
— OutputStreamWriter
(4)在两个对象筛选构造的时候可以加入字符集。
2、编码表的由来
计算机只能识别二进制数据,早期由来是电信号。为了方便应用计算机,让它可以识别各个国家的文字。就将各个国家的文件用数字来表示,并一一对应,形成一张表。这就是编码表
3、常见的编码表
(1)ASCLL:美国标准信息交换码。用一个字节的7位可以表示。
(2)ISO8859-1:拉丁码表、欧洲码表。用一个字节的8位表示。
(3)GB2312:中国的中文编码表。
(4)GBK; 中国的中文编码表升级,融合了更多的中文文字符号。
(5)Unicode:国际标准码,整合了多种文字。所有文字都用两个字节来表示,Java语言使用的就是unicode
(6)UTF-8:最多用三个字节来表示一个字符。
4、编码与解码
(1)编码:字符串变成字节数组。
(2)解码:字节数组变成字符串。
(3)实现例子
import java.util.*;
class EncodeDemo
{
public static void main(String[] args) throws Exception
{
String s = "哈哈";
byte[] b1 = s.getBytes("GBK");
System.out.println(Arrays.toString(b1));
String s1 = new String(b1,"utf-8");
System.out.println("s1="+s1);
//对s1进行IOS8859-1编码
byte[] b2 = s1.getBytes("utf-8");
System.out.println(Arrays.toString(b2));
String s2 = new String(b2,"bgk");
System.out.println("s2="+s2);
}
}