标签:父类 sea return print reference 图片 表示 output path
目录
IO流用来处理设备之间的数据传输,Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中,
输入流(读取数据)
输出流(写数据)
字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
字符流 : 字符流只能操作纯字符数据,比较方便。
InputStream
OutputStream
Reader
Writer
直接已知子类:
●AudioInputStream
●ByteArrayInputStream
●FileInputStream(学习文件输入流)
●FilterInputStream
●ObjectInputStream
●PipedInputStream
●SequenceInputStream
●StringBufferInputStream
FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流,请考虑使用 FileReader
FileInputStream(File file)
FileInputStream(String name)
int read() 从此输入流中读取一个数据字节。
1.FileInputStream用于读取文件数据,在构造方法中传入文件对象
2.构造方法,有可能抛出文件找不到的异常
4.文件不用后,要关闭输入流,避免占用资源
package lesson10;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 读取txt文件内容
* 1.通过FileInputStream来读取txt文件内容
* 2.读取内容通过read方法,
* 》read方法每次读文件1个字节(byte),把byte转成int返回
》当读到后的时候,返回-1,-1表示读取文件结束
3.当读完文件后,这个输入流要关闭,释放资源
*
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//FileNotFoundException fnfe;
//案例:读取txt文件内容
//1.创建一个文件对象
File file = new File("a.txt");
//2.创建一个文件输入流【读取文件数据】对象
FileInputStream fis1 = new FileInputStream(file);
//再创建一个文件输入 流对象
FileInputStream fis2 = new FileInputStream("b.txt");
//3.读取a.txt的数据
/**
* 1.read方法每次读文件1个字节(byte),把byte转成int返回
* 2.当读到后的时候,返回-1,-1读取文件结束
*/
System.out.println(fis1.read());
System.out.println(fis1.read());
System.out.println(fis1.read());
System.out.println(fis1.read());
//4.关闭流
fis1.close();
fis2.close();
}
}
//1.创建一个文件对象
File file = new File("abc.txt");
System.out.println(file.getAbsolutePath());
//2.创建一个文件输入流
FileInputStream inputStream = new FileInputStream(file);
int b;
//while循环里,每次读取字节赋值给b
while((b = inputStream.read()) != -1){
System.out.println(b);
}
因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111 那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上 24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型
***
***
package lesson12;
public class Demo01 {
public static void main(String[] args) {
//面试题:read()方法读取的是一个字节,为什么返回是int,而不是byte ?
//如果使用FileInputStream读取图片数据
/**
* 00010111 00010111 00010111 00010111
* 00010111 11111111 00010111 00010111
*
* byte:11111111 表示的-1
* int:00000000 00000000 00000000 11111111 byte转成int 补0 了不是-1 因此往后读数据
*
* 为什么11111111是表示-1?
* 因为计算机是以补码的方式计算
* 补码: 11111111 (-1)
* 反码: 11111110
* 原码: 10000001
*
* 假如使用FileInputStream读取图片的时候,
* 图片中间有一段数据刚好是 11111111,这八个一表示的-1,用byte接收
* java程序如果读取的是-1,后面的数据就不读取
* 如果把8个1转成int,那就是00000000 00000000 00000000 11111111,这个表示255,
* 就不是-1,归避后面数据没有读取问题
*
*/
}
}
文件输出流是用于将数据写入 File 的输出流。
FileOutputStream 用于写入诸如图像数据之类的原始字节的流。
查看文档的构造方法和成员方法
案例:往一个abc.txt文件写数据(知识点)
new FileOutputStream(file)这种构造方法,会把以前的内容都删除
new FileOutputStream(file,true);这种构造方法能追加内容
FileNotFoundException是IOException的子类
write(int b),写数据
package lesson13;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo01 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
/* FileOutputStream:表示文件输出流,用于往文件写内容
*
* 构造方法
* FileOutputStream(String name)
* FileOutputStream(File file)
*
* 方法
* write(int b);//每次写一个字节
* write(byte[] b) ;//一次写多个字节
* */
//案例:往b.txt 写个内容
//1.创建文件输出流对象
//FileOutputStream fos = new FileOutputStream("b.txt");
OutputStream fos = new FileOutputStream("b.txt");//多态写法
//2.写数据
// fos.write(97);//a
// fos.write(98);//b
// fos.write(99);//c
//一次性写多个字节
byte[] bytes = {97,98,99,100,101};
fos.write(bytes);
//3.关闭流
fos.close();
}
}
***
package lesson14;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:拷贝图片
/**
* 目的:结合输入流和输出流使用
*
* 图片路径:C:\Users\10301\Desktop\a\cm.jpg
*/
//1.先创建输入流对象和输出流对象
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/cm.jpg");
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/cm2.jpg");
//2.通过输入流读取图片的数据
int b = 0;
while( (b = fis.read()) != -1){
//3.通过输出流写入图片数据
fos.write(b);
}
//4.关闭流
fos.close();
fis.close();
System.out.println("图片拷贝成功");
}
}
package lesson01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:拷贝图片【优化一、这种方式在大文件下不建议使用】
/**
* 前面拷贝图片问题:每次只读一个字节,写入的时候也是一个字节一个字节写
* 如果有10W个字节,就要读10W次,写10W次
*
* 字节数组拷贝之available()方法
*/
//1.文件输入流
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/cm.jpg");
int size = fis.available();//是返回文件的长度【字节为单位】
System.out.println("文件的大小:" + size);
//2.现在一次读文件大小的字节
//2.1定义一个字节数组
byte[] bytes = new byte[size];//相当于现在是一个空杯子
//2.2 把数据读到字节数组中
int r = fis.read(bytes);//这个方法的返回值读取到的实际长度
System.out.println("r:" + r);
//3.把字节数组一次性写入到文件
//3.1 输出流
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/cm-副本.jpg");
//3.2 写数据
fos.write(bytes);
//4.关闭流
fis.close();
fos.close();
}
}
1.输入流读取数据的方法:
read(byte[] b) 读取指定字节数的数据
2.输出流写数据的方法:
write(byte[] b)
write(byte[] b, int off, int len)写出有效的字节个数
***
package lesson02;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 杯子思想,缓冲思想
* @author gyf
*
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:拷贝图片【优化二、这种方式开发中建议经常使用】
/**
* 1.每次只读一个字节,又觉得太慢
* 2.一次性读一个文件的所有数据,又怕内存装不下
* 内存只有2G,视频3G,这样就会内存溢出
*
* 3.最终解决方法:折中,定义每次读8KB
*
*/
//1.输入流
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/cm.jpg");
//2.输出流
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/cm-副本2.jpg");
//3.定义个8kb字节数组,也叫缓冲区流
byte[] bytes = new byte[1024 * 8];
int len = 0;
int i = 0;
while( (len = fis.read(bytes)) != -1){
i++;
//4.写入文件
fos.write(bytes,0,len);
}
System.out.println("读取的次数:" + i);
//5.关闭流
fis.close();
fos.close();
}
}
***
package lesson03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.创建文件输入流
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/ghsy.mp3");
//2.创建文件输出流
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/ghsy-副本.mp3");
//3.输入流读数据、输出流写数据
int b = 0;
while( (b = fis.read()) != -1){
fos.write(b);
}
//4.关流
fis.close();
fos.close();
System.out.println("音频拷贝完成...");
}
private static void test1() throws FileNotFoundException, IOException {
/* BufferedInputStream和BufferedOutputStream
>这两个流是内置了缓冲区流,也就是说内部有一个字节数组
>这个两个类没有前面我们写的好用,因为它内部每次读8kb字节,如果想读80kb,没办法
*/
//案例:拷贝音频文件
//1.创建缓冲输入流
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/ghsy.mp3");
BufferedInputStream bis = new BufferedInputStream(fis);
//2.创建缓冲输出流
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/ghsy-副本.mp3");
BufferedOutputStream bos =new BufferedOutputStream(fos);
//3.输入流读数据、输出流写数据
int b = 0;
// bis.read()方法,内部会读8kb数据
while( (b = bis.read()) != -1){
bos.write(b);//内部会写8kb数据
}
//4.关流,只需要关缓冲流,文件流不用关
bis.close();//【内部会关文件流输入流】
bos.close();//【内部会关文件流输出流】
System.out.println("音频拷贝完成...");
}
}
自己写 的数组的读写和带Buffered的读取哪个更快?
自己写数组会略胜一筹,因为读和写操作的是同一个数组
而Buffered操作的是两个数组
close()方法
用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
package lesson05;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//BufferedOutputStream的flush和close方法的区别
/* flush()方法
1.用来刷新缓冲区的,刷新后可以再次写出
close()方法
2.用来关闭流释放资源的
3.如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
*/
//案例:把a文件的内容拷贝到b文件
//1.输入流
FileInputStream fis = new FileInputStream("a.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//2.输出流
FileOutputStream fos = new FileOutputStream("b.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.读写操作
int b = 0;
while( (b = bis.read()) != -1){
bos.write(b);
}
bos.flush();
bos.write(97);
//bos.flush();
//4.关闭流
bis.close();
bos.close();
}
}
字节流读取中文:
字节流读取中文的问题
字节流在读中文的时候有可能会读到半个中文,造成乱码
package lesson06;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo06 {
public static void main(String[] args) throws IOException {
//字节流读写中文乱码问题
//1.读数据
//创建文件输入流
FileInputStream fis = new FileInputStream("a.txt");
//读
//定义字节数组[杯子思想,缓冲区思想]
/**
* 在UTF-8编码表中,一个中文占3个字节,一个英文占1个字节
* 在GBK编译中,一个中文占2个字节
*/
byte buf[] = new byte[3];
int len = 0;
while( (len = fis.read(buf)) != -1){
System.out.println("len:" + len );
//把字节转成字符串
String s = new String(buf, 0, len);
System.out.println("s:" + s);
}
}
}
字节流写入中文的问题
字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
写出回车换行 write("\r\n".getBytes());
package lesson07;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:往a.txt文件写中文
//1.输出流
FileOutputStream fos = new FileOutputStream("a.txt");
//2.写中文
String s = "你好,Gosling最近好吗?";
//把字符转成字节数组
//byte[] bytes = s.getBytes();
/**
* charsetName 字符编码 UTF-8(Unicode),GBK,ASCII
*/
byte[] bytes = s.getBytes("UTF-8");
fos.write(bytes);
//3.关流
fos.close();
}
}
package lesson08;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException{
//流的标准处理异常代码-jdk1.6版本及其以前
//案例:a.txt的内容拷贝到b.txt
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
try {
//读写数据会抛出
int b = 0;
while((b = fis.read()) != -1){
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//关流
try {
fis.close();
}finally {
fos.close();
}
}
}
public static void test1() throws FileNotFoundException {
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
try {
//读写数据会抛出
int b = 0;
while((b = fis.read()) != -1){
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//关流
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
原理:在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉
package lesson09;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Demo01 {
public static void main(String[] args)throws Exception {
//流的标准处理异常代码1.7版本
/**
* 1.把流对象的声明放在try() 括号里面
* 2.操作流【读写数据】的代码放在花括号里面
* 3.这样写不用关闭流,java自动关闭流
* 4.在try的括号里的对象,必须是实现AutoCloseable的接口
*/
try(
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
//Person p = new Person();
//声明一个自己输入流
MyInputStream myis = new MyInputStream();
){
int b = 0;
while((b = fis.read()) != -1){
fos.write(b);
}
}
}
}
class Person{
}
class MyInputStream implements AutoCloseable{
@Override
public void close() throws Exception {
System.out.println("我的输入流关闭了...");
}
}
package lesson10;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
//练习:图片加密
//1.输入输出流
FileInputStream fis = new FileInputStream("C:/Users/10301/Desktop/a/cm2.jpg");
FileOutputStream fos = new FileOutputStream("C:/Users/10301/Desktop/a/cm.jpg");
//2.读写数据
/**
* 加密操作
* 解密操作
*
* 一个数异或2次,数据不变
*/
int b = 0;
while((b = fis.read()) != -1){
fos.write(b ^ 5);
}
//3.关流
fis.close();
fos.close();
System.out.println("图片加密完成");
}
}
package lesson11;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) throws IOException {
//练习:根据用户输入的文件[图片]拷贝文件到当前项目目录
//C:/Users/10301/Desktop/a/cm2.jpg
//1.获取用户输入的文件路径
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个文件的路径[请不要输入文件夹路径]:");
String path = scanner.nextLine();
//2.判断这个路径是否为文件
File file = new File(path);
if(file.isDirectory()){
System.out.println("您输入的路径不是一个文件");
return;
}
//3.如果是文件就拷贝
//3.1 输入流
FileInputStream fis = new FileInputStream(path);
//3.2输出流
FileOutputStream fos = new FileOutputStream(file.getName());
//3.3读写【性能】
byte[] buf = new byte[8 * 1024];
int len = 0;
while((len = fis.read(buf)) != -1){
fos.write(buf, 0, len);
}
//3.4关流
fis.close();
fos.close();
System.out.println("文件拷贝完成...");
}
}
/** * 根据用户在键盘中输入的内容,然后写到一个文件中去 * */
package lesson12;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) throws IOException {
//练习:录入数据拷贝到文件
//1.创建一个文件输出流
FileOutputStream fos = new FileOutputStream("new.txt");
//2.创建一个Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要录入内容...输入quit代表退出");
//3.通过死循环来获取用户输入【当输入quit,代表不录入】
while(true){
//获取用户的输入
String line = scanner.nextLine();
//退出循环
if(line.equals("quit")){
break;
}
//写入文件
fos.write(line.getBytes());
//换行
fos.write("\r\n".getBytes());
}
//4.关流
fos.close();
}
}
1、字符流是可以直接读写字符的IO流
2、字符流读取字符, 就要先读取到字节数据, 然后转为字符.
3、写入字符, 需要把字符转为字节再写出.
FileReader 读取字符流类
FileWrite 写入字符流类
查看API的方法
案例:使用FileReader 读取一个文本数据(知识点):
1、read方法是读取字符char
2、一个字符可能占用1个字节,2个字节,或者3个字节
3、占用字节个的数根据码表决定(ASCII:1字节,GBK:2字节 unicode:3个字节)
4、用int表示字节,假如读取到2个字节,int有4个字节,前个两个字节可以补0
5、GBK,unicode中,中文的字符的第一个字节都是负数,所以知道怎么去读取
6、读取的方式与FileInputStream字节流差不多,会用FileInputStream,就会用 FileReader
package lesson13;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* 以后读纯文本文件,使用FileReader这个类,为什么?因为我们不用考虑乱码问题
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//读字节
FileInputStream fis = new FileInputStream("a.txt");
//int 00000000 00000000 00000000 11111111
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
System.out.println((byte)fis.read());
}
public static void test1() throws FileNotFoundException, IOException {
//FileReader
/**
* FileReader 用于读取字符
*/
//1.创建对象
FileReader reader = new FileReader("a.txt");
//2.读取数据
/**
* reader.read() : 先读取到字节数据, 然后转为字符
*/
System.out.println((char)reader.read());
System.out.println((char)reader.read());
System.out.println((char)reader.read());
System.out.println((char)reader.read());
System.out.println((char)reader.read());
System.out.println(reader.read());
int c;
while((c = reader.read()) != -1){
System.out.println((char)c);
}
//3.关闭流
reader.close();
}
}
1.其实内部是通过一个字符数组缓冲区写入文件
2.内部方法,创建一个字符串长度的字符数组缓存区
package lesson14;
import java.io.FileWriter;
import java.io.IOException;
/**
* FileWiter:
* 掌握:
* 1.write方法使用
* 2.write方法内部实现,内部是通过一个字符数组缓冲区写入文件
*
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
//FileWiter 文件写入流、文件写入字符流
//案例:使用FileWiter往一个文件a.txt写内容
//1.创建writer对象
FileWriter writer = new FileWriter("a.txt");
//2.写内容
writer.write("你好!");
writer.write("\r\n");
writer.write("你好!");
writer.write("\r\n");
writer.write("你好!");
writer.write("\r\n");
writer.write("你好!");
//3.关闭
writer.close();
}
}
//案例:字符流的拷贝
//思路:用FileReader读字符,用FileWriter写字符
package lesson15;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:字符流的拷贝
//思路:用FileReader读字符,用FileWriter写字符
//1.创建 “读取流” 对象
FileReader reader = new FileReader("a.txt");
//2.创建 "写入流" 对象
FileWriter writer = new FileWriter("b.txt");
//3.读取和写入【缓冲思想】
char[] buf = new char[8 * 1024];
int len = 0;
while( (len = reader.read(buf)) != -1){
writer.write(buf, 0, len);
}
//4.关闭流
reader.close();
writer.close();
}
public static void test1() throws FileNotFoundException, IOException {
//1.创建 “读取流” 对象
FileReader reader = new FileReader("a.txt");
//2.创建 "写入流" 对象
FileWriter writer = new FileWriter("b.txt");
//3.读取和写入
int c = 0;
while((c = reader.read()) != -1){
writer.write(c);
}
//4.关闭流
reader.close();
writer.close();
}
}
package lesson01;
import java.io.FileWriter;
public class Demo01 {
public static void main(String[] args) {
//使用字符流的场景
/**
* 1.使用FileReader读取字符
* 原理:先读字节,把字节转成字符(byte -> char)
* 2.使用FileWriter写入字符
* 原理:writer(String str),str 转成 字符数组 再转成 字节写入文件
* (string -> char[] -> char -> byte)
* 如果是读取文本文件,使用FileReader比较好,不考虑乱码问题
* 如果是写入文本文件,不建议使用FileWriter,直接使用FileOutputStream好一点
*/
}
}
package lesson02;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
/**
* 带缓冲的字符流 BufferedReader/BufferedWriter
* 1.这两个类,内部都一个缓冲区,字符数组
* 2.br.read()方法,内部会读8192(8*1024)个字符
* 3.bw.write(),内部会写8192(8*1024)个字符
*
* 回顾:带缓冲的字节流,BufferedInputStream/BufferedOutputStream
* 1.这两个类,内部都一个缓冲区,字节数组
*/
//需求:拷贝文件,a.txt -> b.txt
//1.创建Reader
FileReader fr = new FileReader("a.txt");
BufferedReader br = new BufferedReader(fr);
//2.创建Writer
FileWriter fw =new FileWriter("b.txt");
BufferedWriter bw = new BufferedWriter(fw);
//3.读写
int c = 0;
while( (c = br.read()) != -1){
bw.write(c);
}
//4.关流
br.close();//内部关闭FileReader
bw.close();//内部关闭FileWriter
}
}
package lesson03;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//BufferedReader的readLine()&BufferedWriter的newLine()方法
/**
* 1.readLine(),每次读取一行数据
*/
//1.创建Reader
FileReader fr = new FileReader("a.txt");
BufferedReader br = new BufferedReader(fr);
//2.读一行数据
/* System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());*/
String line = null;
while((line = br.readLine()) != null){
System.out.println(line);
}
//3.关流
br.close();
}
}
package lesson04;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//BufferedWriter的newLine()方法
// newLine()换行
//往b.txt写a.txt文件的内容【一行一行拷贝,读一行写一行】
//1.创建Reader
FileReader fr = new FileReader("a.txt");
BufferedReader br = new BufferedReader(fr);
//2.创建writer
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bw = new BufferedWriter(fw);
//3.读一行写一行
String line = null;
while((line = br.readLine()) != null){
bw.write(line);
/**
* 当使用readline读取一行数据时,不会读回车换行"\r\n"字符
*/
//bw.write("\r\n");
bw.newLine();//换行
}
//4.关流
br.close();
bw.close();
}
}
BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)
BufferedWriter的newLine()可以输出一个跨平台的换行符号"\r\n"
一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
package lesson05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 掌握思想:
* 1.for循环的倒序遍历
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//案例:将文本反转写入另一个文件
//1.把文本每一行内容读取出来存在List<String> 集合
//1.1 集合对象
List<String> list = new ArrayList<String>();
//1.2一行行读取文件
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
String line = null;
while((line = br.readLine()) != null){
list.add(line);
}
System.out.println(list);
//2.当我们要写入文件时,倒序保存List集合中的内容到文件中
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
for(int i = list.size() - 1 ; i>=0; i--){
bw.write(list.get(i));
bw.newLine();//换行
}
//3.关闭流
br.close();
bw.close();
System.out.println("finish....");
}
}
装饰模式的概念:
动态的给一个对象添加一些额外的功能,就增加功能来说,装饰模式比生成子类更为灵活。
在不必改变原类文件和使用继承的情况下,动态的扩展一个对象的功能。
它是创建一个包装对象,也就是使用装饰来包裹真实的对象。
适用性
装饰模式的实现方式
案例1:
package lesson06;
public class Demo01 {
public static void main(String[] args) {
//
/**
* 一、设计模式【一种固定代码风格】
* 面试题:Java中有哪些设计模式
* 常用设计模式:装饰模式、单例模式、模版模式、适配器模式、代理模式、工厂模式...
*
* 二、装饰(Decorator)设计模式
* 1.装饰模式的概念:
装饰模式是动态的给一个对象添加一些额外的功能,就增加功能来说,装饰模式比生成子类更为灵活。
装饰模式是在不必改变原类文件和使用继承的情况下,动态的扩展一个对象的功能。
装饰模式是创建一个包装对象,也就是使用装饰来包裹真实的对象。
2.装饰模式的实现方式
1. 装饰对象和真实对象有相同的接口/抽象类。
2. 装饰对象包含一个真实对象的引用(reference)
3. 装饰对象的所有方法,内部实现都是通过真实对象的引用来调用,然后实现自己的功能
3.适用性
1. 需要扩展一个类的功能,或给一个类添加附加职责。
2. 当不能采用生成子类来实现,比如final类
*/
/* BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
BufferedOutputStream bos;
BufferedReader br;
BufferedWriter bw;*/
/*GYFStudent stu = new GYFStudent();
stu.code();*/
GYFStudent stu = new GYFStudent(new UniversityStudent());
stu.code();
}
}
//1.接口
interface Person{
public void code();
}
//2.接口实现类
final class UniversityStudent implements Person{
@Override
public void code() {
// TODO Auto-generated method stub
System.out.println("在大学期间学了一点点C语言...");
}
}
/*class GYFStudent extends UniversityStudent{
@Override
public void code() {
// TODO Auto-generated method stub
super.code();
System.out.println("在GYF IT EDU 学习Java语言...");
}
}*/
class GYFStudent implements Person{
private UniversityStudent us;
public GYFStudent(UniversityStudent us){
this.us = us;
}
//装饰对象的所有方法,内部实现都是通过真实对象的引用来调用,然后实现自己的功能
@Override
public void code() {
us.code();
System.out.println("在GYF IT EDU 学习Java语言...");
}
}
案例2:
package com.gyf.lesson09;
public class Demo {
public static void main(String[] args) {
GYFStudent stu = new GYFStudent();
stu.coding();
}
}
interface Person {
//人可以具备编码的功能
public void coding();
}
//大学生
class UniversityStudent implements Person{
@Override
public void coding() {
System.out.println("我会一点c基础编程...");
}
public void piano(){
System.out.println("我会钢琴...");
}
}
//第一种继承类的写法
class GYFStudent extends UniversityStudent{
@Override
public void coding() {
// TODO Auto-generated method stub
super.coding();
System.out.println("我会java基础编程了...");
}
}
//class GYFStudent implements Person{
//
// private UniversityStudent uStu;
//
// public GYFStudent(UniversityStudent uStu) {
// super();
// this.uStu = uStu;
// }
//
//
// @Override
// public void coding() {
// // TODO Auto-generated method stub
// uStu.coding();
// System.out.println("我会java基础编程了...");
// }
//}
这两个类用于使用指定的码表读写字符
FileReader是使用默认码表读取文件, 如果需要使用指定码表读取请使用InputStreamReader(字符流,编码表)
FileWriter是使用默认码表写出文件, 如果需要使用指定码表写入请使用OutputStreamWriter(字符流,编码表)
package lesson07;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo01 {
public static void main(String[] args) throws IOException {
/* InputStreamReader&OutputStreamWriter
1>这两个类用于使用指定的码表读写字符*/
//案例1:使用指定 “码表UTF-8&GBK” 读取字符
/**
* charsetName:字符编码的名称
*/
FileInputStream fis = new FileInputStream("a.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
//读一个字符
/* System.out.println((char)isr.read());
System.out.println((char)isr.read());*/
//读一行
BufferedReader br = new BufferedReader(isr);
System.out.println(br.readLine());
br.close();
}
}
案例2:
package lesson07;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
* 掌握:
* 1.当读取文件内容,还有写入文件,可以指定编码格式
* 2.使用InputStreamReader&OutputStreamWriter这个类
* @author gyf
*
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
/* OutputStreamWriter
1>使用指定的编码 写入文件
*/
//1.创建Writer
FileOutputStream fos = new FileOutputStream("c.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
BufferedWriter bw = new BufferedWriter(osw);
//2.写
bw.write("你好,IO流...搞的我有点晕...");
bw.newLine();
bw.write("你好,IO流...搞的我有点晕...");
bw.newLine();
//3.关流
bw.close();
}
}
package lesson08;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
* 掌握:当键盘敲 enter键,两个字符\r\n : 回车换行
*
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//练习:获取文本上字符出现的次数,把数据写入文件
/* 思路:
1.遍历文本每一个字符
2.字符出现的次数存在Map中
*//**
* Map<Character,Integer> map = new HashMap<Character,Integer>();
* map.put('a',18);
* map.put('你',2);
*//*
3.把map中的数据写入文件*/
//==================================
//1.创建Map集合
Map<Character,Integer> map = new HashMap<Character,Integer>();
//System.out.println(map.get('a'));
//2.遍历每一个字符,每一个字符出现的次数放到map中
FileReader reader = new FileReader("a.txt");
int c = 0;
while((c = reader.read()) != -1){
//int 还原 char
char ch = (char)c;
// 判断char是否在map中第一次出现
if(map.get(ch) == null){
map.put(ch, 1);
}else{
map.put(ch, map.get(ch) + 1);
}
}
//3.把map中数据存在文件count.txt
//3.1 创建Writer
BufferedWriter bw = new BufferedWriter(new FileWriter("count.txt"));
//3.2 遍历map,再写入数据
for(Entry<Character, Integer> entry :map.entrySet()){
switch (entry.getKey()) {
case ' ':
bw.write("空格=" + entry.getValue());
break;
case '\t'://\t表示tab 键字符
bw.write("tab键=" + entry.getValue());
break;
case '\r'://
bw.write("回车=" + entry.getValue());
break;
case '\n'://
bw.write("换行=" + entry.getValue());
break;
default:
bw.write(entry.getKey() + "=" + entry.getValue());
break;
}
bw.newLine();
}
//4.关流
reader.close();
bw.close();
}
}
递归做为一种算法,在程序设计语言中广泛应用。
递归:就方法内部调用自己
递归的弊端:不能调用次数过多,容易导致栈内存溢出
递归的好处:不用知道循环次数
构造方法是否可以递归调用?
构造方法不能使用递归调用
递归调用是否必须有返回值?
不一定(可以有,也可以没有)
package lesson09;
public class Demo01 {
public static void main(String[] args) {
//递归
/**
* 递归做为一种算法,在程序设计语言中广泛应用。
递归:就方法内部调用自己
递归的弊端:不能调用次数过多,容易导致栈内存溢出
递归的好处:不用知道循环次数
*/
//使用递归来写乘阶
int r = jiecheng(116);
System.out.println("r=" + r);
}
/**
* jiecheng(6) i = 6
* 6 * jecheng(5)
* 6 * 5 * jecheng(4)
* 6 * 5 * 4 * jecheng(3)
* 6 * 5 * 4 * 3 * jecheng(2)
* 6 * 5 * 4 * 3 * 2 * jecheng(1)
* 6 * 5 * 4 * 3 * 2 * 1
*/
public static int jiecheng(int i){
if(i==1){
return 1;
}else{
return i * jiecheng(i - 1);
}
}
/**
* 使用for循环写阶乘
*/
public static void test1() {
//5!-5的阶乘,5个乘阶
//5*4*3*2*1
int r = 1;//结果
for(int i=1;i<=5;i++){
r = r * i;
/**
* i = 1 ; r = 1*1
* i = 2 ; r = 1* 1 * 2
* i = 3 ; r = 1* 1 * 2 * 3
* .....
*/
}
System.out.println("r=" + r);
}
}
package lesson10;
import java.io.File;
/**
* 任务:计算一个文件夹大小:累加文件的大小
* @author gyf
*
*/
public class Demo01 {
public static void main(String[] args) {
//递归:文件目录
/**打印出a目录所有文件名称,包括子文件夹的文件*/
//1.创建目录对象
File dir = new File("C:/Users/10301/Desktop/a");
//2.打印目录的子文件
printSubFile(dir);
}
public static void printSubFile(File dir){
//打印目录的子文件
File[] subfiles = dir.listFiles();
for(File f : subfiles){
if(f.isDirectory()){//文件夹
printSubFile(f);
}else{//文件
System.out.println(f.getAbsolutePath());
}
}
}
}
练习:从键盘输入接收一个文件夹路径,打印出该文件夹下所有的.jpg文件名
package lesson11;
import java.io.File;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//练习:从键盘输入接收一个文件夹路径,打印出该文件夹下所有的.jpg文件名
//1.获取文件路径
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个文件夹路径...");
String path = scanner.nextLine();
//2.把路径封装成File对象
File file = new File(path);
if(!file.exists()){
System.out.println("此路径对应的文件不存在");
return;
}
if(!file.isDirectory()){
System.out.println("请输入文件夹路径,而不文件路径");
return;
}
//3.遍历文件夹下的子文件
printSubFile(file);
}
public static void printSubFile(File dir){
//打印目录的子文件
File[] subfiles = dir.listFiles();
for(File f : subfiles){
if(f.isDirectory()){//文件夹
printSubFile(f);
}else{//文件
if(f.getName().endsWith(".jpg")){
System.out.println(f.getAbsolutePath());
}
}
}
}
}
标签:父类 sea return print reference 图片 表示 output path
原文地址:https://www.cnblogs.com/wanghui1234/p/9500616.html