黑马程序员_java基础部分_IO流二

------- android培训、java培训、期待与您交流！ ----------

对IO的总结二

1.         File类常见方法：

1，创建。

         boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

                                               和输出流不一样，输出流对象一建立,就创建文件了，而且文件已经存在，会覆盖。

         boolean mkdir():创建文件夹。

         boolean mkdirs():创建多级文件夹。

2，删除。

         boolean delete()：删除失败返回false，如果文件正在被使用，则删除不了，返回false。

         void deleteOnExit();在程序退出时删除指定文件。

3，判断。

         boolean exists() :文件是否存在.

         isFile():

         isDirectory();相对路径，就是默认的路径；

         isHidden();

         isAbsolute();绝对路径，他文件是否存在，都为true，只要带着盘符就可以；

4，获取信息。

         getName():

         getPath():

         getParent():

         getAbsolutePath()

         long lastModified()

         long length()

5，f2.renameTo(f1)修改文件的名称

2.         创建file对象的方法有三种；

//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。

File f1 = new File("a.txt");

//路径名，加上文件名；

File f2 = new File("c:\\abc","b.txt");

 

File d = new File("c:\\abc");

File f3 = new File(d,"c.txt");

3.         用过滤的方法来获取文件的信息

File dir = new File("d:\\java1223\\day18");

//这个是获取的是字符串传入的是内部类对象；

String[] arr = dir.list(new FilenameFilter()

{

//它的返回结果，决定着过滤条件；

public boolean accept(File dir,String name)

{

return name.endsWith(".bmp");

}

});

System.out.println("len:"+arr.length);

 

// 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

//返回所有的文件名；包括文件和文件夹；

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]);

}

}

4.         打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

代码如下，可以直接打印到文件当中；

//键盘录入；转换流；

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

FileWriter fw = new FileWriter("a.txt");

// 接收一个流对象；true具有刷新缓冲区的功能。

//创建新 PrintWriter.打印到文件当中；

PrintWriter out = new PrintWriter(fw,true);

String line = null;

while((line=bufr.readLine())!=null)

{

if("over".equals(line))

break;

//打印到相应的文件中，这里我们打印到a.txt中；

//这里调用打印流；打印到的目的地；

out.println(line.toUpperCase());

}

out.close();

bufr.close();

5.         Properties是hashtable的子类。

也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

这个类里面有键值对的集合。

Properties prop = new Properties();

与文件相关联；

FileInputStream fis = new FileInputStream("info.txt");

将流中的数据加载进集合。

prop.load(fis);

这里修改了流中的数据源的数据，所以我们还要写到文件中，修改文件中的数据；

prop.setProperty("wangwu","39");

FileOutputStream fos = new FileOutputStream("info.txt");

写入到文件中，haha是文件的注释；

prop.store(fos,"haha");

System.out.println(prop);

列出所有的数据；

prop.list(System.out);

fos.close();

fis.close();

6.         文件的切割和合并；

//这个集合比Vector要高效。

ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

//3个碎片；流添加到集合中；

for(int x=1; x<=3; x++)

{

al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));

}

//通过迭代器的方式来获得枚举类型的引用；和枚举类型的引用相关联；

final Iterator<FileInputStream> it = al.iterator();

//               这个是一个内部类的方式，获取对象；

Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()

{//复写里面的2个方法；

public boolean hasMoreElements()

{

return it.hasNext();

}

public FileInputStream nextElement()

{

return it.next();

}

};

//SequenceInputStream 表示其他输入流的逻辑串联。

//它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，

//接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

//它的参数类型必须接受一个枚举类型的输入流参数；

SequenceInputStream sis = new SequenceInputStream(en);

//将碎片合并成一个文件；

FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

byte[] buf = new byte[1024];

int len = 0;

while((len=sis.read(buf))!=-1)

{

fos.write(buf,0,len);

}

fos.close();

sis.close();                

7.         用于操作字节数组的流对象。

ByteArrayInputStream ：

在构造的时候，需要接收数据源，而且数据源是一个字节数组。

ByteArrayOutputStream：

在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。

所以，不用进行close关闭。

在流操作规律讲解时：

源设备，

         键盘 System.in，硬盘 FileStream，内存 ArrayStream。

目的设备：

         控制台 System.out，硬盘FileStream，内存 ArrayStream。

用流的读写思想来操作数据。

同理还有

CharArrayInputStream

CharArrayOutputStream是一样的用法；

还有StringReader和StringWriter也是一样的用法；

8.         DataInputStream与DataOutputStream

可以用于操作基本数据类型的数据的流对象。

修改版的utf-8和标准版的utf-8，区别是编码有些不同

DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

dos.writeInt(234);//4个字节

dos.writeBoolean(true);//1个字节

dos.writeDouble(9887.543);//8个字节

dos.close();

可以直接写data类型的数据；

 

另外它还可以写修改版的utf_8数据；               

DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));

// 修改版的utf-8  用它写数据，就要用dis.readUTF()读数据；

dos.writeUTF("你好");

9.         编码：字符串变成字节数组。

解码：字节数组变成字符串。

//控参数是默认的编码表;

String-->byte[];  str.getBytes(charsetName);

byte[]-->String: new String(byte[],charsetName);

代码

String s = "哈哈";

//默认编码形式;加密;

byte[] b1 = s.getBytes("GBK");

//把数组变成字符串打印出来;打印出来的是一些字节;如-12,-34.等等;

System.out.println(Arrays.toString(b1));

//解码;将字节数组变成字符串;

String s1 = new String(b1,"ISO8859-1");

System.out.println("s1="+s1);

//对s1进行iso8859-1编码。

//我们进行编码,拿到重新拿到数据.再打印出来;应用就是tomcat服务器里面就是ISO8859-1;

//注意这里不能用utf-8做同样的效果;

byte[] b2 = s1.getBytes("ISO8859-1");

System.out.println(Arrays.toString(b2));

String s2 = new String(b2,"gbk");

//还原了我们的数据

System.out.println("s2="+s2);

10.     //读取对象文件的方法，读取写入的文件；

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

//读取的方法；

Person p = (Person)ois.readObject();

System.out.println(p);

ois.close();            

11.     //Serializable序列化，它里面没有方法，所以又叫标记性接口；

//注意；序列号是根据成员获取出来的；uid。我们要自己生成uid那么再改动代码的时候，就不会找不到了；

class Person implements Serializable

{

//这个是给类定义一个固定表示，为了序列化方法,本类改变，可以可以操作旧的序列化对象；

public static final long serialVersionUID = 42L;

12.     //输入管道流和输出管道流，进行连接操作；局部变量必须被初始化；

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();

13.     RandomAccessFile

该类不是算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

 

其实完成读写的原理就是内部封装了字节输入流和输出流。

 

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，读写rw等。

 

如果模式为只读 r。不会创建文件，会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存在，则不会覆盖。

 

应用；

下载软件原理；

用不同的线程分段数据写入；多个线程同时写入数据不会出错误；

一般流，是从头往后写数据；要是多个线程同时写数据，会出错误；

/**

* 随机写数据。很牛；写入数据到任何位置；可以修改任意文件；

* 修改文件的方式，就是写入到应该修改文件的位置，直接把原位置的元素给冲掉了；

* @throws IOException

*/

public static void writeFile_2()throws IOException

{

RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

raf.seek(8*0);

raf.write("周期".getBytes());

raf.writeInt(103);

raf.close();

}

14.     写文件；writeInt和write的区别；

* writeInt。写入的是32位字节；

* write写的是8位字节；

* 用write容易丢失数据；