黑马程序员_IO流

最新推荐文章于 2019-08-21 17:47:15 发布
最新推荐文章于 2019-08-21 17:47:15 发布
阅读量545 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010016264/article/details/8797781
版权

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

 
一、概述
     文件通常是由一连串的字节或字符构成，组成文件的字节序列称为字节流；组成文件的字符序列称为字符流。Java 中根据流的方向可以分为输入流和输出流。输入流是将文件或其它输入设备的数据加载到内存的过程；输出流恰恰相反，是将内存中的数据保存到文件或其他输出设备。

     IO流泛指对某个设备或环境进行数据的数据或输出。
     数据的最常见体现形式是：文件。
InputStream 和OutputStream（字节流 ）

Reader 和Writer（字符流）
     
二、文件流
     1、FileWriter(文件字符输入流)
          创建文件
          
package   com.File;

import   java.io.*;

public   class   FileWriterDemo {

      public   static   void   main(String[] args){
             //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
          FileWriter fw =   null ;
          
             try   {
                 //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
                 //其实该步就是在明确数据要存放的目的地。
              fw =   new   FileWriter( "demo.txt"   );
              
                 //如果想对已有文件进行数据续写，创建文件时传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
                 //fw = new FileWriter("demo.txt",true);
                 //调用write方法，将字符串写入到流中。
              fw.write(   "JAVA Hello" );
          }   catch   (IOException e) {
              
              System.   out .println( "catch:"   +e.toString());
          }   finally {
              
                      try   {
                           //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
                           //将数据刷到目的地中。
                           //fw.flush();
                           //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
                           if (fw !=   null   )
                             fw.close();
                   }   catch   (IOException e) {
                        
                        System.   out .println(e.toString());

          }
          
     }

}
     
          既然close方法也可以刷新缓冲区，为什么，还要专门有一个flush方法。

               jvm占用空间有限，不可能让一个比较大的数据完毕后，才刷新缓冲区。

          close方法和flush方法的区别？

              flush:刷新缓冲区，流对象还可以继续使用。
              close:先刷新缓冲区，然后释放资源。流对象不可以被使用了

     
     2、FileReader（文件字符输入流）
          
package   com.File;

import   java.io.*;

public   class   FileReaderDemo {

     
      public   static   void   main(String[] args) {
             //创建一个文件读取流对象，和指定名称的文件相关联。
             //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
          FileReader fr =   null ;
             try   {
              fr =   new   FileReader(   "demo.txt" );
              
                 //定义一个字符数组。用于存储读到字符。
                 //该read(char[])返回的是读到字符个数。
                 char [] buf =   new       char [1024];
                 int   ch = 0;
                 //调用读取流对象的read方法。
                 //read():一次读一个字符。而且会自动往下读。
                 while ((ch=fr.read(buf))!=-1){
                      //将char数组有效部分转换成字符串
                   System.   out .println( new   String(buf,0,ch));
              }
          }   catch   (FileNotFoundException e) {
              
              System.   out .println(e.toString());
          }   catch   (IOException e) {
                 //   TODO   Auto-generated catch block
              System.   out .println(e.toString());
          }   finally {
                 if (fr !=   null   )
                      try   {
                        fr.close();
                   }   catch   (IOException e) {
                        
                        System.   out .println(e.toString());
                   }
          }
     }

}

     3、FileInputStream（文件字节输入流）和FileOutStream（文件字节输出流）
          基本操作和字符流类型相同，但它不仅可以操作字符，还可以操作其他媒体文件，例如Copy一个Jpg或者Mp3文件。字节流可以不用刷新，因为数据的最基本单位就是字节，所以，可以直接把字节数据写入文件。

     需求：将一个文本文件复制一份。

          
package   com.File;

import   java.io.*;

public   class   CopyDemo {

      public   static   void   main(String[] args)   throws   IOException {
             //   TODO   Auto-generated method stub
           copy_1();
           copy_2();
     }
      //字节方法
      private   static   void   copy_2()   throws   IOException {
             //创建输入流
          FileInputStream fis =   new   FileInputStream( "demo.txt"   );

             //创建输出流
           FileOutputStream fos =   new   FileOutputStream( "demo_2.txt" );
          
             byte [] bytes =   new   byte [1024];
             int   num = 0;
             while ((num=fis.read(bytes)) != -1){
              fos.write(bytes,0,num);
          }
     }
      //字符方法
      private   static   void   copy_1()   throws   IOException {
          
          FileReader fr =   null ;
          FileWriter fw =   null ;
          
          fr =   new   FileReader( "demo.txt"   );
          fw =   new   FileWriter( "demo_1.txt"   );
              
             char [] chars =   new   char [1024];
             int   num = 0;
              
             while ((num = fr.read(chars)) != -1){
              fw.write(chars,0,num);
              
          }    
          fw.flush();
     
          fr.close();
          fw.close();
     
     }
     
}
     
三、缓冲流
      为了提高效率而存在的， 减少物理读取次数， 缓冲流主要有： BufferedInputStream 、BufferedOutputStream 、BufferedReader 、BufferedWriter ， 并且 BufferedReader 提供了实用方法readLine()，可以直接读取一行，BufferWriter 提供了newLine() 可以写换行符。

     1、 采用字符缓冲流改造文件复制代码
     
package   com.File;

import   java.io.*;

public   class   CopyDemo02 {

      public   static   void   main(String[] args)   throws   IOException {
          
           copy_1();
     }
     
      //字符方法
      private   static   void   copy_1()   throws   IOException {
          
          BufferedReader br =   null ;
          BufferedWriter bw =   null ;
          
          br =   new   BufferedReader( new   FileReader( "demo.txt"   ));
          bw =   new   BufferedWriter( new   FileWriter( "demo_b1.txt"   ));
              
          
          String num =   null ;
              
             while ((num = br.readLine()) !=   null ){
              bw.write(num);
              bw.newLine();
              
          }    
     
          br.close();
          bw.close();
     
     }
     
}


     2、装饰设计模式：

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。

装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类于类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

例：
package   com.File;

import   java.io.*;
class   MyBufferedReader   extends   Reader
{
     
      private   Reader   r ;
     MyBufferedReader(Reader r)
     {
             this . r   = r;
     }
     
      //模拟一下BufferedReader的readLine方法
      //可以一次读一行数据的方法。
      public   String myReadLine()   throws   IOException
     {
             //定义一个临时容器。原BufferReader封装的是字符数组。
             //为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
          StringBuilder sb =   new   StringBuilder();
             int   ch = 0;
             while ((ch= r   .read())!=-1)
          {
                 if (ch== '\r'   )
                      continue ;
                 if (ch== '\n'   )
                      return   sb.toString();
                 else
                   sb.append((   char )ch);
          }

             if (sb.length()!=0)
                 return   sb.toString();
             return   null   ;       
     }

      /*
     覆盖Reader类中的抽象方法。

     */
      public   int   read( char   [] cbuf,   int   off,   int   len)   throws   IOException
     {
             return   r   .read(cbuf,off,len) ;
     }

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

package  com.File;

import  java.io.*;

//装饰类
class  MyLineNumberReader  extends  MyBufferedReader
{
       private   int   lineNumber  ;
     MyLineNumberReader(Reader r)
     {
            super  (r);
     }
       //增强myReadLine方法，为其增加行号
       public  String myReadLine()  throws  IOException
     {

            lineNumber  ++;
            return   super  .myReadLine();
     }
       public   void  setLineNumber(  int  lineNumber)
     {
            this  . lineNumber  = lineNumber;
     }
       public   int  getLineNumber()
     {
            return   lineNumber  ;
     }
}

public   class    MyLineNumberReaderDemo
{
       public   static   void  main(String[] args)  throws  IOException
     {
          FileReader fr =  new  FileReader( "AbstractDemo.java"  );

          MyLineNumberReader mylnr =  new  MyLineNumberReader(fr);

          String line =  null  ;
            //mylnr.setLineNumber(100);//设置行号的初始值
            while  ((line=mylnr.myReadLine())!=  null )
          {
               System.  out  .println(mylnr.getLineNumber()+ "::"  +line);
          }

          mylnr.myClose();
     }
} 
LineNumberReader(Reader in)//使用默认输入缓冲区的大小创建新的行编号 reader。LineNumberReader此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。

四、转换流
       主要有两个:
            InputStreamReader 主要是将字节流输入流转换成字符输入流
            OutputStreamWriter 主要是将字节流输出流转换成字符输出流

     1、 InputStreamReader  。需求：将键盘录入的字节流转换成字符流
     
package   com.File;

import   java.io.*;

public   class   TransStreamDemo {

      public   static   void   main(String[] args)   throws   IOException {
             //获取键盘录入对象。
          InputStream in = System.   in ;

             //将字节流对象转成字符流对象，使用转换流。InputStreamReader
          InputStreamReader isr =   new   InputStreamReader(in);
             //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
          BufferedReader bufr =   new   BufferedReader(isr);
          
          String line =   null ;
             while ((line=bufr.readLine())!= null ){
                 if ( "over"   .equals(line)){
                      break ;
              }
              System.   out .println(line.toUpperCase());
              
          }
          bufr.close();
     }

}


     2、   OutputStreamWriter
package   com.File;

import   java.io.*;

public   class   TransStreamDemo {

      public   static   void   main(String[] args)   throws   IOException {
             //获取键盘录入对象。
             //InputStream in = System.in;

             //将字节流对象转成字符流对象，使用转换流。InputStreamReader
             //InputStreamReader isr = new InputStreamReader(in);
             //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
             //BufferedReader bufr = new BufferedReader(isr);
          
          BufferedReader bufr =   new   BufferedReader( new   InputStreamReader(System. in   ));
          
             //OutputStream out = System.out;
             //OutputStreamWriter osw = new OutputStreamWriter(out);
          
             //BufferedWriter bufw = new BufferedWriter(osw);// 为使用newLine
          
          BufferedWriter bufw =   new   BufferedWriter( new   OutputStreamWriter(System. out   ));
          
          String line =   null ;
             while ((line=bufr.readLine())!= null ){
                 if ( "over"   .equals(line)){
                      break ;
              }
              bufw.write(line.toUpperCase());
              bufw.newLine();
                 //字符输出有缓存区，需要flush
              bufw.flush();
              
          }
          bufr.close();
     }

}


五、 流操作的基本规律

     通过三个明确来完成:
1，明确源和目的。
     源：输入流。InputStream  Reader
     目的：输出流。OutputStream  Writer。
2，操作的数据是否是纯文本。
     是：字符流。
     不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。
     通过设备来进行区分：
     源设备：内存，硬盘。键盘
     目的设备：内存，硬盘，控制台。
     
1、需求分析：将一个文本文件中数据存储到另一个文件中。复制文件。

            源：因为是源，所以使用读取流。InputStream Reader 
     是不是操作文本文件。
     是！这时就可以选择Reader
     这样体系就明确了。
     接下来明确要使用该体系中的哪个对象。
     明确设备：硬盘。上一个文件。
     Reader体系中可以操作文件的对象是 FileReader
     是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

     FileReader fr = new FileReader("demo.txt");
     BufferedReader bufr = new BufferedReader(fr);



     目的：OutputStream Writer
     是否是纯文本。
     是！Writer。
     设备：硬盘，一个文件。
     Writer体系中可以操作文件的对象FileWriter。
     是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter
    
     FileWriter fw = new FileWriter("b.txt");
     BufferedWriter bufw = new BufferedWriter(fw);

     2、需求：将键盘录入的数据保存到一个文件中。

     源：InputStream Reader
     是不是纯文本？是！Reader
    
     设备：键盘。对应的对象是System.in.
     不是选择Reader吗？System.in对应的不是字节流吗？
     为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
     所以既然明确了Reader，那么就将System.in转换成Reader。
     用了Reader体系中转换流,InputStreamReader
     InputStreamReader isr = new InputStreamReader(System.in);
     需要提高效率吗？需要！BufferedReader
     BufferedReader bufr = new BufferedReader(isr);


     目的：OutputStream  Writer
     是否是存文本？是！Writer。
     设备：硬盘。一个文件。使用 FileWriter。
     FileWriter fw = new FileWriter("c.txt");
     需要提高效率吗？需要。
     BufferedWriter bufw = new BufferedWriter(fw);


3、扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
    
     目的：OutputStream  Writer
     是否是存文本？是！Writer。
     设备：硬盘。一个文件。使用 FileWriter。
     但是FileWriter是使用的默认编码表。GBK.
    
     但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
     所以要使用的对象是OutputStreamWriter。
     而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
     OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
     需要高效吗？需要。
     BufferedWriter bufw = new BufferedWriter(osw);


     所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流。

六、File
      用来将文件或者文件夹封装成对象, 方便对文件与文件夹的属性信息进行操作 。File 对象可以作为参数传递给流的构造函数。

     File类常见方法：
1，创建。
     boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
     boolean mkdir():创建文件夹。
     boolean mkdirs():创建多级文件夹。
2，删除。
     boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
     void deleteOnExit();在程序退出时删除指定文件。

3，判断。
     boolean exists() :文件是否存在.
     isFile():
     isDirectory();
     isHidden();
     isAbsolute();

4，获取信息。
     getName():
     getPath():
     getParent():
     getAbsolutePath()
     long lastModified()
     long length() 

需求：列出指定目录下文件或者文件夹，包含子目录中的内容。（以及删除）
package   com.File;
import   java.io.*;
public   class   listFile {

      public   static   void   main(String[] args) {
          File dir =   new   File(   "F:\\360云盘\\视频\\51CTO下载-毕向东上课PPT源码"   );
             //showDir(dir ,0);

           removeDir( new   File(   "F:\\客户端\\zzz"   ));
     }
      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   void   removeDir(File dir)
     {
          File[] files = dir.listFiles();
          
             for ( int   x=0; x<files. length ; x++)
          {
                 if (files[x].isDirectory()) //判断是否是目录
                    removeDir(files[x]);
                 else
                   System.   out .println(files[x].toString()+ ":-file-:"   +files[x].delete()); //打印并删除文件
          }

          System.   out .println(dir+ "::dir::"   +dir.delete()); //删除目录
     }

}

七、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");

          prop.store(fos,"haha");

          prop.list(System.out);

          fos.close();
          fis.close();

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

字节打印流：
PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream


字符打印流：
PrintWriter
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。
    
import java.io.*;

class  PrintStreamDemo
{
     public static void main(String[] args) throws IOException
     {
          BufferedReader bufr =
               new BufferedReader(new InputStreamReader(System.in));

          PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

          String line = null;

          while((line=bufr.readLine())!=null)
          {
               if("over".equals(line))
                    break;
               out.println(line.toUpperCase());
               //out.flush();
          }

          out.close();
          bufr.close();

     }    
}
 
九、序列流（SequenceInputStream）
     对多个流进行合并。
     
          应用图片的合成
package   com.File;

import   java.io.*;
import   java.util.ArrayList;
import   java.util.*;

public   class   SequenceInputStreamDemo {


      public   static   void   main(String[] args)   throws   IOException {
           splitFile();
           merge();
     }
     
     
      //分割文件
      public   static   void   splitFile()   throws   IOException{
          FileInputStream fis =   new   FileInputStream( "D:\\360\\360Downloads\\wpcache\\360wallpaper.jpg"   );
          FileOutputStream fos =   null ;
          
             byte [] buf =   new   byte [1024*100];
          
             int   len = 0;
             int   count = 0;
             while ((len=fis.read(buf))!=-1){
              fos =   new   FileOutputStream( "D:\\360\\360Downloads\\wpcache\\"   +(count++)+ ".suipian" );
              fos.write(buf,0,len);
              fos.close();
          
          }
          fis.close();
     }
     

      //合并
      public   static   void   merge()   throws   IOException{
          ArrayList<FileInputStream> al =   new   ArrayList<FileInputStream>();
          
             for ( int   x=0;x<3; x++){
              al.add(   new   FileInputStream( "D:\\360\\360Downloads\\wpcache\\"   +x+ ".suipian"   ));
          }
          
             final   Iterator<FileInputStream> it = al.iterator();
          
          Enumeration<FileInputStream> en =   new   Enumeration<FileInputStream>(){
                 public   boolean   hasMoreElements()
              {
                      return   it.hasNext();
              }
                 public   FileInputStream nextElement()
              {
                      return   it.next();
              }
          };
          
          SequenceInputStream sis =   new   SequenceInputStream(en);
          FileOutputStream fos =   new   FileOutputStream( "D:\\360\\360Downloads\\wpcache\\hebing.bmp"   );
          
             byte [] buf =   new   byte [1024];
             int   len = 0;
             while ((len=sis.read(buf))!=-1){
              fos.write(buf, 0, len);
          }
          fos.close();
          sis.close();
     }
     
     
}

十、对象流
     对象流可以将Java 对象转换成二进制写入磁盘，这个过程通常叫做   序列化  ，并且还可以从磁盘读出完整的Java 对象，而这个过程叫做   反序列化  。
     对象流主要包括：ObjectInputStream 和ObjectOutputStream
        序列化 必须实现序列化接口java.io. Serializable ，该接口没有任何方法， 只是一种 标记接口 ，标记这个类是可以序列化的
     序列化是对内存中的数据。
     静态不能被序列换

     
package   com.File;

import   java.io.*;

public   class   ObjectStreamDemo
{
      public   static   void   main(String[] args)   throws   Exception
     {
             //writeObj();
           readObj();
     }
      public   static   void   readObj() throws   Exception
     {
          ObjectInputStream ois =   new   ObjectInputStream( new   FileInputStream( "obj.txt" ));

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

          System.   out .println(p);
          ois.close();
     }

      public   static   void   writeObj() throws   IOException
     {
          ObjectOutputStream oos =
                 new   ObjectOutputStream( new   FileOutputStream( "obj.txt"   ));

          oos.writeObject(   new   Person( "lisi0"   ,399, "kr"   ));

          oos.close();
     }
}

//实现Serializable接口，标记这个类是可以序列化的
class   Person   implements   Serializable{
      //定义类的序列号
      public   static   final   long   serialVersionUID   = 42L;

      private   String   name ;
      //采用transient 关键字修饰此属性，序列化时会忽略
      transient   int   age   ;
      //静态不能被实例化，
      static   String   country   =   "cn"   ;
     Person(String name,   int   age,String country)
     {
             this . name   = name;
             this . age   = age;
             this . country   = country;
     }
      public   String toString()
     {
             return   name   + ":"   + age   + ":"   + country ;
     }
}

十一、管道流（ PipedInputStream 和 PipedOutputStream）
           输入输出可以直接进行连接，通过结合线程使用
  
package   com.File;
import   java.io.*;

class   Read   implements   Runnable{
      private   PipedInputStream   in ;
     Read(PipedInputStream in){
             this . in   = in;
     }
      @Override
      public   void   run() {
             try {
                 byte [] buf =   new   byte [1024];
              System.   out .println( "读取前---没有数据阻塞"   );
                 int   len =   in   .read(buf);
              System.   out .println( "读取到数据---阻塞结束"   );
              
              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;
     }
      @Override
      public   void   run() {
          System.   out .println( "开始写入数据，等待6秒后"   );
             try   {
              Thread. sleep(6000);
                 out .write(   "piped lai la" .getBytes());
                 out .close();
          }   catch   (Exception e) {
                 throw   new   RuntimeException( "管道流输出失败" );
          }
          
          
     }
}
public   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();
     }

}

十二、RandomAccessFile

该类不是算是IO体系中子类，而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。
该类只能操作文件。而且操作文件还有模式：只读r，，读写rw等。
如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖
     
import java.io.*;

class RandomAccessFileDemo
{
     public static void main(String[] args) throws IOException
     {
          //writeFile_2();
          //readFile();

          //System.out.println(Integer.toBinaryString(258));

     }

     public static void readFile()throws IOException
     {
          RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
         
          //调整对象中指针。
          //raf.seek(8*1);

          //跳过指定的字节数
          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_2()throws IOException
     {
          //不会覆盖文件，只会覆盖文件中的数据
          RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
          raf.seek(8*0);
          raf.write("周期".getBytes());
          raf.writeInt(103);

          raf.close();
     }

     public static void writeFile()throws IOException
     {
          RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

          raf.write("李四".getBytes());
          raf.writeInt(97);
          raf.write("王五".getBytes());
          raf.writeInt(99);

          raf.close();
     }
}

十三、字符编码：
        计算机底层是没有文本文件、图片文件之分的，它只记录每个文件的二进制序列。
        常见的码表：
            ASCII：美国标准信息交换码，用一个字节的7位可以表示。
            ISO8859-1：拉丁码表。欧洲码表用一个字节的8位表示。
            GB2312：中国的中文编码表。
            GBK：中国的中文编码表升级，融合了更多的中文文字符号。
            Unicode：国际标准码，融合了多种文字。
            UTF-8：最多用三个字节来表示一个字符。
        字符流的出现方便操作字符，更重要的是加入了编码转换，通过转换流来完成的
            InputStreamReader和OutputStreamWriter
        举例说明：
            package com.itheima.encode;           
            import java.io.FileInputStream;
            import java.io.FileOutputStream;
            import java.io.IOException;
            import java.io.InputStreamReader;
            import java.io.OutputStreamWriter;

            /*
             * 基本的字符和字节流是实现不了编码问题的。
             * 如果你想实现编码的处理，就必须使用转换流。
             * OutputStreamWriter：如果没有指定编码，默认编码是GBK。
             * 字符流 = 字节符 + 编码表
             * 编码问题的解决方案：采用统一编码表。
             */
            public class EncodeStream {
                public static void main(String[] args) throws IOException {
                    // 使用的是默认的编码表
                    // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                    // "osw.txt"));
                    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                            "osw.txt"), "UTF-8"); // GBK,UTF-8
                    // FileWriter osw = new FileWriter("osw.txt");
                    osw.write("中国");
                    osw.close();

                    InputStreamReader isr = new InputStreamReader(new FileInputStream(
                            "osw.txt"),"UTF-8");
                    char[] chs = new char[20];
                    int len = isr.read(chs);
                    String text = new String(chs,0,len);
                    System.out.println(text);
                }
            }

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


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

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


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

u010016264
关注
wpcache:面向所有人的适用于WordPress的Enterprise Redis:trade_mark:对象缓存
03-20
适用于WordPress的Enterprise Redis:trade_mark:对象缓存 WPCache是​​用于WordPress的Redis对象缓存插件，从头开始编写时要牢记原始性能，以避免不必要的读写，并保持很小的内存占用。
Wordpress优化：网站用nginx前端缓存+Redis Cache缓存提速网站
weixin_45498172的博客
10-23 1271
本问转载：https://www.src1024.com/xy/seo/31780.html 新手站长搭建网站一般为了省钱没去选择大厂的云服务器，而小厂的服务器虽然便宜，但是访问速度也很感人，同时如果你用的是Wordpress建站程序，如果不做优化，那么速度将会更感人。利用宝塔面板和wordpress来搭建网站还是很容易的，但是搭建网站容易，想要访问快却不容易。有些小伙伴总是问，宝塔面板打开很快，但是我的网站访问却很慢。宝塔面板访问快，肯定是利用了缓存来加速，你的网站访问慢，额，配置，带宽，都是慢的原因，
WordPress缓存插件：WP-Cache
bluedusk
03-17 1170
WP-Cache一个非常高效的WordPress页面缓存插件,它可以将php页面缓存为静态文件,避免了每次访问都需要重新编译php文件以及重新访问数据库带来的巨大开销.对于某些数据库连接慢的网站来说,WP-Cache是很好的一个解决方案.可以大大提高你的站点的相应速度,提高用户体验.其缺点是某些动态功能可能会失效,DEGULA使用了这个插件后就发现postviews(包括其js版本)不能正常统计....
pyhton中__pycache__文件夹的产生与作用
热门推荐
yitiaodashu的博客
01-10 7万+
源起 今天和一新来的同事沟通，说他用python编写了一个工程，但在第一次运行后，发现工程根目录下生成了一个__pycache__文件夹，里面是和py文件同名的各种以 .cpython-35.pyc 结尾的文件，问同事都不太清楚，所以便抽空整理了一下该知识点。先解释下cpython-35，cpython代表的是c语言实现的Python解释器，-35代表的是版本为3.5版。 至于pyc，先来了解
wordpress缓存类WP_Object_Cache分析【续二】
Php is everything...
09-21 267
[code="php"] /** * 取得存在的缓存数据 * * 根据ID和分组搜索数据，如果数据存在，返回数据 * * 失败时检查$non_existant_objects属性，如果缓存ID和分组在这个属性中存在，直接返回. * 如果不存在，则cache_misses加1，并把ID和分组添加到$non_existant_objects中。 * ...
黑马程序员_毕向东_Java基础视频教程第18天-14-IO流(拷贝文本文件图例).zip
04-07
黑马程序员_毕向东_Java基础视频教程第18天-14-IO流(拷贝文本文件图例).zip
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
本资料包“Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar”提供了一个深入学习Java IO流的全面资源，包含实例题目、源代码以及PPT教学材料，适合对Java IO有进阶需求的开发者。 1. **Java ...
黑马程序员_毕向东_Java基础视频教程第18天-09-IO流(文件的续写)
04-07
黑马程序员_毕向东_Java基础视频教程第18天-09-IO流(文件的续写)
黑马程序员_毕向东_Java基础视频教程第18天-12-IO流(文本文件读取练习).zip
04-07
在这个“黑马程序员_毕向东_Java基础视频教程第18天-12-IO流(文本文件读取练习)”中，毕向东老师将深入讲解如何使用Java IO流来读取文本文件。Java IO流提供了多种类和方法，使得开发者可以灵活高效地处理输入和输出...
传智播客黑马程序员javaIO流重点总结(必读).doc
11-23
传智播客黑马程序员javaIO流重点总结(必读).doc
创建File对象和其常见方法
weixin_45104211的博客
08-21 5522
一、什么是File类 File类创建的对象可以指带路径下的文件和路径下的目录： 1、指代目录 2、指代文件 package io; import java.io.File; public class Learn { public static void main(String[] args) { File file =new File ("D:\\...
基于FPGA的智能车牌检测系统设计与实现
11-08
内容概要：本文介绍了一种基于FPGA的智能车牌检测系统。该系统采用了OV5640摄像头进行图像采集，通过FPGA集成化开发环境进行图像处理，主要包括图像格式转换、图像灰度化、图像增强、边缘检测、腐蚀膨胀、投影定位等技术步骤。该系统能够在复杂环境中快速实现车牌的图像采集及定位，提高了车牌检测的效率和准确性。 适合人群：具备一定嵌入式系统和图像处理基础的研究人员和技术人员。 使用场景及目标：适用于智慧交通管理系统，尤其是停车场、高速公路、智能制造等领域，主要用于实现实时的车牌检测与识别。 其他说明：系统采用Sobel算子进行边缘检测，中值滤波进行图像增强，投影定位确定车牌位置，整体处理效率较高，适用于复杂光照条件下的车牌检测。
【java毕业设计】springbootJava学生选课系统(springboot+vue+mysql+说明文档).zip
11-08
项目经过测试均可完美运行！ 环境说明： 开发语言：java 框架：ssm jdk版本：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse 部署容器：tomcat7+
JDK-API-1-6-zh-CN
11-08
JDK API 1.6 中文版，附使用说明
【java毕业设计】springbootJava校车管理信息系统(springboot+vue+mysql+说明文档).zip
11-08
项目经过测试均可完美运行！ 环境说明： 开发语言：java 框架：ssm jdk版本：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse 部署容器：tomcat7+
resnet模型-python语言pytorch框架训练识别动物-不含数据集图片-含逐行注释和说明文档.zip
11-08
本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 首先是代码的整体介绍 总共是3个py文件，十分的简便 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01生成txt.py,是将数据集文件夹下的图片路径和对应的标签生成txt格式,划分了训练集和验证集 运行02CNN训练数据集.py,会自动读取txt文本内的内容进行训练，这里是适配了数据集的分类文件夹个数，即使增加了分类文件夹，也不需要修改代码即可训练 训练过程中会有训练进度条，可以查看大概训练的时长,每个epoch训练完后会显示准确率和损失值 训练结束后，会保存log日志，记录每个epoch的准确率和损失值 最后训练的模型会保存在本地名称为model.ckpt 运行03pyqt界面.py，就可以实现自己训练好的模型去识别图片了
仿iphone的listview下拉更新.zip
11-08
内容概要：本资源聚焦 Android 编程实战，包含毕业设计示例、完整的 Android 项目源码及文档分享。采用 MVC 模式进行架构设计，结合 JSP 技术与 SQL Server 2000 数据库管理系统，实现高效的 Android 应用开发。 适用人群：Android 开发初学者、计算机专业学生进行毕业设计参考、希望提升 Android 开发技能的程序员。 实用场景及目标：适用于开发各类 Android 应用项目，帮助开发者快速构建稳定、功能丰富的应用程序，同时为毕业设计提供优质的模板和思路。 说明：资源提供了详细的代码注释和文档说明，方便学习者理解和上手，助力提升 Android 开发能力和项目实战经验。
【Unity 插件】Photon Multiplayer Template (For Game Creator 2)
11-08
文件名：Photon Multiplayer Template For Game Creator 2.unitypackage Photon Multiplayer Template (For Game Creator 2) 是一款专为 Game Creator 2 用户设计的 Unity 插件，它集成了 Photon Networking 系统，用于快速创建多人在线游戏。该插件使得开发者可以在 Game Creator 2 的基础上，无需深厚的网络编程经验，就能快速实现多人游戏功能。它为 Unity 项目提供了一套简单而强大的网络框架，允许玩家在同一场景中进行交互、合作或对战。 主要特点： 集成 Photon 网络框架： 该插件基于 Photon PUN 2（Photon Unity Networking）构建，是一种广泛使用的、功能强大的实时多人游戏网络框架。 通过集成 Photon，开发者可以轻松实现玩家的连接、同步、通信和数据传输功能，而不需要自己从头开始构建网络系统。 适用于 Game Creator 2： 插件专为 Game Creator 2 设计.....
vgg模型-通过CNN卷积神经网络的宠物品种识别-不含数据集图片-含逐行注释和说明文档.zip
最新发布
11-08
本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 首先是代码的整体介绍 总共是3个py文件，十分的简便 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01生成txt.py,是将数据集文件夹下的图片路径和对应的标签生成txt格式,划分了训练集和验证集 运行02CNN训练数据集.py,会自动读取txt文本内的内容进行训练，这里是适配了数据集的分类文件夹个数，即使增加了分类文件夹，也不需要修改代码即可训练 训练过程中会有训练进度条，可以查看大概训练的时长,每个epoch训练完后会显示准确率和损失值 训练结束后，会保存log日志，记录每个epoch的准确率和损失值 最后训练的模型会保存在本地名称为model.ckpt 运行03pyqt界面.py，就可以实现自己训练好的模型去识别图片了
黑马程序员io流笔记
07-29
根据提供的引用内容，IO流是Java中用于处理输入和输出的机制。在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等二进制对象时更常用，而字符流在处理中文时更为方便。\[1\]\[2\]无论是使用字节流还是字符流，操作文件时都需要使用File类来定位文件对象，并通过字节流或字符流的子类来创建对象进行读写操作。最后，需要关闭输入/输出流以释放资源。\[3\] 关于黑马程序员的IO流笔记，根据提供的信息，无法得知具体内容。请提供更多细节或具体问题，以便我能够给出更准确的回答。 #### 引用[.reference_title] - *1* *2* *3* [黑马程序员—IO学习笔记](https://blog.csdn.net/showingtime/article/details/45305741)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值