来自  资质荣誉 2019-09-20 10:27 的文章
当前位置: 澳门太阳娱乐手机登录 > 资质荣誉 > 正文

Scala字节数组转变为数字,输入与出口

   1. 2个字节数组转变为整数

 

图片 1图片 2

  IO流位于java.io包中,依据操作数据分裂,分为字节流和字符流;根据数据输入方面包车型客车两样又可分为输入流和输出流,无论是何种流,最后都依据于操作系统。

1 def bytes2uint8(_bytes: Array[Byte], _offset: Int): Int = {2     val b0 = _bytes & 0xff3     return b04   }5   6   def bytes2sint8(_bytes: Array[Byte], _offset: Int): Int = {7     val b0 = _bytes8     return b09   }

一、字节流:

View Code

1、字节流,首要用以图片、音频、摄像的传导,以二进制的款型举行,分为字节输入流和字节输出流;字节流操作的是字节数组;字符流操作的是字符数组。

   2. 4个字节数组转换为整数

2、字节输入与字节输出流的三番两次种类图 

图片 3图片 4

图片 5

 1 def bytes2uint16(_bytes: Array[Byte], _offset: Int): Int = { 2     var b0 = _bytes & 0xff 3     var b1 = _bytes(_offset + 1) & 0xff 4  5     return ((b1 << 8) | b0).toShort & 0x0FFFF 6   } 7    8 //需要添加import java.nio.ByteBuffer 9   def bytes2sint16(_bytes: Array[Byte], _offset: Int): Int = {10       var _array: Array[Byte] = new Array[Byte](2)11       _array = _bytes(_offset + 1)12       _array = _bytes13       return  ByteBuffer.wrap.getShort()14   }

图片 6

View Code

3、InputStream 与OutputStream常用方法

   3. 8个字节数组调换为整数   

 

图片 7图片 8

InputStream 常用艺术

 1 def bytes2uint32(_bytes: Array[Byte], _offset: Int): Long = { 2         var b0 = _bytes(_offset + 0) & 0xff 3         var b1 = _bytes(_offset + 1) & 0xff 4         var b2 = _bytes(_offset + 2) & 0xff 5         var b3 = _bytes(_offset + 3) & 0xff 6         return ((b3 << 24) | (b2 << 16) | (b1 << 8) | b0).toLong & 0xFFFFFFFFL 7     } 8  9   def bytes2sint32(_bytes: Array[Byte], _offset: Int): Int = {10     var b0 = _bytes & 0xff11     var b1 = _bytes(_offset + 1) & 0xff12     var b2 = _bytes(_offset + 2) & 0xff13     var b3 = _bytes(_offset + 3) & 0xff14     return ((b3 << 24) | (b2 << 16) | (b1 << 8) | b0)15   }

办法申明

View Code

功用描述

   4. 2个字节数组调换为布尔型

int read()

    

从输入流读取贰个8位的字节,把它转变为0-255以内的整数,并重临这一整数

图片 9图片 10

int read(byte[] b)

1 def bytes2bool(_bytes: Array[Byte], _offset: Int): Boolean = {2     var b0 = _bytes & 0xff3     var b1 = _bytes(_offset + 1) & 0xff4 5     return if (((b1 << 8) | b0) != 0) true else false6   }

从输入流读取若干字节,把它们保存到参数b钦点的字节数组中,重临的卡尺头表示读取的字节数

View Code

int read(byte[] b,int off,len)

   5. 4个字节数组转变为浮点型

从输入流读取若干字节,把它们保存到参数b钦命的字节数组中,off钦点字节数组起首保存数据的初始下标,len表示读取的字节

图片 11图片 12

void close()

 1 import java.nio.ByteBuffer 2 def bytes2float(_bytes: Array[Byte], _offset: Int): Double = { 3  4     var _array: Array[Byte] = new Array[Byte](4) 5  6     for (i <- 0 until 4) { 7       _array = _bytes(-i + _offset + 3) 8     } 9 10     return ByteBuffer.wrap.getFloat()11   }

闭馆此输入流并释放与该流关联的具有系统能源

View Code

 

   6. 8个字节数组调换为Double

OutputStream 常用艺术

图片 13图片 14

方法评释

 1 import java.nio.ByteBuffer 2 def bytes2real(_bytes: Array[Byte], _offset: Int): Double = { 3  4     var _array: Array[Byte] = new Array[Byte](8) 5  6     for (i <- 0 until 8) { 7       _array = _bytes(-i + _offset + 7) 8     } 9 10     return ByteBuffer.wrap.getDouble11   }

成效描述

View Code

void write(int b)

   7. 8个字节数组转变为Long

向输出流写入二个字节

图片 15图片 16

void write(byte[]  b)

1 import java.nio.ByteBuffer2 def bytes2long(_bytes: Array[Byte], _offset: Int): Double = {3     var _array: Array[Byte] = new Array[Byte](8)4     5     for (i <- 0 until 8) {6       _array = _bytes(-i + _offset + 7)7     }8     return ByteBuffer.wrap.getLong9   }

把参数b钦命的字节数组的有所字节写到输出流

View Code

void write(byte[] b,int off,len)

将钦定byte数组中从偏移量off开端的len个字节写入输出流

void flush()

刷新此输出流并威迫写出富有缓冲的输出字节

void close()

关门此输出流并释放与该流关联的富有系统财富

 

4、字节流读写文件:

  FileInputStream 是操作文件的的字节输入流,特地用于读取文件中的数据。

  FileOutputStream是操作文件的的字节输出流,特地用于把数据写入文件。

           示例:

图片 17图片 18

 1 public class Example01 {
 2     public static void main(String[] args) throws Exception{
 3         //创建一个文件字节型输入流
 4         InputStream inputStream = new FileInputStream("test.txt");
 5         int b = 0;  //定义一个int类型的变量b,记住每一次读取的一个字节
 6         while (true){
 7             b=inputStream.read();//变量b记住读取的一个字节
 8             if(b==-1){     //如果读取的字节为-1,跳出while循环
 9                 break;
10             }
11             System.out.println(b); //否则将b写出
12         }
13         inputStream.close();
14       
15         //创建一个文件字节输出流
16         OutputStream OutputStream= new FileOutputStream("example.txt",true);
17         String string = "人之初";
18         byte [] bytes= string.getBytes();
19         for (int i = 0;i<bytes.length;i++){
20             OutputStream.write(bytes[i]);
21         }
22         OutputStream.close();
23     }
24 }

View Code

  文件拷贝:

图片 19图片 20

 1 public class Example04 {
 2        public static void main(String[] args) throws Exception{
 3            //创建一个字节输入流,用于读取当前目录下source文件中的docx文件
 4            InputStream in = new FileInputStream("source/IO工具包.mp4") ;
 5            //创建一个文件字节输出流,用于将读取的数据写入target目录下的文件中
 6            OutputStream out = new FileOutputStream("target/IO工具包.mp4");
 7            byte [] buff = new byte[1024]; //定义一个字节数组,作为缓冲区
 8            int len;  //定义一个int类型的变量len记住读取读入缓冲区的字节数
 9            // int len = 0 ; //定义一个int类型变量,记住每次读取的一个字节
10            long begintime = System.currentTimeMillis();
11               while ((len=in.read(buff))!=-1){  //判断是否读到文件末尾
12                   out.write(buff,0,len);  //从第一字节开始,向文件写入len个字节
13               }
14            long endtime = System.currentTimeMillis();
15            System.out.println("耗时"+(endtime-begintime)+"毫秒");
16            in.close();
17            out.close();
18        }
19 }

View Code

5、装饰设计方式观念:

TextReader:读取文本;

MediaReader:读取媒体数据;

抽出共性,变成系统。

Reader

|---TextReader  read()

|---MediaReader

需求1:

进步读取文本的功能,使用缓冲本事,提供一个读取文本更敏捷的读取方法。

覆盖TextReader中的方法。创立高效的read方法。所以创建贰个TextReader的子类,用于高效的读取。

Reader

|---TextReader  read()

    |--BufferedTextReader

     |---MediaReader

需求2:

抓牢读取媒体数据的频率,派生贰个飞速的子类,用于高效的读取。

Reader

|---TextReader  read()

    |--BufferedTextReader

     |---MediaReader

         |--BufferedMediaReader

 

察觉七个小标题,假使Reader中还应该有读取别的数据的子类,如果要快快,这岂不是还要给那个子类增添三个神速子类?

是的,为了给现实的读取数据的靶子扩大一些作用,是急需经过子类来实现的。

可是那样做,会导致那么些一连种类很臃肿!仅仅为了充实一些效果与利益,而进展后续,不建议的。

这几个子类无非便是急需快捷,况兼那几个高速的效率达成是完全一样的。就是提供三个缓冲区而以。

简直,单独定义四个兼有这些缓冲效能的对象,哪个子类要求被缓冲,就将哪个子类传递步向。

class BufferedReader  extends Reader{

private [];//提供数据

BufferedReader(Reader r){    //对Reader高效就行

}

read(){操作的是数组}  //高效的读取动作

}

那时候三番五次类别:

Reader

|---TextReader 

     |---MediaReader

     |---BufferedReader

察觉这种规划艺术收缩了后续种类的交汇,增减效能,比持续更为灵活。

这种设计格局叫做:装饰设计方式。

减轻难点:给一组类扩张效果,防止后续的重叠,提升灵活。

注意:装饰类和棉被服装饰类必得属于同一种类,平常装饰类都会提供构造函数接收棉被服装饰类对象。装饰类经常不单独存在。

6、字节缓冲流

  使用的是装饰设计格局

  示例:

图片 21图片 22

 1 public class Example07 {
 2     public static void main(String[] args) throws Exception{
 3         //创建一个带缓冲区的输入流
 4         BufferedInputStream bis = new BufferedInputStream(
 5                 new FileInputStream("src.txt"));
 6         //创建一个带缓冲区的输出流
 7         BufferedOutputStream bos = new BufferedOutputStream(
 8                 new FileOutputStream("des.txt"));
 9         int len;
10         while ((len=bis.read())!=-1){
11             bos.write(len);
12         }
13         bis.close();
14         bos.close();
15     }
16 }

View Code

二、字符流

1、字符流:为了方便操作数据中的字符数据。原理:字节流+编码表。

2、字符流承袭体系

图片 23

 

图片 24

3、基类方法摘要

Reader方法摘要

abstract  void close()  

关闭该流并释放与之提到的装有能源。

void mark(int readAheadLimit) 

标识流中的近来地点。

boolean markSupported() 

认清此流是或不是援助 mark() 操作。

int read() 

读取单个字符。

int read(char[] cbuf) 

将字符读入数组。

abstract  int read(char[] cbuf, int off, int len) 

将字符读入数组的某一局地。

int read(CharBuffer target) 

精算将字符读入钦点的字符缓冲区。

boolean ready() 

推断是或不是筹划读取此流。

void reset() 

重新载入参数该流。

long skip(long n) 

跳过字符。

 

 

Writer方法摘要

void close() 

关门此流,但要先刷新它。

void flush() 

刷新该流的缓冲。

String getEncoding() 

回来此流使用的字符编码的名称。

void write(char[] cbuf, int off, int len) 

写入字符数组的某一部分。

void write(int c) 

写入单个字符。

void write(String str, int off, int len) 

写入字符串的某一片段。

flush()和close()的区别?

flush();将流中的缓冲区缓冲中的数据刷新到指标地中,刷新后,流还足以持续选取;

close();关闭能源,但在关闭前会将缓冲区中的数据刷新到指标地,不然遗失数据,然后再关闭流,流不得以行使。

如若写入数据多,一边写一边刷新,最终三遍能够不刷新,由close()完毕刷新并关闭。

4、字符流操作文件

  FileReader 和FileWriter 用于读写文件;BufferedReader 和BufferdeWriter是具有缓冲成效的流,能够提升读写效用。

  BufferedReader中有一珍视的方法readLind(),该办法用于叁遍读取一行文本。

图片 25图片 26

 1 public class Example10 {
 2     public static void main(String[] args) throws Exception{
 3         FileReader reader = new FileReader("src.txt");
 4         //创建一个BufferedReader缓冲对象
 5         BufferedReader br = new BufferedReader(reader);
 6         FileWriter writer = new FileWriter("des.txt");
 7         //创建一个BufferedWriter缓冲对象
 8         BufferedWriter bw = new BufferedWriter(writer);
 9         String string;
10         while ((string=br.readLine())!=null){
11             bw.write(string);
12             bw.newLine();//写入一个换行符,该方法会根据不同的操作系统生成相应的换行符
13         }
14         br.close();
15         bw.close();
16     }
17 }

View Code

  BufferedReader一直接子类——LineNumberReader ,一个得以追踪行号的输入流。

图片 27图片 28

 1 public class Example11 {
 2     public static void main(String[] args) throws Exception{
 3         FileReader fr = new FileReader("/Users/Shared/第八章IO练习/exampele09.txt"); //创建字符输入流
 4         FileWriter fw = new FileWriter("copy.txt");//创建字符输出流
 5         LineNumberReader lr = new LineNumberReader(fr);  //包装
 6         lr.setLineNumber(0);  //设置读取文件的起始行号
 7         String line = null;
 8         while ((line=lr.readLine())!=null){
 9             fw.write(lr.getLineNumber()+":"+line);//将行号写入到文件中
10             fw.write("rn");  //写入换行
11         }
12         lr.close();
13         fw.close();
14     }
15 }

View Code

5、转换流

        转变流是一种字符流,只可以兑现字节流读写文本数据的时候,通过转移流来使用字符高效流的方法。而无法达成图片、音频等数据的读写。

   InputStream里德r:驾驭上是字节流通向字符流的大桥,使用上为:

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

   OutputStreamWriter:理解上是字符流通向字节流的桥梁,使用上照旧经过字节流转成字符流:

BufferedWriter  bw = new BufferedWriter (new OutputStreamWriter(System.out));

图片 29图片 30

 1 public class Example12 {
 2     public static void main(String[] args) throws Exception{
 3         FileInputStream in= new FileInputStream("src1.txt");//创建字节输入流
 4         InputStreamReader isr = new InputStreamReader(in);//将字节流输入转换成字符输入流
 5         BufferedReader br = new BufferedReader(isr);//对字符流对象进行包装
 6         FileOutputStream out = new FileOutputStream("des1.txt");
 7         //将字节流转换为字符输出流
 8         OutputStreamWriter osw = new OutputStreamWriter(out);
 9         //对字符输出流对象进行包装
10         BufferedWriter bw = new BufferedWriter(osw);
11         String line;
12         while ((line=br.readLine())!=null){  //判断是否读到文件末尾
13             bw.write(line);  //输出读取到文件
14         }
15         br.close();
16         bw.close();
17     }
18 }

View Code

三、其他IO流

1、ObjectOutputStream、ObjectInputStream

  体系化:把目的根据流同样的秘技传输大概存款和储蓄。(ObjectOutputStream).

         当对象实行种类化时,必需保障该对象完毕塞里alizable接口,不然程序会现出NotSerializableException十分。

  反系列号:把互联网中的流多少依然文件中的流多少(二进制数据)还原成对象。(ObjectInputStream).

图片 31图片 32

 1 public class Example13 {
 2     public static void main(String[] args) throws Exception{
 3         //序列化对象
 4         Person person = new Person("p1","zhangsan",20);
 5         //创建文件输出流对象,将数据写入objectStream.txt
 6         FileOutputStream fos = new FileOutputStream("objectStream.txt");
 7         //创建对象输出流对象,用于处理输出流对象写入的数据
 8         ObjectOutputStream oos = new ObjectOutputStream(fos);
 9         //将Person对象输出到输出流中
10         oos.writeObject(person);
11         oos.close();
12  
13         //反序列化对象
14         FileInputStream fis = new FileInputStream("object.txt");
15         //创建文件输入流对象,用于读取指定文件的数据
16         ObjectInputStream ois = new ObjectInputStream(fis);
17         //创建对象输入流,并且从指定的输入流中过读取数据
18         Object p = ois.readObject();
19         System.out.println(p);
20         ois.close();
21     }
22 }
23 class Person implements Serializable{
24     private String id;
25     private String name;
26     private int age;
27     public Person(String id, String name, int age) {
28         super();
29         this.id = id;
30         this.name = name;
31         this.age = age;
32     }
33     public String getId() {
34         return id;
35     }
36     public String getName() {
37         return name;
38     }
39     public int getAge() {
40         return age;
41     }
42 }

View Code

2、DataInputStream,DataOutputStream

        有时候并无需存款和储蓄整个对象的音信,而只供给仓库储存对象的成员数量,那几个成员数量的花色又都以着力数据类型,可使用数据操作流:DataInputStream,DataOutputStream 。

图片 33图片 34

 1 public class Example15 {
 2     public static void main(String[] args) throws Exception{
 3         BufferedOutputStream  bos = new BufferedOutputStream(
 4                 new FileOutputStream("/Users/Shared/ioexample/dataStream.txt"));
 5         DataOutputStream dos = new DataOutputStream(bos);
 6         dos.writeByte(12);                  //写一个字节
 7         dos.writeChar('1');                 //写一个字符
 8         dos.writeBoolean(true);             //写一个布尔值
 9         dos.writeUTF("同学,你好");          //写一个转换成UTF-8的字符串
10         dos.close();                           //关闭流
11         BufferedInputStream bis= new BufferedInputStream(
12                 new FileInputStream("/Users/Shared/ioexample/dataStream.txt"));
13         DataInputStream dis = new DataInputStream(bis);
14         System.out.println(dis.readByte());     //读取一个字节
15         System.out.println(dis.readChar());     //读取一个字符
16         System.out.println(dis.readBoolean());  //读取一个布尔值
17         System.out.println(dis.readUTF());      //读一个转换成UTF-8编码的字符串
18         dis.close ();                           //关闭流
19     }
20 }

View Code

  唯有读取数据的一一与写多少的一一保持一致,才具确定保证最后数额的平常性。

3、打印流PrintStream

图片 35图片 36

 1 public class Example16 {
 2     public static void main(String[] args) throws Exception{
 3         PrintStream ps = new PrintStream(
 4                 new FileOutputStream("printStream.txt",true));
 5            Student stu = new Student();
 6            ps.print("这是一个数字");
 7            ps.println(19);
 8            ps.println(stu);
 9     }
10 }
11 class Student {
12     @Override
13     public String toString() {
14         return "我是一个学生";
15     }
16 }

View Code

4、规范输入输出流(in、out、err)

图片 37图片 38

 1 public class Example17 {
 2     public static void main(String[] args) throws Exception{
 3         StringBuffer sb = new StringBuffer();
 4         int ch;
 5         //while循环用于读取键盘输入的数据
 6         while ((ch=System.in.read())!=-1){   //判断是否读取到数据的末尾
 7             //对输入的字符进行判断,如果是回车"r"或者换行"n",则跳出循环
 8             if(ch =='r' || ch=='n'){
 9                 break;
10             }
11             sb.append((char)ch);  //将读取到的数据添加到sb中
12         }
13         System.out.println (sb);  //打印键盘输入的数据
14     }
15 }

View Code

 

重定向流常用的静态方法

艺术证明

效果与利益描述

void setIn(InputStream in)

对正规输入流重定向

void setOut(PrintStream out)

对标准输出流重定向

void setErr(PrintStream out)

对行业内部错误输出流重定向

 

5、管道流(PipedInputStream、PipedOutputStream)

  二十多线程之间能够由此此管道流达成数量的传导。

图片 39图片 40

 1 public class Example19 {
 2     public static void main(String[] args) throws Exception{
 3         final PipedInputStream  pis = new PipedInputStream();//创建PipedInputStream对象
 4         final PipedOutputStream pos = new PipedOutputStream();
 5         //PipedInputStream和PipedOutputStream建立连接,也可写成pos.connect(pis)
 6         pis.connect(pos);
 7         new Thread(new Runnable(){          //创立线程
 8             public void run(){
 9                 //将从键盘读取的数据写入管道流中
10                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
11                 //将从键盘读取的数据写入管道流中
12                 PrintStream ps = new PrintStream(pos);
13                 while (true){
14                    try{
15                       System.out.println(br.readLine());
16                       Thread.sleep(1000);
17                    }catch (Exception e){
18                         e.printStackTrace();
19                    }
20                 }
21             }
22         },"发送数据的线程").start();
23         new Thread(new Runnable() {
24             @Override
25             public void run() {
26                 //下面代码是从管道流中读取数据,每读一行数据输出一次
27                 BufferedReader br = new BufferedReader(new InputStreamReader(pis));
28                 while (true){
29                     try{
30                         System.out.println(Thread.currentThread().getName()+"收到的内容:"+br.readLine());
31                     }catch (IOException e){
32                         e.printStackTrace();
33                     }
34                 }
35             }
36         },"接收数据的线程").start();
37     }
38 }

View Code

6、ByteArrayOutputStream、ByteArrayInputStream

  将数据写入(读取)到缓冲区,最终二次性写入(输出)到文件。

  假设读取的文本充裕大,就不能够应用这些列,不然会导致内部存款和储蓄器溢出。

图片 41图片 42

 1 public class Example20 {
 2     public static void main(String[] args) throws Exception{
 3         //将数据写入缓冲区中
 4         FileInputStream fs = new FileInputStream("source.txt");
 5         //创建一个字接数据缓冲区
 6         ByteArrayOutputStream bos = new ByteArrayOutputStream();
 7         FileOutputStream fos = new FileOutputStream("target1.txt");
 8         //下面的代码是循环读取缓冲区中的数据,并将数据一次性写入文件
 9         int b1;
10         while ((b1=fs.read())!=-1){
11             bos.write(b1);
12         }
13         fs.close();
14         bos.close();
15         fos.write(bos.toByteArray());//将缓冲区中的数据一次性写入文件
16         fos.close();
17  
18         //读取缓冲区中的数据
19         byte[] bufs = new byte[]{97,98,99,100};//创建一个字节数组
20         ByteArrayInputStream bis = new ByteArrayInputStream(bufs);//读取字节数组中的数据
21         //下面代码是循环读取缓冲区中的数据
22         int b2;
23         while ((b2=bis.read())!=-1){
24             System.out.println((char)b2);
25         }
26         bis.close();
27     }
28 }

View Code

7、CharArrayReader和CharArrayWriter

  将字符型数据不经常存入缓冲区。

图片 43图片 44

 1 public class Example22 {
 2     public static void main(String[] args) throws Exception{
 3         FileReader fr = new FileReader("A.txt");//创建一个FileReader对象
 4         CharArrayWriter cw = new CharArrayWriter();//在内存中创建一个字符数组缓冲区
 5         //下面打代码是将数据写入缓冲区
 6         int b;
 7         while ((b=fr.read())!=-1){
 8             cw.write(b);         //将读取的字符写入缓冲区
 9         }
10         fr.close();
11         cw.close();
12         char [] c = cw.toCharArray(); //将缓冲区中的数据转换成字符型数组
13         CharArrayReader cr = new CharArrayReader(c); //读取字符数据中的数据
14         //下面的代码是从缓冲区中读取数据,并进行打印
15         int i = 0;
16         while ((i=cr.read())!=-1){
17             System.out.println((char)i);
18         }
19         cr.close();
20     }
21 }

View Code

8、SequenceInputStream

  SequenceInputStream类能够将多少个输入流串联在协同。

  构造方法:

1、SequenceInputStream(InputStream s1, InputStream s2)

2、SequenceInputStream(Enumeration<? extends InputStream> e)

图片 45图片 46

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 import java.io.SequenceInputStream;
 4 import java.util.Enumeration;
 5 import java.util.Vector;
 6  
 7 public class Example24 {
 8     public static void main(String[] args) throws Exception{
 9         Vector vector =new Vector();//创建Vector对象
10         //下面代码是创建3个输入流对象
11         FileInputStream in1 =new FileInputStream("stream1.txt");
12         FileInputStream in2 =new FileInputStream("stream2.txt");
13         FileInputStream in3 =new FileInputStream("stream3.txt");
14         //下面代码是向vector中添加三个输入流对象
15         vector.addElement(in1);
16         vector.addElement(in2);
17         vector.addElement(in3);
18         Enumeration e = vector.elements();//获取Vector对象中的元素
19         //将Enumeration对象中的流合并
20         SequenceInputStream sis = new SequenceInputStream(e);
21         FileOutputStream fs= new FileOutputStream("stream.txt");
22         int len;
23         byte[]buf = new byte[1024];   //创建一个大小为1024个字节数组的缓冲区
24         while ((len=sis.read(buf))!=-1){
25             fs.write(buf,0,len);
26         }
27         sis.close();
28         fs.close();
29     }
30 }

View Code

四、File类

  对文本本身进行操作

1、File类的常用方法

 

构造方法摘要

File(File parent, String child) 

基于 parent 抽象路线名和 child 路线名字符串成立多个新 File 实例。

File(String pathname) 

透过将给定路线名字符串调换为架空路线名来成立叁个新 File 实例。

File(String parent, String child)    

基于 parent 路线名字符串和 child 路线名字符串创造一个新 File 实例。

File(URI uri) 

经过将加以的 file: U福睿斯I 调换为贰个空洞路径名来创建二个新的 File 实例。

  

File类常用方法摘要

boolean exists() 

测量试验此抽象路线名表示的文件或目录是不是存在。

boolean delete() 

剔除此抽象路线名表示的公文或目录,删除成功则赶回true,不然再次来到false;

boolean createNewFile() 

当且仅当不设有具备此抽象路线名钦赐名称的文件时,才创立钦赐的新的文书。

String getName() 

回到经过抽象路线名表示的文件或目录的名号。

String getPath() 

回来File对象对应的路子

String getAbsolutePath() 

回到File对象对应的绝对路线名字符串。

String getParent() 

回来此抽象路线名父目录的门道名字符串;要是此路线名未有一点点名父目录,则赶回 null。

boolean canRead() 

测验应用程序是否足以读取此抽象路线名表示的文件。

boolean canWrite() 

测验应用程序是还是不是能够修改此抽象路线名表示的公文。

boolean isFile() 

测量试验此抽象路线名表示的文本是不是是四个标准文件。

boolean isDirectory() 

测量试验此抽象路线名表示的文书是不是是二个索引。

boolean isAbsolute() 

测验此抽象路线名是或不是为相对路线名。

long lastModified() 

归来此抽象路线名表示的文本最终一回被涂改的日子。

long length() 

回到经过抽象路径名表示的文本的长短。

String[]  list() 

回来八个字符串数组,这一个字符串钦赐此抽象路线名表示的目录中的文件和目录。

File[] listFiles() 

回来贰个华而不实路线名数组,那个门路名代表此抽象路线名表示的目录中的文件。

   示例:

图片 47图片 48

 1 public class Example25 {
 2     public static void main(String[] args) {
 3         File file = new File("example1.txt");//创建File文件对象,表示一个文件
 4         System.out.println("文件名称"+file.getName());
 5         System.out.println("文件的相对路径"+file.getPath());
 6         System.out.println("文件的绝对路径"+file.getAbsolutePath());
 7         System.out.println("文件的父路径"+file.getParent());
 8         System.out.println(file.canRead()?"文件可读":"文件不可读");
 9         System.out.println(file.canWrite()?"文件可写":"文件不可写");
10         System.out.println(file.isFile()?"是一个文件":"不是一个文件");
11         System.out.println(file.isDirectory()?"是一个目录":"不是一个目录");
12         System.out.println(file.isAbsolute()?"是绝对路径":"不是绝对路径");
13         System.out.println("最后修改时间"+file.lastModified());
14         System.out.println("文件大小"+file.length()+"bytes");
15         System.out.println("是否成功删除"+file.delete());
16     }
17 }

View Code

2、遍历目录下的文书(过滤)

图片 49图片 50

 1 public class Example27 {
 2     public static void main(String[] args) throws Exception{
 3         File file = new File("/Users/Shared/第八章IO练习/src/datastream");
 4         FilenameFilter filenameFilter= new FilenameFilter() {
 5             @Override
 6             public boolean accept(File dir, String name) {
 7                 File currFile = new File(dir,name);
 8                 if (currFile.isFile()&&name.endsWith(".java")){
 9                     return true;
10                 }else{
11                    return false;
12                 }
13             }
14         };
15         if (file.exists()){
16             String [] lists = file.list(filenameFilter);
17             for (String name:lists){
18                 System.out.println(name);
19             }
20         }
21     }
22 }

View Code

3、删除文件及目录

图片 51图片 52

 1 import java.io.File;
 2  
 3 public class Example30 {
 4     public static void main(String[] args) {
 5         File file =new File("/Users/Shared/第八章IO练习/src/delete");
 6         deleteDir(file);
 7     }
 8  
 9     public static void deleteDir(File dir) {
10         if(dir.exists()){
11             File[] files= dir.listFiles();
12             for (File file:files){
13                 if (file.isDirectory()){
14                   deleteDir(file);
15                 }else{
16                     file.delete();
17                 }
18             }
19             dir.delete();
20         }
21     }
22 }

View Code

五、RandomAccessFile

      不属于流类,但全体读写文件数量的效应,能够随意地从文件大肆人置上马施行读写多少操作。

1、应用场景:

    ①向10G文本末尾插入内定内容,只怕向钦命指针地点张开插队只怕涂改内容。 

  ②断点续传,使用seek()方法不断的换代下载能源的职分。

2、构造方法与稳固文件地方的诀窍

构造方法

办法表明

效果描述

RandomAccessFile(File file, String mode)

创办随机拜会文件流,以从File参数钦命的文本中读取,并可挑选写入文件。

RandomAccessFile(String name, String mode)

成立随机会见文件流,以从中内定名称的文本读取,并可采用写入文件。

 

  构造函数中mode参数字传送值介绍:

  • r 代表以只读方式展开钦定文件 。
  • rw 以读写方式张开钦点文件 。
  • rws 读写情势展开,并对剧情或元数据都一齐写入底层存储设备 。
  • rwd 读写格局展开,对文本内容的创新同步更新至底层存款和储蓄设备 。

RandomAccesseFile定位文件地方的点子

方法评释

效果描述

long getFilePointer()

回去当前读写指针所处的岗位

void seek(long pos)

设定读写指针的地点,与公事开始相隔pos个字节数

Int skipBytes(int n)

使读写指针从脚下岗位上马,跳过n个字节

Void setLength(long newLength)

安装此文件的尺寸

 

  软件试用次数限制小案例:

图片 53图片 54

 1 public class Example31 {
 2 
 3     public static void main(String[] args) throws Exception{
 4 
 5         //在time.txt文件中输入数字5
 6 
 7         RandomAccessFile raf = new RandomAccessFile("time.txt","rw");
 8 
 9         int times = 0;      //int类型的表露表示试用次数
10 
11         times=Integer.parseInt(raf.readLine()); //第一次读取文件时times为5
12 
13         if (times>0){
14 
15             //试用一次,次数减少一次
16 
17             System.out.println("您还可以试用"+times--+"次数");
18 
19             raf.seek(0);               //使用记录指针指向文件的开头
20 
21             raf.writeBytes(times+"");    //将剩余的次数再次写入文件
22 
23         }else {
24 
25             System.out.println("软件试用次数已到");
26 
27         }
28 
29         raf.close();
30 
31     }
32 
33 }

View Code

 

本文由澳门太阳娱乐手机登录发布于 资质荣誉,转载请注明出处:Scala字节数组转变为数字,输入与出口

关键词: