黑马程序员_java基础笔记第八天

 

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一 IO流
 1 定义
  1 用于处理设备间的数据传输。
  2 按类型分为两中字节流，字符流。
  3 按流向分为两种输出流输入流。
 
二 字符流：
 1 定义：
  1 凡是能用记事本打开能多懂得文件都可以用字符流。
  2 用于操作文本文件。
  3 大体分为读取流Reader,写入流Writer.

 2 Reader常见方法：
  1 read()
   一次多去以个字符。
  2 read(char[] arr )
   一次都取数组长度的字符存储到数组中。
  3 close()
   关闭关联文件。
  
 3 Writer常见方法：
  1 write()
   将数据写入流中一次写以个字符也就是两个字节。

  2 write(char [] arr,int start,int end)
   将数组中有小数据写到流中。

  3 flush()
   将写入到流中的数据刷到文件中。

  4 close()
   将关联文件关闭。

三 字符流例题：
1 读取指定文件到屏幕上。
public class Test{
 public static void main(String[] args)throws IOException {
 Reader rea=new FileReader("Test.java");
    int ch=fr.read();
   
     while（(ch=rea.read())!=-1）
    {
        System.out.println((char)ch);
    }
 rea.close();
}
}

2 复制文件:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
 public class Test{
  public static void main(String[] args) {
  Reader rea=null;
  Writer wri=null;
  try{
  rea=new FileReader("Test.java");
  wri=new FileWriter("Test1.javaq");
     int ch=rea.read();
      while((ch=rea.read())!=-1)
     {
         wri.write(ch);
  wri.flush();
     }}catch(IOException e)
     {
      e.printStackTrace();
     }
  finally{
   if(rea!=null)
   {
    try {
     rea.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   if(wri!=null)
   {
    try {
     wri.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }

 
 }
 
}

四 字节流：
 1 定义：
  1 字节流可以操作任意类型文件。
  2 大体分为InputStream,字节读取流，OutputStream季节写入流。

 2  InputStream常用方法：
  1 read()
   一次读取一个字节。

  2 read(byte[] b)
   一次读取数组长度的数据存到数组中。

  3 close()
   关闭相关联文件。

 3 OutPutStream常用方法：
  1 write(byte[] int start,int end)
   将数组内有效数据写到文件或控制台上。

  2 write()
   一次写入以个字节。
   
五 字节流练习：
1 复制图片

        FileOutputStream fw=null;
   FileInputStream fr=null;
   try {
    fos=new FileOutputStream("b.jpg");
    fis=new FileInputStream("a.jpg");
    byte[] buf=new byte[1024];
    int num=0;
    while ((num=fis.read(buf))!=-1){
    fis.write(buf,0,num);
    }
 }
   catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }
   finally
  {
     try {
                      if(fis!=null)
    fis.close();
   } catch (IOException e) {
    
    e.printStackTrace();
   }  
     
     try {
    fos.close();
   } catch (IOException e) {
    
    e.printStackTrace();
   }  
  }

六 缓冲区流：
 1 定义：
  1 字节流字符流都有各自的缓冲区流。 
  2 是他们的包装类。
  3 也称为高效流，将读取来的，或写如的数据存起来，到一定数目一起传输过去。
 2 种类及方法的使用：
  1 BufferedWrite字符高效写入流。
    newLine()
    写入换行符任意平台都识别。
  2 BufferedReader字符高效读取流。
    readerLine();
    一次读取一行不读取换符。
    
  3 BufferedOutoutStream字节高效写入流。 

  4 BufferedInputStream字节高效读取流。
   available()
    获取数据的总长度。
 
七 高效流例题：
1 使用高效流复制mp3文件。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test6 {

 public static void main(String[] args) {
  
  copyFile("d:\\1.mp3", "1.mp3");
  
 }

 private static void copyFile(String target, String destination) {
 
 
  BufferedInputStream bin=null; 
  BufferedOutputStream bou=null;
  try{
  //建立读取缓冲流对象包装文件读取流对象
  bin=new BufferedInputStream(new FileInputStream(target));
  
  //建立写入缓冲流对象包装文件写入流对象
  bou=new BufferedOutputStream(new FileOutputStream(destination));
  
  //创建数组初始化为1024
  byte[] b=new byte[1024];
  int x=0;
  
  //每次读取数据存储到数组内，无数据返回-1
  while((x=bin.read(b))!=-1)
  {
   //将数组内的有效数据写入目的地文件内
   bou.write(b,0,x);
  
  }}
  catch(IOException e)
  {
   e.printStackTrace();
  }
  finally
  {
   //如果bin不为空关闭bin流对象，为空会空指针异常
   if(bin!=null)
   {
    try {
     bin.close();
    } catch (IOException e) {

     e.printStackTrace();
    }
   }
   
   //如果bou不为空关闭bou流对象，为空会空指针异常
   if(bou!=null)
   {
    try {
     bou.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }

  }
 }
}

2 自定义缓冲区。
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

class MyBufferedInputStream{
 private InputStream in;
 private byte[] buf =new byte[1024];
 private int pos;
 private int count;
 
 MyBufferedInputStream(InputStream in)
 {
  this.in=in;
 }

public int myRead()throws IOException{

 if(count==0)
 {
  count=in.read(buf);
  
  if(count<0)
   return -1;

  pos=0;
  byte b = buf[pos];
  pos++;
  count--;
  return b&255;

 }
 else if(count>0)
 {
  byte b = buf[pos];
  pos++;
  count--;
 return b&0xff;
 }
 return -1;
}

public void myClose()throws IOException
{
 in.close();
}
}

public class Test{
 
public static void main(String...args) throws IOException{
 long start = System.currentTimeMillis();
 copy();
 long end = System.currentTimeMillis();
 System.out.println(end-start);
}

public static void copy()throws IOException
{
MyBufferedInputStream bufis = new MyBufferedInputStream 
 (new FileInputStream("C:\\1.avi"));

BufferedOutputStream bufos = new BufferedOutputStream
 (new FileOutputStream("C:\\2.avi"));

 for(int len=0;(len=bufis.myRead())!=-1;)
  {
  bufos.write(len);
  }

 bufis.myClose();
 bufos.close();
 }

}

八 LineNumberReader
 1 定义：
  带有行号的缓冲区
2 例题读取文件带行数打印到控制台上。

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class bao {
public static void main(String[] args) throws IOException {
 FileReader fr=new FileReader ("a.txt");

 LineNumberReader lnfr=new LineNumberReader (fr);

 String line=null;
  while((line=lnfr.readLine())!=null)
  {
   String s=line;
   int num=lnfr.getLineNumber();
   System.out.println(num+":"+s);
  }

 lnfr.close();
}
}

九字符转换流OutputStreamWriter：
 1 定义
  1 将字符数据以字节的形式写出去。
  2 字符通向字节的桥梁。 
 2 字符转换流例题：
1 应用字符转换流录入输出到屏幕上
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class Test{
public static void main(String[] args) throws IOException {

 BufferedWriter bw=new BufferedWriter(
   new OutputStreamWriter(System.out));
 for(int x=0;x<5;x++)
 {
  bw.write(x+"");
 
 }
 
 bw.close();
}

十 字节转换流OutputStreamReader：
 1 定义
  
  1 字节通向字符的桥梁。 
 2 字符转换流例题：
1 读取键盘录入打印到控制台上：

public class Test {
 public static void main(String[] args) throws IOException {
  BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));
   String str=null;
   while((str=buff.readLine())!=null)
   {
    System.out.println(str);
   }buff.close();
 }
}r.close;
}

十一 File类;
 1 定义：
  1 用来描述文件和文件夹的类。
 2 构造方法：
  构造方法摘要
   1 File(File parent, String child)
             根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
   2 File(String pathname)
             通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
   3 File(String parent, String child)
             根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
 3 常用方法：
  1 exists()
    判读文件时否存在。
  2 getAbsoluteFile()
   获取绝对路径。
  3 getName()
   获取文件的名字。
  4 getPath()
   将抽象路径转换为字符串。
  5 isDirectory()
   判断是不是文件夹。
  6 isFile
   判断是不是文件。
  7 list()
   返回一个目录下所有文件盒文件夹名的字符串表现形式。
  8 listFiles()
   返回该目录下的虽有文件和文件夹的对象。
  9 listFiles(FilenameFilter filter)
   返回给定要求的该目录下的虽有文件和文件夹的对象。
  10 delete()
   删除文件或文件夹。京剧界
十二 File例题：
1 打印指定目录下满足.java格式的锁有文件。

import java.io.File;
import java.io.FilenameFilter;

public class Test{
public static void main(String[] args) {
 File[] f=show(new File("e:\\day"));
 for(File ff:f)
 {
  System.out.println(ff.getName());
 }
}
public static File[] show(File f)
 {
  File[] ff=f.listFiles(new FilenameFilter(){
   public boolean accept(File f,String name){
   File fff=new File(f,name);
   return fff.isFile()&&fff.getName().endsWith(".java");    
   }
  });
  return ff;
 }
}

2 或取指定目录下的所有问加你啊内的.java文件。
import java.io.File;

public class Test{
public static void main(String[] args) {
 show(new File("d:\\"));
}
public static void show(File str)
 {
  File[] f2=str.listFiles();
  for(File f3:f2)
  {
   if(f3.isDirectory()&&!f3.isHidden())
   {
    show(f3);
   }
   if(f3.getName().endsWith(".java")) 
    System.out.println(f3.getName());
  }
  
 }
}

十三 Properties
 1 定义：
  1 与io流相关的集合。
  2 用于配置文件。
  3 是以键值对形象存储的。

 2 常见方法：
  1 load()
   将数据存入集合。
  2 list()
   将集合那内的数据写到文件中。

十四 序列化流
 1 定义：
  1 将对象存储到文件中。
  2 保持对象的持久化。
  3 分为ObjectInputStream对象读取流，ObjectOutputStream对象写入流。
  4 要序列化的类必须实现
十五 序列化例题：
 将对象存储到文件再取出。
public class Test {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
 
 ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("object.txt"));
 Student s=new Student("张三",12);
 
 os.writeObject(s);
 os.flush();
 ObjectInputStream oi=new ObjectInputStream(new FileInputStream("object.txt"));
 Object obj=(Student)oi.readObject();
 System.out.println(obj);
 os.close();
 oi.close();
}
}
 
十六 打印流PrintWriter,PrintStream 
 1 定义：
  1 他们是为其他输出流添加了功能。
  2 永远不会抛异常。
  3 可以指定编码表。
  4 当够方法如需自动刷新为true时，println() 可以自动换行和自动刷新。
  

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------