DAY18

DAY18

回顾内容:

一 异常类:处理异常的两种方式:

捕获异常:标准格式:try...catch...finally

try...finally

try...catch

                  try....catch...catch....

抛出异常:经常使用的是throws:在方法声明上抛出(抛出的是一个异常类名),可以抛出多个异常,中间用逗号隔开;

throw:抛出:抛出一个异常对象,一般情况匿名对象

throw new Exception();

在方法中抛出

Finally:释放资源

一般用在IO流中或者是数据库中;

 try{

     .....

}catch(异常类名 变量名){

处理异常

}finally{  //这里代码的一定会执行,除非Jvm退出了.

在释放流资源的时候,不要忘了进行非空判断

释放资源

}

给catch中加入return语句,finally中的代码还会执行,在return前

自定义异常类的方法

自定义一个类,该类继承自RuntimeException或者是Exception....

异常中的注意事项:

 1:子类继承父类,父类中的成员抛出异常,那么子类重写的这个方法要么是跟它抛出的异常一样,要么是异常的子类...

2:子类继承父类,如果父类中的方法没有抛出异常,子类重写该方法不能抛出异常,只能try...catch...finally:捕获

二File:文件或者文件夹的抽象路径表现形式

构造方法:File(String pathName) ;

创建文件夹:

mkdir()

mkdirs();当不存在文件夹的时候,依次创建父目录

创建文件:createNewFile():  该方法抛出异常:IOException

获取功能:length():文件长度

getAbsolutepath():绝对路径

getPath():相对路径

public  File[]  listFiles();获取当前盘符下的所有的文件以及文件夹的File数组

public  File[]  listFiles(Filenamefilter file):参数是一个接口:文件名称过滤器

 

 三    IO流

1 IO流的分类:

1 按方向划分:

输入流:读取数据

输出流:写输出数据

2 按数据类型分:先有的字节流,然后有了字符流:

如果我们针对是文本文件操作,优先采用字符流,使用记事本打开并且能读懂;

如果使用记事本打开,读不懂,比如:图片文件,音频,视频等等....使用字节流进行操作

字节输入流 :InputStream:抽象类:FileInputStream

字节输出流: OutputStream:抽象类FileOutputStream

应用:1)创建文件输出流对象

常用的构造方式:FileOutputStream(“xxx.txt”) ;

FileOutputStream out = new FileOutputStream(“xxx.txt”) ;

       2)写数据:

writer(int by )

wirter(byte[] bys)

writer(byte[] bys,int index ,int len);

    3)释放资源:关闭流对象out.close();

字符输入流:Reader:FileReader

字符输出流:Writer:FileWriter

 

一 文件的字节输入流

使用改流读数据

public FileInputStream(String name)

开发步骤:

1)创建字节文件输入流对象

2)读数据

3)释放资源

读数据的两种方式:

1)public int read():一次读取一个字节

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

public class FileInputStreamDemo {

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

//1)创建文件输入流对象

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

FileInputStream fis = new FileInputStream("FileInputStreamDemo2.java") ;

//2)读数据

public int read():一次读取一个字节

第一次读:

    int by = fis.read() ;

System.out.println(by);.

System.out.println((char)by);

第二次读取

by = fis.read() ;

System.out.println(by);

System.out.println((char)by);

第三次读取

by = fis.read() ;

System.out.println(by);

System.out.println((char)by);

第四次读取

by = fis.read() ;

System.out.println(by);

System.out.println((char)by);

 上面代码重复非常高,采用循环,由于文件如果内容很多,不知道循环的次数,所以采用  while循环,该循环应该有一个结束条件,.通过观察,当该文件读取完毕了,返回-1就是结束条件 优化改进

int by = fis.read() ;

while(by!=-1){

System.out.println((char)by);

by = fis.read() ;

}

最终版代码:

读取,赋值,判断

一次读取一个字节的模板代码

int by = 0 ;

while((by=fis.read())!=-1){

System.out.print((char)by);

}

//释放资源

fis.close() ;

 

                                                          

 

public class FileInputStreamDemo2 {

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

//1)创建文件字节输入流对象

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

FileInputStream fis = new FileInputStream("FileInputStreamDemo.java") ;

//2)读数据

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

//定义一个字节数组

byte[] bys = new byte[5] ;

//1)10KB

    //指定的字节数组的长度是1024或者是1024的倍数

//第一次读取

int len = fis.read(bys) ;                                                                                                                                     

System.out.println(new String(bys,0,len));

 

//第二次读取

len = fis.read(bys) ;

System.out.println(len);

System.out.println(new String(bys));

//第三次读取

len = fis.read(bys) ;

System.out.println(new String(bys));

//第四次读取

len = fis.read(bys) ;

    System.out.println(new String(bys));

 上述代码重复度高,使用while循环来进行优化改进

//如果使用模板带去去读取数据:一次读取一个字节数组

//定义缓冲区大小:指定长度为1024

byte[] bys = new byte[1024] ;

int len = 0 ; //读取字节数的实际长度

while((len=fis.read(bys))!=-1){

System.out.println(new String(bys))

//从指定的索引开始(指定0),读取的是实际长度

System.out.println(new String(bys,0,len));//推荐使用这种格式读取数据:从0开始,读取实际长度

}

}

}

 

 

 

需求:在当前项目下有一个:a.txt文件

将a.txt文件的内容赋值到b.txt文件中

  1)数据源:a.txt------->FileInputStream:输入流------->读数据

  2)目的地:b.txt------->FileOutputStream:输出流------>写数据

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class CopyFileDemo {

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

//封装数据源:

//创建一个文件字节输入流对象

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

//封装目的地

//创建文件输出流对象

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

//一次读取一个字节:模板代码

int by = 0 ;

while((by=fis.read())!=-1){

//一次读一个字节,使用输出流给b.txt文件写一个字节

fos.write(by) ;

}

//释放资源

fos.close() ;

fis.close() ;

}

}

 

 

一次读取一个字节数组的读取方式

public class Test3 {

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

//封装数据源和目的地

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

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

//一次读取一个字节数组

byte[] bys = new byte[1024] ;

int len = 0 ;

while((len=fis.read(bys))!=-1){

//写数据的

fos.write(bys, 0, len) ;

}

//释放资源

fis.close() ;

fos.close() ;

}

}

 

 

 

 字节缓冲输入流:BufferedInputStream

 构造方法:

BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象

缓冲输入流:一次读取一个字节:

 一次读取一个字节数组

 两种方式的读取任选一种:

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class BufferedInputStreamDemo {

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

//创建一个字节缓冲输入流对象

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")) ;

//一次读取一个字节数组或者一次读取一个字节都可以

byte[] bys = new byte[1024] ;

int len = 0 ;

while((len=bis.read(bys))!=-1){

System.out.println(new String(bys,0,len));

}

//释放资源

bis.close() ;

}

}

 由于字节数组比一次读取一个字节更快,从而引出类更高效的一种流:字节缓冲流

 字节缓冲输入流:BufferedInputStream

 字节缓冲输出流:BufferedOutputStream

  构造方式:

public BufferedOutputStream(OutputStream out):默认缓冲区大小(默认缓冲大小已经足够大了)

为什么字节缓冲流不能直接针对文件进行操作呢?

缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作

 flush()和close()方法的区别?

 flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.

close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedOutputStreamDemo {

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

//创建字节缓冲输出流对象

BufferedOutputStream bos = new BufferedOutputStream(

new FileOutputStream("bos.txt"));//Java的一种设计模式:装饰者设计模式:Scanner sc = new Scanner(System.in) ;

//写数据

bos.write(97) ;

//刷新该缓冲区的流

bos.flush() ;//迫使将这写字节强制输出流中

bos.write(98) ;

//释放资源

bos.close() ;

bos.flush() ;

}

}

 

 计算机是如何识别中文的?

1)每个中文左边对应的字节一定是负数

2)GBK格式:右边的字节可以是正数,可以是0,可以是负数

package DAY18;

 

import java.util.Arrays;

public class String2 {

public static void main(String[] args) {

//定义一个字符串

String s1 = "abcde" ;

//[97, 98, 99, 100, 101]

String s = "我爱你tututu" ;

//当前平台默认的编码集:GBK:一个中文对应两个字节

//[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

//将当前字符串转换成字节数组

byte[] bys = s.getBytes() ;

byte[]bys2= s1.getBytes();

//System.out.println(bys);

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

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

}

}

;

 

对于图片文件,音频文件,视频文件,优先采用字节缓冲输入流(高效流)一次读取一个字节数组字节流复制文件:

 基本字节流(FileInputStream)一次读取一个字节:共耗时:253820毫秒

 基本字节流一次读取一个字节数组:共耗时:396毫秒

 高效字节流(字节缓冲输入流)一次读取一个字节:共耗时:98020毫秒

 高效字节流(字节缓冲输入流)一次读取一个字节数组:共耗时:317毫秒

 复制e:\\abc.mp4文件---->当前项目下的Copy.mp4文件

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException

public class CopyFileDemo {

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

long startTime = System.currentTimeMillis() ;

method1("E:\\abc.mp4","Copy.mp4") ;

method2("E:\\abc.mp4","Copy.mp4") ;

method3("E:\\abc.mp4","Copy.mp4") ;

method4("E:\\abc.mp4","Copy.mp4") ;

long endTime = System.currentTimeMillis() ;

System.out.println("共耗时:"+(endTime-startTime)+"毫秒");

}

//高效字节流一次读取一个字节数组

private static void method4(String SrcString, String destString) throws IOException{

//封装数据源和目的地

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;

//一次读取一个字节数组

byte[] bys = new byte[1024] ;

int len = 0 ;

while((len=bis.read(bys))!=-1){

bos.write(bys, 0, len) ;

bos.flush() ;//刷新缓冲区的流

}

//释放资源

bis.close() ;

bos.close() ;

}

 

//字节缓冲输入流一次读取一个字节

private static void method3(String SrcString, String destString) throws IOException {

//创建字节缓冲输入对象

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;

//一次读取一个字节

int by = 0 ;

while((by=bis.read())!=-1){

bos.write(by)  ;

bos.flush() ;

}

//释放资源

bis.close() ;

bos.close() ;

}

 

//基本的字节流一次读取一个字节数组

private static void method2(String SrcString, String destString) throws IOException {

//封装数据源

FileInputStream fis = new FileInputStream(SrcString) ;

//封装目的地

FileOutputStream fos = new FileOutputStream(destString) ;

//一次读取一个字节数组

byte[] bys = new byte[1024] ;

int len = 0 ;

while((len=fis.read(bys))!=-1){

//边读边写

fos.write(bys, 0, len) ;

}

//释放资源

fis.close() ;

fos.close() ;

}

 

//基本字节流一次读取一个字节

private static void method1(String StrString, String destString) throws IOException {

//封装数据源

FileInputStream fis = new FileInputStream(StrString) ;

//封装目的地

FileOutputStream fos = new FileOutputStream(destString) ;

//一次读取一个字节

//并且一次写一个字节

int by = 0 ;

while((by=fis.read())!=-1){

//写数据

fos.write(by) ;

}

//释放资源

fis.close() ;

fos.close() ;

}

}

 

 字节流一次读取一个字节,出现了中文乱码:

 原因是:给字节进行强制类型转换,代码代码的注释中有中文,并且平台默认编码:GBK格式:一个中文对应的两个字节

 使用字符流来进行操作:

 字符流就必须指定编码格式

import java.io.FileInputStream;

import java.io.IOException;

public class FileInputStreamDemo {

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

//创建字节输入流对象

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

//一次读取一个字节

int by = 0 ;

while((by=fis.read())!=-1){

System.out.print((char)by);

}

//释放资源

fis.close() ;

}

}

编码:就是能看懂的字符串转换成看不懂的字节数组

public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)

解码:就是将看不懂的字节数组----->能看懂的:将字节数组--->字符串

public String(byte[] bytes, Charset charset)通过使用指定的 编码格式 解码指定的byte 数组，构造一个新的String

"老"----->字节数组----->二进制数据---->

解码:二进制数据----->十进制数据----->字节数组----->构造方式:字符串

import java.io.IOException;

import java.util.Arrays;

public class StringDemo {

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

String s = "爱你" ;

//编码

byte[] bys = s.getBytes("utf-8") ;//:GBK[-80, -82, -60, -29]

//utf-8:[-25, -120, -79, -28, -67, -96]

//如果不写编码格式:默认GBK

byte[] bys = s.getBytes() ;//[-80, -82, -60, -29]

System.out.println(bys);

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

//解码

//public String(byte[] bytes, Charset charset)

String str = new String(bys, "GBK") ;

String str = new String(bys) ;//默认GBK

System.out.println(str);//爱你

}

}

 

 

 

 

字符输入流:字节输入流+编码格式(默认GBK)

public InputStreamReader(InputStream in,charset sc) ;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

public class InputStreamReaderDemo {

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

//创建字符输入流对象

InputStreamReader isr = new InputStreamReader(new FileInputStream(

"osw.txt"), "GBK");

InputStreamReader isr = new InputStreamReader(new FileInputStream(

"osw.txt"));//以GBK格式读数据

//读数据:一次读取一个字符

int ch = 0 ;

while((ch=isr.read())!=-1){

System.out.print((char)ch);

}

char[] chs = new char[1024] ;

int len = 0;

while((len=isr.read(chs))!=-1){

System.out.println(new String(chs, 0, len));

}

//释放资源

isr.close() ;

}

}

 

 

 

字符输出流:Writer:是一个抽象类

使用的是该抽象类的子类:OutputStreamWriter------>字符转换流:可以将字节输出流转换字符流

public OutputStreamWriter(OutputStream out,Charset cs):创建一字符输出转换流对象,指定编码格式

字节输出流+编码格式---->字符输出流

编码格式:使用平台的默认编辑集进行编码:GBK

public OutputStreamWriter(OutputStream out) ;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.Writerpublic

 class OutputStreamWriterDemo {

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

//创建一个字符输出流对象

//public OutputStreamWriter(OutputStream out,Charset cs)

// Writer w = new OutputStreamWriter(new FileOutputStream("w.txt"), "GBK") ;//抽象类多态

// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

// "osw.txt"), "GBK");

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

"osw.txt"));//默认GBK

//写数据

osw.write("rng") ;

//释放资源

osw.close() ;

}

}

 

 

 

 

 

需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作

数据源:a.txt---->Reader---->InputStreamReader(InputStream in):字符转换输入流

目的地:b.txt---->Writer---->OutputStreamWriter(Outputstream out):字符转换输出流

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class CopyFileTest {

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

//1)创建字符转换输入流对象

InputStreamReader isr = new InputStreamReader(new FileInputStream(

"a.txt"));

//2)封装目的地

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

"b.txt"));

//一次读取一个字符数组

char[] chs = new char[1024] ;

int len = 0;

while((len=isr.read(chs))!=-1){

//写数据:

osw.write(chs, 0, len) ;

//刷新流

osw.flush() ;

}

//释放资源

isr.close() ;

osw.close() ;

}

}

 

 

 

 

 使用字符转换流进行操作数据的时候:字节流+编码格式

 并且在书写代码名称非常长,Java提供了以中更简单的类:便捷类:

字符转换输入流:InputStreamReader----->FileReader

FileReder(String fileName)

字符转换输出流:OutputStreamWriter---->FileWriter

FileWriter(String fileName)

需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作

数据源:a.txt---->字符流读数据:InputStreamReader------>便捷类:FileReader

目的地:b.txt---->字符流写数据:OutputStreamWriter----->便捷类:FileWriter

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReaderDemo {

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

//1)封装数据源和目的地

FileReader fr = new FileReader("a.txt") ;

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

//一次读取一个字符数组

char[] chs = new char[1024] ;

int len = 0 ;

while((len=fr.read(chs))!=-1){

fw.write(chs, 0, len) ;

fw.flush() ;

}

//关闭资源

fw.close() ;

fr.close() ;

}

}

 

 

 

字符输入流读数据的方式:

public int read():一次读取一个字符

public int read(char[] chs):一次读取一个字符数组

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

public class InputStreamReaderDemo {

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

//1)创建字符输入流对象

InputStreamReader isr = new InputStreamReader(new FileInputStream(

"FileInputStreamDemo2.java"));

//2)方式1:一次读取一个字符

int ch = 0 ;

while((ch=isr.read())!=-1){

System.out.print((char)ch);

}

//2)方式2:一次读取一个字符数组

char[] chs = new char[1024] ;

int len = 0 ;

while((len=isr.read(chs))!=-1){

System.out.println(new String(chs, 0, len));

}

//释放资源

isr.close() ;

}

}

 

 

 

 

  关于字符输出流写数据的方法:

 public void write(int c):写单个字符

 public void write(char[] cbuf):写一个字符数组

 public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分

 public void write(String str):写字符串

 public void write(String str, int off,int len):写字符串的一部分

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

public class OutputStreamDemo {

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

//创建字符输出流对象

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

"osw2.txt"));

//写数据

//public void write(int c):写单个字符

osw.write(97) ;

osw.write('a') ;

//public void write(char[] cbuf):写一个字符数组

//定义一个字符数组:静态初始化

char[] chs = {'a','b','c','d','e'}  ;

osw.write(chs) ;

//public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分

osw.write(chs, 1, 3) ;

//public void write(String str):写字符串

String str = "电子竞技" ;

osw.write(str) ;

//public void write(String str, int off,int len):写字符串的一部分

osw.write(str, 1, 3) ;

//void flush()刷新该流

osw.flush() ;

//关闭流对象

osw.close() ;

// osw.write('b') ;//字符输出流:如果流已经关闭,那么写数据会报异常!

}

}

 

 

 

 

 关于字符缓冲输入流的特有功能:

 BufferedWriter:

public void newLine():写入一个换行符号

  BufferReader:

public String readLine():一次读取一行

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class BufferedDemo {

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

write();

read();

}

private static void read() throws FileNotFoundException, IOException {

//读数据

//创建一个字符缓冲输入流对象

BufferedReader br = new BufferedReader(new FileReader("bw2.txt")) ;

//读数据

//public String readLine():一次读取一行

/*String line = br.readLine() ;

System.out.println(line);

//第二次读取

line = br.readLine() ;

System.out.println(line);

//这种方式读数据:

当数据读取完毕,如果返回值是null,说明已经读完了

//代码重复度高,使用循环改进

String line = null ;

while((line=br.readLine())!=null){

System.out.println(line);

}

//释放资源

br.close() ;

}

 

private static void write() throws IOException {

//写数据

//创建一个字符缓冲输出流对象

BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")) ;

//写数据

for(int x = 0 ; x <10 ; x ++){

bw.write("hello"+x) ;

//没有使用这个方法之前:使用写入换行符号

// bw.write("\r\n") ;

//使用特有功能

bw.newLine() ;

//刷新该流

bw.flush() ;

}

//释放资源

bw.close() ;

}

}

 

 

 

 

 字符缓冲输入流

BufferedReader

BufferedReader(Reader in) :创建默认缓冲大小

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class BufferedReaderDemo {

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

//1)创建字符缓冲输入流对象

BufferedReader br = new BufferedReader(new FileReader("RNG.txt")) ;

//方式1:一次读取一个字符

int ch = 0 ;

while((ch=br.read())!=-1){

System.out.print((char)ch);

}

//方式2:一次读取一个字符数组

char[] chs = new char[1024] ;

int len = 0 ;

while((len = br.read(chs))!=-1){

System.out.println(new String(chs, 0, len));

}

//关闭资源

br.close() ;

}

}

 

 

 

 字符流为了提高读写速度,Java就提供了一个字符缓冲流的类:

 BufferedReader:字符缓冲输入流

 BufferedWriter:字符缓冲输出流

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

 可以指定缓冲区的大小，或者接受默认的大小

 

 构造方式:

 public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流

import java.io.BufferedWriter;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

public class BufferedWriterDemo {

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

//创建字符缓冲输出流对象

//public BufferedWriter(Writer out)

/*BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(

new FileOutputStream("bw.txt")));*/

BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;

//写数据

bw.write("javaee") ;

bw.write("hello") ;

bw.write("world") ;

bw.write("java") ;

//刷新流

bw.flush() ;

//关闭资源

bw.close() ;

}

}

 

 

 

 

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.util.Scanner;

public class Demo {

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

//1)创建键盘录入对象

/*Scanner sc = new Scanner(System.in);//InputStream is = System.in;

System.out.println("请您输入一个字符串:");

String line = sc.nextLine() ;

System.out.println(line);*/

//使用IO流的形式读数据

//BufferedReadr进行包装

/* InputStream is = System.in ;//标准输入流

//不能使用is对象对它进行读取数据,BufferedReader可以

//BufferedReader br = new BufferedReader(is) ;//字符缓冲输入流只能针对字符输入流进行操作,不能针对字节流进行操作

//需要将标准输入流转换成字符输入流:InputStreamReader(InputStream in)

//创建字符转换输入流对象

InputStreamReader isr = new InputStreamReader(is) ;

//创建字符缓冲输入流对象

BufferedReader br = new BufferedReader(isr) ;*/

//一步走

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

System.out.println("请输入一个整数:");

String str = br.readLine() ;//返回值是一个字符串

int number = Integer.parseInt(str) ;

System.out.println("您输入的整数是:"+number);

//标准输出流

// PrintStream out = System.out ;

//PrintWriter

}

}

 

 

递归的三个条件:

1)定义一个方法

2)必须有规律

3)要有出口条件

课堂练习递归:

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问

第二十个月的兔子对数为多少？

public class DiGuituzi {

public static void main(String[] args) {

//定义一个数组:动态初始化

int[] arr =new int[20] ;

//第一个月和第二个月兔子对数都是已知的

arr[0] = 1 ;

arr[1] = 1 ;

//arr[2] =arr[0]+arr[1] ;

//arr[3] =arr[1]+arr[2] ;

for(int x = 2 ; x < arr.length; x ++){

//计算出每一个月兔子对数的数据

arr[x]  = arr[x-1]+arr[x-2];

}

System.out.println("第二十个月兔子的对数是:"+arr[19]);//6765

System.out.println("----------------------");

System.out.println("第二十个月兔子的对数是:"+fib(20));//6765

}

 //n表示月份

 //返回值是兔子的对数

     //第一个月和第二个月兔子的对数1:从第三个月开始,每一个月兔子对数的数据是前两个月之和

private static int fib(int n) {

if(n==1 || n==2){//出口条件

return 1 ;

}else{

return fib(n-1) +fib(n-2) ;//中间的规律

}

}

}