11.25日笔记
来源:互联网 发布:矩阵优化 编辑:程序博客网 时间:2024/06/17 00:22
使用改流读数据
public FileInputStream(String name)
读数据的两种方式:
1)public int read():一次读取一个字节
2)public int read(byte[] b):一次读取一个字节数组
返回的是实际读取的字节数
使用文件输入流一次读取一个字节数组
package qx.work_02;import java.io.FileInputStream;import java.io.IOException;public class FileInputStreamDemo {public static void main(String[] args) throws IOException {//创建文件输入流对象FileInputStream fis = new FileInputStream("fis.txt");int by = 0;while((by = fis.read())!=-1){System.out.println(by);}fis.close();
//如果使用模板带去去读取数据:一次读取一个字节数组//定义缓冲区大小:指定长度为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文件的内容赋值到b.txt文件中
分析:
1)数据源:a.txt------->FileInputStream:输入流------->读数据
2)目的地:b.txt------->FileOutputStream:输出流------>写数据
public class CopyFileDemo {public static void main(String[] args) throws IOException {//封装数据源://创建一个文件字节输入流对象FileInputStream fis = new FileInputStream("a.txt") ;//封装目的地//创建文件输出流对象FileOutputStream fos = new FileOutputStream("b.txt") ;//一次读取一个字节:模板代码int by = 0 ;while((by=fis.read())!=-1){//一次读一个字节,使用输出流给b.txt文件写一个字节fos.write(by) ;}//释放资源fos.close() ;fis.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() ;//bos.write(99) ;}}
计算机是如何识别中文的?
1)每个中文左边对应的字节一定是负数
2)GBK格式:右边的字节可以中正数,可以是0,可以是负数
package qx.work_02;import java.util.Arrays;public class StringDemo {public static void main(String[] args) {//定义一个字符串//String s = "abcde" ;//[97, 98, 99, 100, 101]String s = "西安科技大学" ;//当前平台默认的编码集:GBK:一个中文对应两个字节//[-50, -9, -80, -78, -65, -58, -68, -68, -76, -13, -47, -89]//将当前字符串转换成字节数组byte[] bys = s.getBytes() ;//System.out.println(bys);System.out.println(Arrays.toString(bys));}}
对于图片文件,音频文件,视频文件,优先采用字节缓冲输入流(高效流)一次读取一个字节数组!
字节流复制文件:
基本字节流(FileInputStream)一次读取一个字节
基本字节流一次读取一个字节数组
高效字节流(字节缓冲输入流)一次读取一个字节
高效字节流(字节缓冲输入流)一次读取一个字节数组
import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOExceptionpublic 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() ;}}
编码:就是能看懂的字符串转换成看不懂的字节数组
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]//如果不写编码格式:默认GBKbyte[] 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) ;//默认GBKSystem.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------>字符转换流:可以将字节输出流转换字符流
publicOutputStreamWriter(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):字符转换输出流
importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.OutputStreamWriter;publicclass CopyFileTest { public static void main(String[] args)throws IOException { //1)创建字符转换输入流对象 InputStreamReader isr = newInputStreamReader(new FileInputStream( "a.txt")); //2)封装目的地 OutputStreamWriter osw = newOutputStreamWriter(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(StringfileName)
字符转换输出流:OutputStreamWriter---->FileWriter
FileWriter(StringfileName)
需求:把当前项目目录下的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() ;}}
字符输入流读数据的方式:
publicint read():一次读取一个字符
publicint 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,intoff,int len):写入字符数组的一部分
public void write(String str):写字符串
public void write(String str, int off,intlen):写字符串的一部分
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:
publicvoid newLine():写入一个换行符号
BufferReader:
publicString 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)要有出口条件
课堂练习递归:
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]);//6765System.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) ;//中间的规律}}}
- 11.25日笔记
- 标日笔记下载
- 29r日笔记
- 4.12日学习笔记
- 3.24日学习笔记
- 9.1日课堂笔记
- 十月16日笔记
- java/11.11日/笔记
- Java/11.12日/笔记
- 11.26日笔记
- 12.2日笔记
- 12月27日笔记
- 24日的学习笔记
- 5月31日笔记
- 6月1日笔记
- 6月2日笔记
- 6月4日笔记
- 6月5日笔记
- Mysql| Mysql分组函数
- 如何避免内存泄漏?
- LeetCode 15. 3Sum
- ScrollView监听是否滑动到底部
- 自动化测试之页面元素组织
- 11.25日笔记
- jmeter报错java.lang.NoSuchMethodError: org.apache.jmeter.samplers.SampleSaveConfiguration.setFormatter
- JavaScript 对象(一)
- android app 安装后的名称
- Android Handler 机制实现原理分析
- HDOJ 2162 Add ‘em(水题)
- Linux下内核编译
- 旋转数组的最小数
- 操作系统-最坏适应算法