JAVA自学笔记20

JAVA自学笔记20

1、递归：

1）方法定义中定义中调用方法本身的现象

2）要有出口，否则就是死递归

次数不能太多。否则内存将溢出

构造方法不能递归使用

//斐波那契数列：1,1,2,3,5,8,13,21.34
public int Fibonacci(int n){
if(n==1||n==2){return 1;}
return Fibonacci(n-1)+Fibonacci(n-2)
}

@例题1：遍历目录下指定后缀名结尾的文件名称

private static void getAllJavaFilePaths(File srcFolder){
//获取该目录下所有的文件或者文件夹的File数组
File[] fileArray=srcFolder.listFiles();
for(File file:fileArray){
if(file.isDirectory()){
getAllJavaFilePaths(file)
}else{
if(file.getNmae().endsWith(".java")){
System.out.println(file.getAbsolutePath());
}
}
}
}

@例题2：递归删除带内容的目录

public class DeleteFolders{
File[] fileArray=srcFolder.listFiles();
for(File file:fileArray){
if(file.isDirectory()){
deleteFolder(file);
}
else{
System.out.println(file.delete());
}
}
System.out.println(srcFolder.delete);
}

2、IO

1)用于处理设备之间的数据传输。java对数据的操作是通过流的方式，java用于操作的流的对象都在IO包中



2）IO流分类

按数据流向分：

输入流：读入数据

输出流：写出数据

按数据类型分

字节流

字符流

3）常用基类：

抽象基类：InputStream,OutputStream

字符流的抽象基类：

Reader,Writer

注意：由这四个类派生出来的子类名都是以其父类名作为子类名的后缀

4）FileOuputStream

构造方法：

FileOutputStream(File file)

FileOutputStream(String name)

//在一个文本文件中写一句hello
//采用字节输出流
//创建字节流输出对象
File file=new File("Fos.txt");
FileOutputStream fos=new FileOutputStream(file);
//或FileOutputStream fos=new FileOutputStream("fos.txt");
//写数据
fos.writer("hello".getBytes());
//释放资源
fos.close();//流关闭，通知系统释放相关资源

4）字节流写数据方式

public void write(int b)

写一个字节

public void write(byte[] b)

写一个字节数组

public void write(byte[] b,int off,int leng)

写一个字节数组的一部分

FileOutputStream fos=new FileOutputStream("fos2.txt");
fos.write(97);//写入a
byte[] bys={97,98,99,100,101};
fos.write(bys);
fos.write(bys,1,3);
//

//实现换行
FileOutputStream fos=new FileOutputStream("fos.txt");
for(int x=0,x<0,x++){
fos.write(("hello"+x).getBytes());
fos.write("\n".getBytes());
}
fos.close();
}

注意:

//追加写入
FileOutputStream fos=new FileOutputStream("fos.txt"，true);
for(int x=0,x<0,x++){
fos.write(("hello"+x).getBytes());
fos.write("\r\n".getBytes());
}

5)异常处理

如果fos不是null，才能close

6)字节流读取数据

FileInputStream

构造方法：

FileInputStream(File file)

FileInputStream(String name)

成员方法：

int read():一次读取一个字节,返回-1则已读到末尾

int read(byte[] b)：一次读取一个字节数组

FileInputStream fis=new FileInputStream(fis.txt);
int by=fis.read();
fis.close();
//改进，仅适用与字母与数字
int by=0;
while((by=fis.read())!=-1){
System.out.print((char)by);
fis.close();
}

//字节流复制文本文件
//封装数据源,数据源已读要存在
FileInputStream fis=new FileInputStream("a.txt");
//封装目的地
FileOuputStream fos=new FileOuputStream("b.txt")

int by=0;
while((by=fis.read())!=-1{
fos.write(by);
}
fis.close();
fos.close();

//将c盘目录下的a.txt内容复制到b.txt中
FileInputStream fis=new FileInputStream("c:\\a.txt");
FileOuputStream fos=new FileOuputStream("d:\\b.txt");
int by==0;
while((by=fis.read()0!=-1){
fos.write(by);
}

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

//复制图片
FileInputStream fis=new FileInputStream("c:\\a.jpg");
FileOuputStream fos=new FileOuputStream("d:\\b.jpg");
int by==0;
while((by=fis.read()0!=-1){
fos.write(by);
fos.close();
fis.close();
}

//复制视频
FileInputStream fis=new FileInputStream("c:\\a.mp4");
FileOuputStream fos=new FileOuputStream("d:\\b.mp4");
int by==0;
while((by=fis.read()0!=-1){
fos.write(by);
fos.close();
fis.close();
}//速度太慢，一次一个字节复制

研究

int read(byte[] b)：一次读取一个字节数组，返回的是实际读取的字符数目，字节数组可被覆盖。到大结尾返回-1

//读取一个文件
byte[]bys=new byte[1024];
int len=0;
while((len=fis.read(bys)!=-1){
System.out.println(new String(bys,0,len));
}
fis.close();

存储图解：

//复制文本文件
FileInputStream fis=new FileIntputStream("c:\\a.txt")；
FileOuputStream fis=new FileOutputStream("b.txt")；
byte[]bys=new byte[1024];
int len=0;
while((len=fis.read(bys)!=-1){
for.write(bys,0,len);
fos.close();
fis.close();
}

字节流复制视频
FileInputStream fis=new FileIntputStream("c:\\a.mp4")；
FileOuputStream fis=new FileOutputStream("b.mp4")；

byte[1024];
int len=0;
while((len=fis.read(bys)!=-1){
for.write(bys,0,len);
fos.close();
fis.close();

7)字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区的效果,java本身在设计过程中也考虑到了这样的设计思想（装饰设计模式后面讲解），故提供了字节缓冲流

字节缓冲输出流

BufferedOutputStream

字节缓冲输入流

BufferedInputStream

构造方法可以指定缓冲区的大小，因为默认缓冲区大小就足够了。

BufferedIn（out）putStream（In(Out)putStream）

字节缓冲区流仅仅提供缓冲区为高效而设计，但真正的读写操作还得靠基本的流对象实现。

BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("bos.txt"));
//写数据
bos.write("hello".getBytes());
bos.close();

BufferedInputStream bos=new BufferedInputStream(new FileInputStream("bos.txt"));
//读数据
byte[]bys=new byte[1024];
int len=0;
while((len=bis.read(bys)!=-1){
System.out.println(new String(bys,0,len));
}