package com.it.demo02_lambda;
//接口, 表示动物.
//public abstract class Animal { //报错, Lambda表达式只针对于接口有效
public interface Animal {
//抽象方法, 表示吃饭.
public abstract void eat();
//void sleep(); //报错, Lambda表达式只针对于一个抽象方法有效.
}
package com.it.demo02_lambda;
/*
案例: Lambda表达式初体验(入门)
需求:
1.已知接口Animal中有一个抽象方法eat()
2.在测试类AnimalTest中定义show(Animal an)方法, 实现调用Animal#eat()方法.
3.并在main方法中, 调用AnimalTest#show()方法.
Lambda表达式简介:
概述:
它是JDK1.8的特性, 体现的是 函数式编程思想, 即: 我们告诉程序做什么就行了, 怎么做是程序的事儿, 创建哪些对象, 重写什么方法也是程序的是, 我们不关心.
格式:
(形参列表) -> {
方法体, 即: 告诉程序需要它做的事儿.
}
解释:
形参列表: 和以前定义方法时的形参列表一样.
-> : 表示具体的指向动作, 固定格式.
方法体 : 和以前定义的方法体一致, 就是告诉程序需要它做的事儿
前提:
Lambda表达式只针对于: 有且只能有一个抽象方法的接口有效.
*/
public class AnimalTest {
public static void main(String[] args) {
//并在main方法中, 调用AnimalTest#show()方法.
//方式一: 定义子类Cat, 实现Animal接口, 多态的方式创建 Animal接口的子类对象.
//方式二: 匿名内部类, 体现的是 面向对象 编程思想,
//即: 对象还需要我们自己new, 逻辑还要我们告诉对象.
show(new Animal() {
@Override
public void eat() {
System.out.println("我是匿名内部类, 动物会吃!");
}
});
System.out.println("----------------------");
//方式三: Lambda表达式实现, 体现的是 函数式 编程思想.
//即: 告诉程序做什么, 怎么做是程序的事儿, 创建哪些对象, 重写什么方法也是程序的是, 我们不关心.
show(() -> {
System.out.println("我是匿名内部类, 动物会吃!");
});
}
//在测试类AnimalTest中定义show(Animal an)方法, 实现调用Animal#eat()方法.
public static void show(Animal an) { //Animal an = new Cat();
an.eat();
}
}
package com.it.demo02_lambda;
//表示具有加法运算的功能
public interface Addable {
//表示加法运算
int add(int x,int y);
}
package com.it.demo02_lambda;
/*
Lambda表达式案例: 演示有参有返回值的方法.
需求:
定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
定义一个测试类(AddableDemo)，在测试类中提供两个方法
一个方法是：useAddable(Addable a)
一个方法是主方法，在主方法中调用useAddable方法
*/
public class AddableTest {
public static void main(String[] args) {
//需求: 调用useAddable(Addable a)方法
//方式一: 匿名内部类
useAddable(new Addable() {
@Override
public int add(int x, int y) {
System.out.println("匿名内部类");
return x + y;
}
});
System.out.println("-----------------------------");
//方式二: Lambda表达式
useAddable((int x, int y) -> {
System.out.println("Lambda表达式");
return x + y;
});
}
//定义方法useAddable(Addable a), 接收Addable接口的子类对象.
public static void useAddable(Addable a) {
int sum = a.add(10, 20);
System.out.println(sum);
}
}
package com.it.demo02_lambda;
//表示具有吃饭的功能
public interface Eatable {
//吃饭
void eat();
}
package com.it.demo02_lambda;
/*
Lambda表达式案例: 演示无参无返回值的方法.
需求:
–定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
–定义一个测试类(EatableDemo)，在测试类中提供两个方法
•一个方法是：useEatable(Eatable e)
•一个方法是主方法，在主方法中调用useEatable方法
*/
public class EatableTest {
public static void main(String[] args) {
//需求: 调用useEatable()方法
//useEatable(Eatable接口的子类对象);
//方式一: 匿名内部类, 体现的是 面向对象 编程思想.
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("匿名内部类, 吃饭!");
}
});
System.out.println("----------------------------");
//方式二: Lambda表达式, 体验的是 函数式 编程思想.
useEatable(() -> {
System.out.println("Lambda表达式, 吃饭!");
});
}
//定义方法：useEatable(Eatable e), 调用Eatable#eat()
public static void useEatable(Eatable e) {
e.eat();
}
}
package com.it.demo02_lambda;
//表示具有 飞翔 的功能
public interface Flyable {
//飞翔的功能
void fly(String s);
}
package com.it.demo02_lambda;
/*
Lambda表达式案例: 演示有参无返回值的方法.
需求:
定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
定义一个测试类(FlyableDemo)，在测试类中提供两个方法
一个方法是：useFlyable(Flyable f)
一个方法是主方法，在主方法中调用useFlyable方法
*/
public class FlyableTest {
public static void main(String[] args) {
//需求: 调用useFlyable(Flyable f)方法.
//格式: useFlyable(Flyable接口的子类对象)
//方式一; 匿名内部类.
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println("匿名内部类");
System.out.println(s); //"风和日丽, 晴空万里"
System.out.println("适合开飞机自驾游!");
}
});
System.out.println("-------------------");
//方式二: Lambda表达式.
useFlyable((String s) -> {
System.out.println("Lambda表达式");
System.out.println(s); //"风和日丽, 晴空万里"
System.out.println("适合开飞机自驾游!");
});
}
//定义方法 useFlyable(Flyable f), 接收Flyable对象.
public static void useFlyable(Flyable f){
f.fly("风和日丽, 晴空万里");
}
}
package com.it.demo02_lambda;
/*
案例: 演示Lambda表达式的省略模式.
规则:
1. 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
2. 如果参数有且仅有一个，那么小括号可以省略
3. 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
*/
public class Demo01_省略模式 {
public static void main(String[] args) {
//演示: 1. 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
//useFlyable((String s) -> {
useFlyable((s) -> { //参数类型可以省略
System.out.println(s);
System.out.println("适合开飞机进行自驾游!");
});
System.out.println("------------------");
//useAddable((int x,int y) -> {
//useAddable((x,int y) -> { //报错, 有多个参数的情况下，不能只省略一个
useAddable((x,y) -> {
return x + y;
});
System.out.println("------------------");
//演示: 2. 如果参数有且仅有一个，那么小括号可以省略
useFlyable(s -> { //小括号可以省略
System.out.println(s);
System.out.println("适合开飞机进行自驾游!");
});
System.out.println("------------------");
//演示: 3. 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
useEatable(() -> System.out.println("动物会吃!"));
//多态, 父接口引用指向子类对象(Lambda表达式会帮我们创建)
Addable a = (x, y) -> x + y;
useAddable((x, y) -> x + y);
}
//定义方法, 接收Eatable对象.
public static void useEatable(Eatable e) {
e.eat();
}
//定义方法, 接收Flyable对象.
public static void useFlyable(Flyable f) {
f.fly("风和日丽, 晴空万里!");
}
//定义方法, 接收Addable对象.
public static void useAddable(Addable a) {
int sum = a.add(11, 22);
System.out.println(sum);
}
}
package com.it.demo03_exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
案例: 异常入门.
异常简介:
概述:
Java中, 把程序出现不正常的情况统称为: 异常.
分类:
Throwable: 异常体系的顶层类.
Error: 表示错误, 一般和我们的代码没关系, 也不需要我们处理, 你也处理不了.
服务器宕机, 数据库崩溃.
Exception: 表示异常, 这个才是我们常说的异常, 需要程序员处理.
编译期异常: 发生在编译期间的异常.
非RuntimeException及其子类都是: 编译期异常.
运行时异常: 当程序运行之后, 才会出现的异常.
RuntimeException及其子类都是: 运行时异常.
JVM的默认处理异常的方式:
1. 会将异常的类型, 出现的原因以及异常出现的位置打印到控制台上.
2. 并终止程序的执行.
*/
public class Demo01 {
public static void main(String[] args) {
int a = 10;
int b = 0;
System.out.println(a / b); //运行时异常.
System.out.println("看看我执行了吗?");
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
//String s = "2020/08/02";
//Date date = sdf.parse(s); //编译期异常.
}
}
package com.it.demo03_exception;
/*
案例: 演示如何自己处理异常.
异常的处理方式:
方式一: try.catch.finally语句, 捕获异常.
格式:
try{
//这里写的是可能出现问题的代码.
}catch(异常类型 对象名) {
e.printStackTrace(); //该方法会将异常的类型, 原因, 位置打印到控制台上.
} finally{
//正常情况下, 这里的代码永远会执行, 一般是用来释放资源的.
}
特点:
1. try.catch.finally处理完异常之后, 程序会继续执行.
2. 先走try,
如果代码没有出问题, 当try执行完后, 会执行finally里边的内容.
如果代码有问题, 会立马跳到catch语句中执行, catch执行完毕后, 会执行finally里边的内容.
方式二: throws处理, 表示 声明抛出异常.
*/
public class Demo02 {
public static void main(String[] args) {
try{
//这里写的是可能出现问题的代码.
int a = 10;
int b = 0;
System.out.println(a / b);
System.out.println("看看我执行了吗? try语句...");
}catch(Exception e) {
e.printStackTrace(); //该方法会将异常的类型, 原因, 位置打印到控制台上.
} finally{
//正常情况下, 这里的代码永远会执行, 一般是用来释放资源的.
System.out.println("我是finally, 我是释放资源的");
}
System.out.println("看看我执行了吗? try走完了.");
}
}
package com.it.demo03_exception;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
案例: 演示 throws声明抛出异常.
特点:
会将异常的类型, 原因, 以及异常出现的位置打印到控制台上, 并终止程序的执行.
*/
public class Demo03 {
public static void main(String[] args) { //调用者, 买西瓜的.
//调用show()方法
try {
show();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("看看我执行了吗? ");
}
//定义show()方法
public static void show() throws Exception{ //被调用者, 卖西瓜的.
//方式一: try.catch处理, 调用者无需处理了.
/* try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
String s = "2020/08/02";
//遇到异常了, 请问, 怎么办?
Date date = sdf.parse(s); //编译期异常.
System.out.println(date);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("我是释放资源的");
}*/
//方式二: 声明抛出异常, 即: 告诉调用者我这里有问题, 但是我不处理, 交给调用者处理.
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
String s = "2020年08月02日";
//遇到异常了, 请问, 怎么办?
Date date = sdf.parse(s); //编译期异常.
System.out.println(date);
}
}
package com.it.demo03_exception;
/*
案例: 演示关于异常的两个小问题
思考题如下:
1.final, finally, finalize三个关键字之间的区别是什么?
final: 最终. //Day07
finally: 释放资源.
finalize: 是Object类中的一个方法, 当对象变成垃圾的时候, 由GC调用该对象的此方法, 来回收对象.
2.finally里边的代码真的永远会执行吗?
是的, 正常情况下永远会执行. 当然非正常情况也存在, 例如: 还没有来得及执行finally呢, 程序退出了, 或者断电了,
则finally里边的代码就不会执行了.
*/
public class Demo04 {
public static void main(String[] args) {
try {
//可能出问题的代码.
int a = 10;
int b = 0;
System.out.println(a / b); //运行时异常.
System.out.println("看看我执行了吗?");
} catch (Exception e) {
//出现问题后的解决方案
e.printStackTrace();
//System.err.println("给夯哥发短信, 说程序有问题...");
System.exit(0); //退出正在执行的JVM,
} finally {
System.out.println("我一般是用来: 释放资源的");
}
}
}
package cn.it.demo;
/*
* Throwable
* Exception 异常 感冒,阑尾炎
* 将异常处理掉,可以继续执行
* RuntimeException
* Error 非典,艾滋,癌
* 必须修改程序
*/
public class Demo {
public static void main(String[] args) {
/*int[] arr = new int[99999999];
System.out.println(arr[3]);*/
}
}
package cn.it.demo;
/*
* 异常中的关键字
* throw,在方法内部,抛出异常的对象
* throw 后面,必须写new 对象,必须是异常的对象,必须是Exception或者子类
*
* 方法中声明异常关键字
* throws 用于在方法的声明上,标明次方法,可能出现异常
* 请调用者处理
* throws 后面必须写异常类的类名
*
* 调用了一个抛出异常的方法,调用者就必须处理
* 不处理,编译失败
*/
public class ExceptionDemo {
public static void main(String[] args) throws Exception {
int[] arr = {};
int i = getArray(arr);
System.out.println(i);
}
//对数组的最后索引*2,返回
public static int getArray(int[] arr) throws Exception {
//对方法参数进行合法性的判断,进行判断是不是null
if( arr == null){
//抛出异常的形式,告诉调用者
//关键字 throw
throw new Exception("传递数组不存在");
}
//对数组进行判断,判断数组中,是不是有元素
if(arr.length == 0){
//抛出异常的形式,告诉调用者,数组没有元素
throw new Exception("数组中没任何元素");
}
int i = arr[arr.length-1];
return i*2;
}
}
package cn.it.demo;
/*
* 异常的处理方式:
* try...catch...finally
* 格式:
* try{
* 被检测的代码
* 可能出现异常的代码
* }catch(异常类名 变量){
* 异常的处理方式
* 循环,判断,调用方法,变量
* }finally{
* 必须要执行代码
* }
*/
public class ExceptionDemo1 {
public static void main(String[] args) {
int[] arr = null;
try{
int i = getArray(arr);
System.out.println(i);
}catch(NullPointerException ex){
System.out.println("###"+ex);
}catch(ArrayIndexOutOfBoundsException ex){
System.out.println("!!!!!!"+ex);
}
System.out.println("Game Over");
}
/*
* 定义方法,抛出异常
* 调用者使用try catch
*/
public static int getArray(int[] arr)throws NullPointerException,ArrayIndexOutOfBoundsException{
//对数组判空
if( arr == null){
//手动抛出异常,抛出空指针异常
throw new NullPointerException("数组不存在");
}
//对数组的索引进行判断
if( arr.length < 3){
//手动抛出异常,抛出数组的索引越界异常
throw new ArrayIndexOutOfBoundsException("数组没有3索引");
}
return arr[3]+1;
}
}
package cn.it.demo;
import java.util.NoSuchElementException;
/*
* 多catch写在一起
* 细节:
* catch小括号中,写的是异常类的类名
* 有没有顺序的概念,有
*
* 平级异常: 抛出的异常类之间,没有继承关系,没有顺序
* NullPointerException extends RuntimeException
* NoSuchElementException extends RuntimeException
* ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException
*
* 上下级关系的异常
* NullPointerException extends RuntimeException extends Exception
* 越高级的父类,写在下面
*/
public class ExceptionDemo2 {
public static void main(String[] args) {
try{
}catch(NullPointerException ex){
}
catch(Exception ex){
}
}
public static void function(int a)throws NullPointerException,Exception{
if(a == 0){
throw new NullPointerException();
}
if(a == 1){
throw new Exception();
}
}
}
package cn.it.demo;
/* try{
* 被检测的代码
* 可能出现异常的代码
* }catch(异常类名 变量){
* 异常的处理方式
* 循环,判断,调用方法,变量
* }finally{
* 必须要执行代码
* }
* finally,无论程序是否有异常出现,程序必须执行
* 释放资源
*/
public class ExceptionDemo3 {
public static void main(String[] args) {
try{
function(0);
}catch(Exception ex){
System.out.println(ex);
}finally{
System.out.println("代码必须执行");
}
}
public static void function(int a)throws Exception{
if( a == 0)
throw new Exception();
System.out.println(a);
}
}
package cn.it.demo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo4 {
public static void main(String[] args) {
try{
function();
}catch(ParseException ex){
}
}
public static void function()throws ParseException{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse("2088-8-8");
System.out.println(date);
}
}
package cn.it.demo1;
/*
* 异常分为编译异常和运行时期异常
* 编译异常: 调用了抛出异常的方法,不处理编译失败 (try throws)
* 运行异常: 抛出的异常是RuntimeException类,或者是他的子类
*
* 运行异常的特点:
* 方法内部抛出的异常是运行异常, new XXXException
* 方法的声明上,不需要throws语句,调用者,不需要处理
* 设计原因:
* 运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码
*
* 运行异常: 一旦发生,不要处理,请你修改源代码, 运行异常一旦发生,后面的代码没有执行的意义
*/
public class RuntimeExceptionDemo {
public static void main(String[] args) {
double d = getArea(1);
System.out.println(d);
}
/*
* 定义方法,计算圆形的面积
* 传递参数0,或者负数,计算的时候没有问题
* 但是,违反了真实情况
* 参数小于=0, 停止程序,不要在计算了
*/
public static double getArea(double r){
if(r <= 0)
throw new RuntimeException("圆形不存在");
return r*r*Math.PI;
}
public static void function(){
int[] arr = {1,2,3};
//对数组的5索引进行判断,如果5索引大于100,请将5索引上的数据/2,否则除以3
//索引根本就没有
if(arr[5] > 100){
arr[5] = arr[5]/2;
}else{
arr[5] = arr[5]/3;
}
}
}
package cn.it.demo2;
/*
* 继承后,在子类重写父类方法的时候,异常处理
* 结论:
* 父类的方法,如果抛出异常,子类重写后
* 可以不抛出异常
* 也可以抛出异常,但是,如果子类要抛,抛出的异常不能大于父类的异常
* 大于,都指的是继承关系
*
* 父类的方法,没有异常抛出,子类重写后
* 也不能抛出异常
* 如果子类中调用了抛出异常的方法,别无选择,只能try..catch处理
*/
public class ExceptionDemo {
public static void main(String[] args) {
Fu f = new Zi();
f.function();
}
}
class Fu{
public void function(){
}
}
class Zi extends Fu{
public void function(){
try {
method();
} catch (Exception e) {
e.printStackTrace();
}
}
public void method()throws Exception{
}
}
package cn.it.demo2;
/*
* Throwable类中的方法
* 三个方法,都和异常的信息有关系
* String getMessage() 对异常信息的详细描述 异常了!
* String toString() 对异常信息的简短描述 java.lang.Exception: 异常了!
* void printStackTrace() 将异常信息追踪到标准的错误流 异常信息最全,JVM默认调用方法也是这个方法
*/
public class ExceptionDemo1 {
public static void main(String[] args) {
try{
function();
}catch(Exception ex){
//System.out.println(ex.toString());
ex.printStackTrace();
}
}
public static void function() throws Exception{
throw new Exception("异常了!");
}
}
package cn.it.demo3;
public class ExceptionDemo {
public static void main(String[] args) {
int avg = getAvg(50,60,-70,80);
System.out.println(avg);
}
/*
* 传递成绩,计算成绩的平均数
* 成绩没有负数,需要抛出异常,停止运算
*/
public static int getAvg(int...source){
int sum = 0 ;
for(int s : source){
if( s < 0){
throw new FuShuException("成绩错误 "+s);
}
sum = sum + s;
}
return sum/source.length;
}
}
package cn.it.demo3;
/*
* 自定义异常
* 继承Exception,或者继承RuntimeException
* 构造方法中,super将异常信息,传递给父类
*/
public class FuShuException extends RuntimeException{
public FuShuException(String s){
super(s);
}
public FuShuException(){}
}
package com.it.demo04_file;
import java.io.File;
/*
案例: File类入门.
File类简介:
概述:
它是用来描述文件(夹)的, 通过 路径的形式进行描述.
大白话翻译: File表示 文件(夹)的路径.
构造方法:
public File(String pathName); 根据给定的目录, 获取其对应的File对象.
public File(String parent, String child); 根据给定的字符串形式的父目录 和 子目录名, , 获取其对应的File对象.
public File(File parent, String child); 根据给定的File对象形式的父目录 和 子目录名, , 获取其对应的File对象.
细节:
为什么要设计这么多的构造方法呢?
就是为了满足用户灵活多变的需求, 在不同的场景下, 有不同的构造方法可以选择.
*/
public class Demo01 {
public static void main(String[] args) {
//需求: 定义File对象, 描述: d:/abc/1.txt
//方式一: public File(String pathName); 根据给定的目录, 获取其对应的File对象.
File file1 = new File("d:/abc/1.txt");
//File file1 = new File("d:\\abc\\1.txt");
//方式二: public File(String parent, String child); 根据给定的字符串形式的父目录 和 子目录名, , 获取其对应的File对象.
File file2 = new File("d:/abc", "1.txt");
//方式三: public File(File parent, String child); 根据给定的File对象形式的父目录 和 子目录名, , 获取其对应的File对象.
File file3 = new File("d:/abc");
File file4 = new File(file3, "1.txt");
//打印结果:
System.out.println("file1: " + file1);
System.out.println("file2: " + file2);
System.out.println("file4: " + file4);
}
}
package com.it.demo04_file;
import java.io.File;
import java.io.IOException;
/*
案例: 演示File类的创建功能.
涉及到的File类中的成员方法:
public boolean createNewFile() 当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir() 创建由此抽象路径名命名的目录, 创建单级目录
make directory: 制造文件夹
public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录, 能创建单级目录, 也能创建多级目录.
细节:
1. 上述三个方法都是, 文件(夹)不存在就创建, 返回true, 存在就不创建, 返回false.
2. 创建文件时, 要求其父目录必须存在.
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
//需求1: 创建 d:/abc/1.txt文件
File file1 = new File("d:/abc/1.txt");
System.out.println(file1.createNewFile());
System.out.println("--------------------");
/*File file2 = new File("d:/aaa/1.txt");
System.out.println(file2.createNewFile()); //报错, 创建文件时, 要求其父目录必须存在.*/
//需求2: 创建 d:/aa 文件夹
File file2 = new File("d:/aa");
System.out.println(file2.mkdir()); //创建单级目录
/*File file3 = new File("d:/aa/bb/cc");
System.out.println(file3.mkdir()); //false, 因为mkdir()只能创建单级目录.
*/
System.out.println("--------------------");
//需求3: 创建 d:/aa/bb/cc/dd 文件夹
File file3 = new File("d:/aa/bb/cc/dd");
System.out.println(file3.mkdirs()); //创建多级目录(也能创建单级目录)
}
}
package com.it.demo04_file;
import java.io.File;
/*
案例: 演示File类的判断功能
涉及到的File类的成员方法:
public boolean isDirectory() 测试此抽象路径名表示的File是否为(存在的)目录
public boolean isFile() 测试此抽象路径名表示的File是否为(存在的)文件
public boolean exists() 测试此抽象路径名表示的File是否存在
细节:
isDirectory(), isFile()方法都默认包含了 exists()方法的功能.
*/
public class Demo03 {
public static void main(String[] args) {
//需求1: 测试 public boolean exists() 测试此抽象路径名表示的File是否存在
File file1 = new File("d:/abc/1.txt");
System.out.println(file1.exists()); //判断文件(夹)是否存在的.
System.out.println("-------------------");
//需求2: 测试public boolean isFile() 测试此抽象路径名表示的File是否为(存在的)文件
File file2 = new File("d:/abc/123.txt");
System.out.println(file2.isFile()); //要求: 1. 必须是文件. 2. 必须是存在的文件. 才会返回true,其他都返回false
System.out.println("-------------------");
//需求3: public boolean isDirectory() 测试此抽象路径名表示的File是否为(存在的)目录
File file3 = new File("d:/abc");
System.out.println(file3.isDirectory()); //要求: 1. 必须是文件夹. 2. 必须是存在的文件夹. 才会返回true,其他都返回false
}
}
package com.it.demo04_file;
import java.io.File;
/*
案例: 演示File类的获取功能.
涉及到的File类的成员方法:
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
public String getPath() 将此抽象路径名转换为路径名字符串
public String getName() 返回由此抽象路径名表示的文件或目录的名称
public String[] list() 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组
绝对路径和相对路径的区别:
绝对路径: 固定的, 写"死"的路径, 即: 以盘符开头的路径.
例如: c:/abc/1.txt
相对路径: 指的是相对于某个路径来讲的, 默认的相对路径都是: 当前项目的路径.
例如: 1.txt, 其实他是当前项目下的1.txt, 即: 当前项目路径/1.txt
*/
public class Demo04 {
public static void main(String[] args) {
//测试: public String getAbsolutePath() 获取绝对路径.
File file1 = new File("d:/abc/123.txt"); //文件不存在也不会报错.
File file2 = new File("123.txt");
System.out.println(file1.getAbsolutePath());
System.out.println(file2.getAbsolutePath());
System.out.println("------------------------------");
//测试: public String getPath() 创建文件的时候用什么路径, 就获取什么路径, 一般是获取相对路径的.
System.out.println(file1.getPath());
System.out.println(file2.getPath());
System.out.println("------------------------------");
//测试: public String getName() 获取文件(夹)的名字
System.out.println(file1.getName());
System.out.println("------------------------------");
//测试: public String[] list() 获取指定目录下的文件(夹)的 名称字符串数组, 大白话翻译: 获取的是子文件(夹)的名字.
File file3 = new File("D:\\Compile\\abc");
String[] listNames = file3.list();
for (String listName : listNames) {
//listName: 就是file3目录下 每个文件(夹)的名字.
System.out.println(listName);
}
System.out.println("------------------------------");
//测试: public File[] listFiles() 获取指定目录下的文件(夹)的 File对象数组, 大白话翻译: 获取的是子文件(夹)的File对象形式.
File[] listFiles = file3.listFiles();
for (File listFile : listFiles) {
System.out.println(listFile);
}
}
}
package com.it.demo04_file;
import java.io.File;
/*
案例: 演示File类的删除功能
涉及到的File类的成员方法:
public boolean delete() 删除由此抽象路径名表示的文件或目录
细节:
1. Java中的删除不走回收站, 而是直接删除的.
2. 要删除的文件夹必须为空文件夹, 如果是文件, 则可以直接删除.
*/
public class Demo05 {
public static void main(String[] args) {
//需求1: 删除 d:/abc/1.txt
File file1 = new File("d:/abc/1.txt");
System.out.println(file1.delete());
System.out.println("-------------------");
//需求2: 删除 d:/abc文件夹
File file2 = new File("d:/abc");
System.out.println(file2.delete());
}
}
package cn.it.demo;
import java.io.File;
/*
* java.io.File
* 将操作系统中的,文件,目录(文件夹),路径,封装成File对象
* 提供方法,操作系统中的内容
* File与系统无关的类
* 文件 file
* 目录 directory
* 路径 path
*/
public class FileDemo {
public static void main(String[] args) {
//File类静态成员变量
//与系统有关的路径分隔符
String separator = File.pathSeparator;
System.out.println(separator);// 是一个分号,目录的分割 Linux :
//与系统有关的默认名称分隔符
separator = File.separator;
System.out.println(separator);// 向右 \ 目录名称分割 Linux /
}
}
package cn.it.demo;
import java.io.File;
/*
* File类的构造方法
* 三种重载形式
*/
public class FileDemo1 {
public static void main(String[] args) {
function_2();
}
/*
* File(File parent,String child)
* 传递路径,传递File类型父路径,字符串子路径
* 好处: 父路径是File类型,父路径可以直接调用File类方法
*/
public static void function_2(){
File parent = new File("d:");
File file = new File(parent,"eclipse");
System.out.println(file);
}
/*
* File(String parent,String child)
* 传递路径,传递字符串父路径,字符串子路径
* 好处: 单独操作父路径和子路径
*/
public static void function_1(){
File file = new File("d:","eclipse");
System.out.println(file);
}
/*
* File(String pathname)
* 传递路径名: 可以写到文件夹,可以写到一个文件
* c:\\abc c:\\abc\\Demo.java
* 将路径封装File类型对象
*/
public static void function(){
File file = new File("d:\\eclipse");
System.out.println(file);
}
}
package cn.it.demo;
import java.io.File;
import java.io.IOException;
/*
* File类的创建和删除功能
* 文件或者是目录
*/
public class FileDemo2 {
public static void main(String[] args)throws IOException {
function_2();
}
/*
* File类的删除功能
* boolean delete()
* 删除的文件或者是文件夹,在File构造方法中给出
* 删除成功返回true,删除失败返回false
* 删除方法,不走回收站,直接从硬盘中删除
* 删除有风险,运行需谨慎
*/
public static void function_2(){
File file = new File("c:\\a.txt");
boolean b = file.delete();
System.out.println(b);
}
/*
* File创建文件夹功能
* boolean mkdirs() 创建多层文件夹
* 创建的路径也在File构造方法中给出
* 文件夹已经存在了,不在创建
*/
public static void function_1(){
File file = new File("c:\\abc");
boolean b = file.mkdirs();
System.out.println(b);
}
/*
* File创建文件的功能
* boolean createNewFile()
* 创建的文件路径和文件名,在File构造方法中给出
* 文件已经存在了,不在创建
*/
public static void function()throws IOException{
File file = new File("c:\\a.txt");
boolean b = file.createNewFile();
System.out.println(b);
}
}
package cn.it.demo;
import java.io.File;
/*
* File类的获取功能
*/
public class FileDemo3 {
public static void main(String[] args) {
function_3();
}
/*
* File类的获取功能
* String getParent() 返回String对象
* File getParentFile()返回File对象
* 获取父路径
*/
public static void function_3(){
File file = new File("d:\\eclipse\\eclipse.exe");
File parent = file.getParentFile();
System.out.println(parent);
}
/*
* File类获取功能
* String getAbsolutePath() 返回String对象
* File getAbsoluteFile() 返回File对象
* 获取绝对路径
* eclipse环境中,写的是一个相对路径,绝对位置工程根目录
*/
public static void function_2(){
File file = new File("src");
File absolute = file.getAbsoluteFile();
System.out.println(absolute);
}
/*
* File类获取功能
* long length()
* 返回路径中表示的文件的字节数
*/
public static void function_1(){
File file = new File("d:\\eclipse\\eclipse.exe");
long length = file.length();
System.out.println(length);
}
/*
* File类的获取功能
* String getName()
* 返回路径中表示的文件或者文件夹名
* 获取路径中的最后部分的名字
*/
public static void function(){
File file = new File("d:\\eclipse\\eclipse.exe");
String name = file.getName();
System.out.println(name);
/*String path = file.getPath();
System.out.println(path);*/
// System.out.println(file);
}
}
package cn.it.demo;
import java.io.File;
/*
* File类的判断功能
*/
public class FileDemo4 {
public static void main(String[] args) {
function_1();
}
/*
* File判断功能
* boolean isDirectory()
* 判断File构造方法中封装的路径是不是文件夹
* 如果是文件夹,返回true,不是文件返回false
*
* boolean isFile()
* 判断File构造方法中封装的路径是不是文件
*/
public static void function_1(){
File file = new File("d:\\eclipse\\eclipse.exe");
if(file.exists()){
boolean b = file.isDirectory();
System.out.println(b);
}
}
/*
* File判断功能
* boolean exists()
* 判断File构造方法中封装路径是否存在
* 存在返回true,不存在返回false
*/
public static void function(){
File file = new File("src");
boolean b = file.exists();
System.out.println(b);
}
}
package cn.it.demo1;
import java.io.File;
/*
* File类获取功能
* list
* listFiles
*/
public class FileDemo {
public static void main(String[] args) {
function_2();
}
public static void function_2(){
//获取系统中的所有根目录
File[] fileArr = File.listRoots();
for(File f : fileArr){
System.out.println(f);
}
}
/*
* File类的获取功能
* File[] listFiles()
* 获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
* 返回的是目录或者文件的全路径
*/
public static void function_1(){
File file = new File("d:\\eclipse");
File[] fileArr = file.listFiles();
for(File f : fileArr){
System.out.println(f);
}
}
/*
* File类的获取功能
* String[] list()
* 获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
* 返回只有名字
*/
public static void function(){
File file = new File("c:");
String[] strArr = file.list();
System.out.println(strArr.length);
for(String str : strArr){
System.out.println(str);
}
}
}
package cn.it.demo1;
import java.io.File;
/*
* File类的获取,文件获取过滤器
* 遍历目录的时候,可以根据需要,只获取满足条件的文件
* 遍历目录方法 listFiles()重载形式
* listFiles(FileFilter filter)接口类型
* 传递FileFilter接口的实现类
* 自定义FileFilter接口实现类,重写抽象方法,
* 接口实现类对象传递到遍历方法listFiles
*/
public class FileDemo1 {
public static void main(String[] args) {
File file = new File("c:\\demo");
File[] fileArr = file.listFiles(new MyFilter());
for(File f : fileArr){
System.out.println(f);
}
}
}
package cn.it.demo1;
import java.io.File;
import java.io.FileFilter;
/*
* 自定义过滤器
* 实现FileFilter接口,重写抽象方法
*/
public class MyFilter implements FileFilter{
public boolean accept(File pathname) {
/*
* pathname 接受到的也是文件的全路径
* c:\\demo\\1.txt
* 对路径进行判断,如果是java文件,返回true,不是java文件,返回false
* 文件的后缀结尾是.java
*/
//String name = pathname.getName();
return pathname.getName().endsWith(".java");
}
}
package cn.it.demo2;
/*
* 方法的递归调用
* 方法自己调用自己
* 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
* 注意:
* 递归一定要有出口, 必须可以让程序停下
* 递归次数不能过多
* 构造方法,禁止递归
*/
public class DiGuiDemo {
public static void main(String[] args) {
/*int sum = getSum(3);
System.out.println(sum);*/
System.out.println(getJieCheng(5));
System.out.println(getFBNQ(12));
}
/*
* 方法递归,计算斐波那契数列
*
*/
public static int getFBNQ(int month){
if( month == 1)
return 1;
if( month == 2)
return 1;
return getFBNQ(month-1)+getFBNQ(month-2);
}
/*
* 计算阶乘 5!
* 5*4*3*2*1
*/
public static int getJieCheng(int n){
if ( n == 1)
return 1;
return n * getJieCheng(n-1);
}
/*
* 计算 1+2+3+100和 = 5050
* 计算规律:
* n+(n-1)+(n-2)
* 100+(100-1)+(99-1)+...1
*/
public static int getSum(int n){
if( n == 1)
return 1;
return n + getSum(n-1);
}
}
package cn.it.demo2;
import java.io.File;
/*
* 对一个目录的下的所有内容,进行完全的遍历
* 编程技巧,方法的递归调用,自己调用自己
*/
public class FileDemo {
public static void main(String[] args) {
File dir = new File("d:\\eclipse");
getAllDir(dir);
}
/*
* 定义方法,实现目录的全遍历
*/
public static void getAllDir(File dir){
System.out.println(dir);
//调用方法listFiles()对目录,dir进行遍历
File[] fileArr = dir.listFiles();
for(File f : fileArr){
//判断变量f表示的路径是不是文件夹
if(f.isDirectory()){
//是一个目录,就要去遍历这个目录
//本方法,getAllDir,就是给个目录去遍历
//继续调用getAllDir,传递他目录
getAllDir(f);
}else{
System.out.println(f);
}
}
}
}
package cn.it.demo2;
import java.io.File;
/*
* 遍历目录,获取目录下的所有.java文件
* 遍历多级目录,方法递归实现
* 遍历的过程中,使用过滤器
*/
public class FileDemo1 {
public static void main(String[] args) {
getAllJava(new File("c:\\demo"));
// new File("c:\\demo").delete();
}
/*
* 定义方法,实现遍历指定目录
* 获取目录中所有的.java文件
*/
public static void getAllJava(File dir){
//调用File对象方法listFiles()获取,加入过滤器
File[] fileArr = dir.listFiles(new MyJavaFilter());
for(File f : fileArr){
//对f路径,判断是不是文件夹
if(f.isDirectory()){
//递归进入文件夹遍历
getAllJava(f);
}else{
System.out.println(f);
}
}
}
}
package cn.it.demo2;
import java.io.File;
import java.io.FileFilter;
public class MyJavaFilter implements FileFilter {
public boolean accept(File pathname) {
//判断获取的是目录,直接返回true
if(pathname.isDirectory())
return true;
return pathname.getName().toLowerCase().endsWith(".java");
}
}
package cn.it.copy;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 字节流复制文件
* 采用数组缓冲提高效率
* 字节数组
* FileInputStream 读取字节数组
* FileOutputStream 写字节数组
*/
public class Copy_1 {
public static void main(String[] args) {
long s = System.currentTimeMillis();
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("c:\\t.zip");
fos = new FileOutputStream("d:\\t.zip");
//定义字节数组,缓冲
byte[] bytes = new byte[1024*10];
//读取数组,写入数组
int len = 0 ;
while((len = fis.read(bytes))!=-1){
fos.write(bytes, 0, len);
}
}catch(IOException ex){
System.out.println(ex);
throw new RuntimeException("文件复制失败");
}finally{
try{
if(fos!=null)
fos.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fis!=null)
fis.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}
}
}
long e = System.currentTimeMillis();
System.out.println(e-s);
}
}
package cn.it.copy;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
* 字符流复制文本文件,必须文本文件
* 字符流查询本机默认的编码表,简体中文GBK
* FileReader读取数据源
* FileWriter写入到数据目的
*/
public class Copy_2 {
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("c:\\1.txt");
fw = new FileWriter("d:\\1.txt");
char[] cbuf = new char[1024];
int len = 0 ;
while(( len = fr.read(cbuf))!=-1){
fw.write(cbuf, 0, len);
fw.flush();
}
}catch(IOException ex){
System.out.println(ex);
throw new RuntimeException("复制失败");
}finally{
try{
if(fw!=null)
fw.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fr!=null)
fr.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}
}
}
}
}
package cn.it.copy;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 将数据源 c:\\a.txt
* 复制到 d:\\a.txt 数据目的
* 字节输入流,绑定数据源
* 字节输出流,绑定数据目的
*
* 输入,读取1个字节
* 输出,写1个字节
*/
public class Copy {
public static void main(String[] args) {
//定义两个流的对象变量
FileInputStream fis = null;
FileOutputStream fos = null;
try{
//建立两个流的对象,绑定数据源和数据目的
fis = new FileInputStream("c:\\t.zip");
fos = new FileOutputStream("d:\\t.zip");
//字节输入流,读取1个字节,输出流写1个字节
int len = 0 ;
while((len = fis.read())!=-1){
fos.write(len);
}
}catch(IOException ex){
System.out.println(ex);
throw new RuntimeException("文件复制失败");
}finally{
try{
if(fos!=null)
fos.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fis!=null)
fis.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}
}
}
}
}
package com.it.demo05_outputstream;
/*
案例: IO流简介, 本类中只有文字, 没有代码.
IO流简介:
概述:
IO流也叫输入(Input)/输出(Output)流, 它是用来进行文件传输, 拷贝文件等工作的.
应用场景:
文件上传
文件下载
文件拷贝
分类:
按照流向分:
输入流: 读取数据的.
输出流: 写数据的.
按照操作分:
字节流: 以字节为单位来操作数据, 也叫"万能流", 因为它能操作任意类型的数据.
字节输入流: 以字节为单位 读取 数据, 顶层抽象类是: InputStream
常用的子类如下:
普通的字节输入流: FileInputStream
高效的字节输入流: BufferedInputStream
字节输出流: 以字节为单位 写 数据, 顶层抽象类是: OutputStream
常用的子类如下:
普通的字节输出流: FileOutputStream
高效的字节输出流: BufferedOutputStream
字符流; 以字符为单位来操作数据, 只能操作纯文本文件.
字符输入流: 以字符为单位 读取 数据, 顶层抽象类是: Reader
常用的子类如下:
普通的字符输入流: FileReader
高效的字符输入流: BufferedReader
字符输出流: 以字符为单位 写 数据, 顶层抽象类是: Writer
常用的子类如下:
普通的字符输出流: FileWriter
高效的字符输出流: BufferedWriter
关于字节流和字符流的选择问题:
当一个文件能用微软自带的记事本打开, 并且里边的内容你也能看懂的时候, 就可以考虑使用字符流了,
否则使用字节流.
*/
public class Demo01 {
public static void main(String[] args) {
}
}
package com.it.demo05_outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 字节输出流入门.
需求:
1.创建FileOutputStream对象, 关联指定的目的地文件.
2.往文件中写入字符'a', 'b', 'c'.
普通的字节输出流简介:
概述:
普通的字节输出流指的是FileOutputStream, 它是以 字节 为单位往文件中 写数据的.
构造方法:
public FileOutputStream(String pathName); 创建字节输出流对象, 关联目的地文件(字符串形式), 会覆盖文件中的内容.
public FileOutputStream(File pathName); 创建字节输出流对象, 关联目的地文件(File对象形式), 会覆盖文件中的内容.
public FileOutputStream(String pathName, boolean append); 创建字节输出流对象, 关联目的地文件(字符串形式), 第二个参数值如果为true, 表示往文件中追加数据.
public FileOutputStream(File pathName, boolean append); 创建字节输出流对象, 关联目的地文件(File对象形式), 第二个参数值如果为true, 表示往文件中追加数据.
成员方法:
public void write(int ch); 一次写一个字节
public void write(byte[] bys); 一次写一个字节数组
public void write(byte[] bys, int start, int len); 一次写一个字节数组的一部分.
public void close(); 关闭流对象, 释放资源.
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
//1. 创建输出流, 关联目的地文件.
/*
细节:
1. 目的地文件不存在, 程序会自动创建.
2. 目的地文件的父目录必须存在.
*/
FileOutputStream fos = new FileOutputStream("day11/data/1.txt");
//2. 往文件中写数据.
//方式一: 一次写一个字节
fos.write(97);
fos.write(98);
fos.write(99);
//3. 关流, 释放资源.
fos.close();
}
}
package com.it.demo05_outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 字节输出流写数据的三种方式.
需求:
1.创建FileOutputStream对象, 关联指定的目的地文件.
2.往文件中写入字符'a', 'b', 'c'.
普通的字节输出流简介:
概述:
普通的字节输出流指的是FileOutputStream, 它是以 字节 为单位往文件中 写数据的.
构造方法:
public FileOutputStream(String pathName); 创建字节输出流对象, 关联目的地文件(字符串形式), 会覆盖文件中的内容.
public FileOutputStream(File pathName); 创建字节输出流对象, 关联目的地文件(File对象形式), 会覆盖文件中的内容.
public FileOutputStream(String pathName, boolean append); 创建字节输出流对象, 关联目的地文件(字符串形式), 第二个参数值如果为true, 表示往文件中追加数据.
public FileOutputStream(File pathName, boolean append); 创建字节输出流对象, 关联目的地文件(File对象形式), 第二个参数值如果为true, 表示往文件中追加数据.
成员方法:
public void write(int ch); 一次写一个字节
public void write(byte[] bys); 一次写一个字节数组
public void write(byte[] bys, int start, int len); 一次写一个字节数组的一部分.
public void close(); 关闭流对象, 释放资源.
*/
public class Demo03 {
public static void main(String[] args) throws IOException {
//1. 创建输出流, 关联目的地文件.
/*
细节:
1. 目的地文件不存在, 程序会自动创建.
2. 目的地文件的父目录必须存在.
*/
FileOutputStream fos = new FileOutputStream("day11/data/1.txt");
//2. 往文件中写数据.
//方式一: 一次写一个字节
/*fos.write(97);
fos.write(98);
fos.write(99);*/
//方式二: 一次一个字节数组
/*byte[] bys = {65, 66, 67, 68, 69}; //ABCDE
fos.write(bys);*/
//方式三: 一次一个字节数组的一部分 //CD
byte[] bys = {65, 66, 67, 68, 69};
fos.write(bys, 2, 2);
//3. 关流, 释放资源.
fos.close();
}
}
package com.it.demo05_outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示关于IO流的两个小问题
问题1: 如何换行?
写入 \r\n 即可
问题2: 如何追加数据?
创建输出流的时候, 第二个参数传入 true 即可.
true: 追加. false: 不追加.
需求:
1.创建FileOutputStream对象, 关联指定的目的地文件.
2.往文件中写入10次hello, 每个hello占一行.
3.往文件中追加一句话: 键盘敲烂, 月薪过万!
*/
public class Demo04 {
public static void main(String[] args) throws IOException {
//1. 创建输出流, 关联目的地文件.
//FileOutputStream fos = new FileOutputStream("day11/data/1.txt"); //默认是覆盖
FileOutputStream fos = new FileOutputStream("day11/data/1.txt", true); //true: 表示追加
//2. 往文件中写入10次hello, 每个hello占一行.
//String#getBytes()方法的作用: 把字符串转成其对应的 字节数组形式.
/*for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
//加入换行
fos.write("\r\n".getBytes());
}*/
//3. 往文件中追加一句话: 键盘敲烂, 月薪过万!
fos.write("键盘敲烂, 月薪过万!".getBytes());
//4. 关流, 释放资源.
fos.close();
}
}
package com.it.demo05_outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
//这个是做空文件的, 明天上课还会在详细讲一遍.
public class Demo05 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\Compile\\王兴平(蓝光高清无码).avi");
byte[] bys = new byte[1024]; //1KB = 1023byte
for (int i = 0; i < 1024 * 1024; i++) {
fos.write(bys);
}
fos.close();
}
}
package cn.it.demo;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* FileOutputStream
* 写入数据文件,学习父类方法,使用子类对象
*
* 子类中的构造方法: 作用:绑定输出的输出目的
* 参数:
* File 封装文件
* String 字符串的文件名
*
* 流对象使用步骤
* 1. 创建流子类的对象,绑定数据目的
* 2. 调用流对象的方法write写
* 3. close释放资源
*
* 流对象的构造方法,可以创建文件,如果文件存在,直接覆盖
*/
public class FileOutputStreamDemo {
public static void main(String[] args)throws IOException {
FileOutputStream fos = new FileOutputStream("c:\\a.txt");
//流对象的方法write写数据
//写1个字节
fos.write(97);
//写字节数组
byte[] bytes = {65,66,67,68};
fos.write(bytes);
//写字节数组的一部分,开始索引,写几个
fos.write(bytes, 1, 2);
//写入字节数组的简便方式
//写字符串
fos.write("hello".getBytes());
//关闭资源
fos.close();
}
}
package cn.it.demo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* FileOutputStream 文件的续写和换行问题
* 续写: FileOutputStream构造方法, 的第二个参数中,加入true
* 在文件中,写入换行,符号换行 \r\n
* \r\n 可以写在上一行的末尾, 也可以写在下一行的开头
*/
public class FileOutputStreamDemo1 {
public static void main(String[] args)throws IOException {
File file = new File("c:\\b.txt");
FileOutputStream fos = new FileOutputStream(file,true);
fos.write("hello\r\n".getBytes());
fos.write("world".getBytes());
fos.close();
}
}
package cn.it.demo;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* IO流的异常处理
* try catch finally
*
* 细节:
* 1. 保证流对象变量,作用域足够
* 2. catch里面,怎么处理异常
* 输出异常的信息,目的看到哪里出现了问题
* 停下程序,从新尝试
* 3. 如果流对象建立失败了,需要关闭资源吗
* new 对象的时候,失败了,没有占用系统资源
* 释放资源的时候,对流对象判断null
* 变量不是null,对象建立成功,需要关闭资源
*/
public class FileOutputStreamDemo3 {
public static void main(String[] args) {
//try 外面声明变量,try 里面建立对象
FileOutputStream fos = null;
try{
fos = new FileOutputStream("s:\\a.txt");
fos.write(100);
}catch(IOException ex){
System.out.println(ex);
throw new RuntimeException("文件写入失败,重试");
}finally{
try{
if(fos!=null)
fos.close();
}catch(IOException ex){
throw new RuntimeException("关闭资源失败");
}
}
}
}
package cn.it.demo;
/*
* 字节输出流
* java.io.OutputStream 所有字节输出流的超类
* 作用: 从Java程序,写出文件
* 字节: 这样流每次只操作文件中的1个字节
* 写任意文件
*
* 方法都是写文入的方法
* write(int b) 写入1个字节
* write(byte[] b) 写入字节数组
* write(byte[] b,int,int)写入字节数组,int 开始写入的索引, int 写几个
* close() 方法,关闭流对象,释放与次流相关的资源
*
* 流对象,操作文件的时候, 自己不做,依赖操作系统
*/
public class OutputStreamDemo {
}
package cn.it.demo1;
import java.io.FileInputStream;
import java.io.IOException;
/*
* FileInputStream读取文件
*
* 构造方法: 为这个流对象绑定数据源
*
* 参数:
* File 类型对象
* String 对象
* 输入流读取文件的步骤
* 1. 创建字节输入流的子类对象
* 2. 调用读取方法read读取
* 3. 关闭资源
*
* read()方法,
* read()执行一次,就会自动读取下一个字节
* 返回值,返回的是读取到的字节, 读取到结尾返回-1
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("c:\\a.txt");
//读取一个字节,调用方法read 返回int
//使用循环方式,读取文件, 循环结束的条件 read()方法返回-1
int len = 0;//接受read方法的返回值
while( (len = fis.read()) != -1){
System.out.print((char)len);
}
//关闭资源
fis.close();
}
}
/*
* int i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
*/
package cn.it.demo1;
import java.io.FileInputStream;
import java.io.IOException;
/*
* FileInputStream读取文件
* 读取方法 int read(byte[] b) 读取字节数组
* 数组作用: 缓冲的作用, 提高效率
* read返回的int,表示什么含义 读取到多少个有效的字节数
*/
public class FileInputStreamDemo1 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("c:\\a.txt");
//创建字节数组
byte[] b = new byte[1024];
int len = 0 ;
while( (len = fis.read(b)) !=-1){
System.out.print(new String(b,0,len));
}
fis.close();
}
}
/*
*
int len = fis.read(b);
System.out.println(new String(b));//ab
System.out.println(len);//2
len = fis.read(b);
System.out.println(new String(b));//cd
System.out.println(len);//2
len = fis.read(b);
System.out.println(new String(b));//ed
System.out.println(len);//1
len = fis.read(b);
System.out.println(new String(b));//ed
System.out.println(len);//-1
*/
package cn.it.demo1;
/*
* 字节输入流
* java.io.InputStream 所有字节输入流的超类
* 作用: 读取任意文件,每次只读取1个字节
* 读取的方法 read
* int read() 读取1个字节
* int read(byte[] b) 读取一定量的字节,存储到数组中
*/
public class InputStreamDemo {
}
package cn.it.demo2;
import java.io.FileReader;
import java.io.IOException;
/*
* 字符输入流读取文本文件,所有字符输入流的超类
* java.io.Reader
* 专门读取文本文件
*
* 读取的方法 : read()
* int read() 读取1个字符
* int read(char[] c) 读取字符数组
*
* Reader类是抽象类,找到子类对象 FileReader
*
* 构造方法: 绑定数据源
* 参数:
* File 类型对象
* String文件名
*/
public class ReaderDemo {
public static void main(String[] args) throws IOException{
FileReader fr = new FileReader("c:\\1.txt");
/*int len = 0 ;
while((len = fr.read())!=-1){
System.out.print((char)len);
}*/
char[] ch = new char[1024];
int len = 0 ;
while((len = fr.read(ch))!=-1){
System.out.print(new String(ch,0,len));
}
fr.close();
}
}
package cn.it.demo2;
import java.io.FileWriter;
import java.io.IOException;
/*
* 字符输出流
* java.io.Writer 所有字符输出流的超类
* 写文件,写文本文件
*
* 写的方法 write
* write(int c) 写1个字符
* write(char[] c)写字符数组
* write(char[] c,int,int)字符数组一部分,开始索引,写几个
* write(String s) 写入字符串
*
* Writer类的子类对象 FileWriter
*
* 构造方法: 写入的数据目的
* File 类型对象
* String 文件名
*
* 字符输出流写数据的时候,必须要运行一个功能,刷新功能
* flush()
*/
public class WriterDemo {
public static void main(String[] args) throws IOException{
FileWriter fw = new FileWriter("c:\\1.txt");
//写1个字符
fw.write(100);
fw.flush();
//写1个字符数组
char[] c = {'a','b','c','d','e'};
fw.write(c);
fw.flush();
//写字符数组一部分
fw.write(c, 2, 2);
fw.flush();
//写如字符串
fw.write("hello");
fw.flush();
fw.close();
}
}
package cn.it.copy;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
* 使用缓冲区流对象,复制文本文件
* 数据源 BufferedReader+FileReader 读取
* 数据目的 BufferedWriter+FileWriter 写入
* 读取文本行, 读一行,写一行,写换行
*/
public class Copy_1 {
public static void main(String[] args) throws IOException{
BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));
BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
//读取文本行, 读一行,写一行,写换行
String line = null;
while((line = bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
bfw.close();
bfr.close();
}
}
package cn.it.copy;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 文件复制方式,字节流,一共4个方式
* 1. 字节流读写单个字节 125250 毫秒
* 2. 字节流读写字节数组 193 毫秒 OK
* 3. 字节流缓冲区流读写单个字节 1210 毫秒
* 4. 字节流缓冲区流读写字节数组 73 毫秒 OK
*/
public class Copy {
public static void main(String[] args)throws IOException {
long s = System.currentTimeMillis();
copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
long e = System.currentTimeMillis();
System.out.println(e-s);
}
/*
* 方法,实现文件复制
* 4. 字节流缓冲区流读写字节数组
*/
public static void copy_4(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.close();
bis.close();
}
/*
* 方法,实现文件复制
* 3. 字节流缓冲区流读写单个字节
*/
public static void copy_3(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
while((len = bis.read())!=-1){
bos.write(len);
}
bos.close();
bis.close();
}
/*
* 方法,实现文件复制
* 2. 字节流读写字节数组
*/
public static void copy_2(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = fis.read(bytes))!=-1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}
/*
* 方法,实现文件复制
* 1. 字节流读写单个字节
*/
public static void copy_1(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
while((len = fis.read())!=-1){
fos.write(len);
}
fos.close();
fis.close();
}
}
package cn.it.demo;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 转换流
* java.io.InputStreamReader 继承 Reader
* 字符输入流，读取文本文件
*
* 字节流向字符的敲了，将字节流转字符流
*
* 读取的方法:
* read() 读取1个字符，读取字符数组
*
* 技巧： OuputStreamWriter写了文件
* InputStreamReader读取文件
*
* OuputStreamWriter(OuputStream out)所有字节输出流
* InputStreamReader(InputStream in) 接收所有的字节输入流
* 可以传递的字节输入流： FileInputStream
* InputStreamReader(InputStream in,String charsetName) 传递编码表的名字
*/
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// readGBK();
readUTF();
}
/*
* 转换流,InputSteamReader读取文本
* 采用UTF-8编码表,读取文件utf
*/
public static void readUTF()throws IOException{
//创建自己输入流,传递文本文件
FileInputStream fis = new FileInputStream("c:\\utf.txt");
//创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
char[] ch = new char[1024];
int len = isr.read(ch);
System.out.println(new String(ch,0,len));
isr.close();
}
/*
* 转换流,InputSteamReader读取文本
* 采用系统默认编码表,读取GBK文件
*/
public static void readGBK()throws IOException{
//创建自己输入流,传递文本文件
FileInputStream fis = new FileInputStream("c:\\gbk.txt");
//创建转换流对象,构造方法,包装字节输入流
InputStreamReader isr = new InputStreamReader(fis);
char[] ch = new char[1024];
int len = isr.read(ch);
System.out.println(new String(ch,0,len));
isr.close();
}
}
package cn.it.demo;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
* 转换流
* java.io.OutputStreamWriter 继承Writer类
* 就是一个字符输出流，写文本文件
* write()字符，字符数组，字符串
*
* 字符通向字节的桥梁，将字符流转字节流
*
* OutputStreamWriter 使用方式
* 构造方法：
* OutputStreamWriter(OuputStream out)接收所有的字节输出流
* 但是： 字节输出流： FileOutputStream
*
* OutputStreamWriter(OutputStream out, String charsetName)
* String charsetName 传递编码表名字 GBK UTF-8
*
* OutputStreamWriter 有个子类， FileWriter
*/
public class OutputStreamWriterDemo {
public static void main(String[] args)throws IOException {
// writeGBK();
writeUTF();
}
/*
* 转换流对象OutputStreamWriter写文本
* 采用UTF-8编码表写入
*/
public static void writeUTF()throws IOException{
//创建字节输出流，绑定文件
FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
//创建转换流对象，构造方法保证字节输出流，并指定编码表是UTF-8
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
osw.write("你好");
osw.close();
}
/*
* 转换流对象 OutputStreamWriter写文本
* 文本采用GBK的形式写入
*/
public static void writeGBK()throws IOException{
//创建字节输出流，绑定数据文件
FileOutputStream fos = new FileOutputStream("c:\\gbk.txt");
//创建转换流对象，构造方法，绑定字节输出流，使用GBK编码表
OutputStreamWriter osw = new OutputStreamWriter(fos);
//转换流写数据
osw.write("你好");
osw.close();
}
}
package cn.it.demo1;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 字节输入流的缓冲流
* java.io.BufferedInputStream
* 继承InputStream,标准的字节输入流
* 读取方法 read() 单个字节,字节数组
*
* 构造方法:
* BufferedInputStream(InputStream in)
* 可以传递任意的字节输入流,传递是谁,就提高谁的效率
* 可以传递的字节输入流 FileInputStream
*/
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException{
//创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
byte[] bytes = new byte[10];
int len = 0 ;
while((len = bis.read(bytes))!=-1){
System.out.print(new String(bytes,0,len));
}
bis.close();
}
}
package cn.it.demo1;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 字节输出流的缓冲流
* java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率
* BufferedOuputStream 继承 OutputStream
* 方法,写入 write 字节,字节数组
*
* 构造方法:
* BufferedOuputStream(OuputStream out)
* 可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率
*
* FileOutputSteam
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args)throws IOException {
//创建字节输出流,绑定文件
//FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");
//创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
BufferedOutputStream bos = new
BufferedOutputStream(new FileOutputStream("c:\\buffer.txt"));
bos.write(55);
byte[] bytes = "HelloWorld".getBytes();
bos.write(bytes);
bos.write(bytes, 3, 2);
bos.close();
}
}
package cn.it.demo2;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
* 字符输入流缓冲流
* java.io.BufferedReader 继承 Reader
* 读取功能 read() 单个字符,字符数组
* 构造方法:
* BufferedReader(Reader r)
* 可以任意的字符输入流
* FileReader InputStreamReader
*
* BufferedReader自己的功能
* String readLine() 读取文本行 \r\n
*
* 方法读取到流末尾,返回null
* 小特点:
* 获取内容的方法一般都有返回值
* int 没有返回的都是负数
* 引用类型 找不到返回null
* boolean 找不到返回false
*
* String s = null
* String s ="null"
*
* readLine()方法返回行的有效字符,没有\r\n
*/
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
int lineNumber = 0;
//创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
//调用缓冲流的方法 readLine()读取文本行
//循环读取文本行, 结束条件 readLine()返回null
String line = null;
while((line = bfr.readLine())!=null){
lineNumber++;
System.out.println(lineNumber+" "+line);
}
bfr.close();
}
}
/*
* String line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
*/
package cn.it.demo2;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/*
* 字符输出流缓冲区流
* java.io.BufferedWriter 继承 Writer
* 写入方法 write () 单个字符,字符数组,字符串
*
* 构造方法:
* BufferedWriter(Writer w)传递任意字符输出流
* 传递谁,就高效谁
* 能传递的字符输出流 FileWriter, OutputStreamWriter
*
* BufferedWriter 具有自己特有的方法
* void newLine() 写换行
*
* newLine()文本中换行, \r\n也是文本换行
* 方法具有平台无关性
* Windows \r\n
* Linux \n
*
* newLine()运行结果,和操作系统是相互关系
* JVM: 安装的是Windows版本,newLine()写的就是\r\n
* 安装的是Linux版本,newLine()写的就是\n
*/
public class BufferedWrierDemo {
public static void main(String[] args) throws IOException{
//创建字符输出流,封装文件
FileWriter fw = new FileWriter("c:\\buffer.txt");
BufferedWriter bfw = new BufferedWriter(fw);
bfw.write("你好");
bfw.newLine();
bfw.flush();
bfw.write("我好好");
bfw.newLine();
bfw.flush();
bfw.write("大家都好");
bfw.flush();
bfw.close();
}
}
/*
*
bfw.write(100);
bfw.flush();
bfw.write("你好".toCharArray());
bfw.flush();*/
package cn.it.demo;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/*
* 集合对象Properties类,继承Hashtable,实现Map接口
* 可以和IO对象结合使用,实现数据的持久存储
*/
public class PropertiesDemo {
public static void main(String[] args)throws IOException {
function_2();
}
/*
* Properties集合的特有方法store
* store(OutputStream out)
* store(Writer w)
* 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
*/
public static void function_2()throws IOException{
Properties pro = new Properties();
pro.setProperty("name", "zhangsan");
pro.setProperty("age", "31");
pro.setProperty("email", "123456789@163.com");
FileWriter fw = new FileWriter("c:\\pro.properties");
//键值对,存回文件,使用集合的方法store传递字符输出流
pro.store(fw, "");
fw.close();
}
/*
* Properties集合特有方法 load
* load(InputStream in)
* load(Reader r)
* 传递任意的字节或者字符输入流
* 流对象读取文件中的键值对,保存到集合
*/
public static void function_1()throws IOException{
Properties pro = new Properties();
FileReader fr = new FileReader("c:\\pro.properties");
//调用集合的方法load,传递字符输入流
pro.load(fr);
fr.close();
System.out.println(pro);
}
/*
* 使用Properties集合,存储键值对
* setProperty等同与Map接口中的put
* setProperty(String key, String value)
* 通过键获取值, getProperty(String key)
*/
public static void function(){
Properties pro = new Properties();
pro.setProperty("a", "1");
pro.setProperty("b", "2");
pro.setProperty("c", "3");
System.out.println(pro);
String value = pro.getProperty("c");
System.out.println(value);
//方法stringPropertyNames,将集合中的键存储到Set集合,类似于Map接口的方法keySet
Set<String> set = pro.stringPropertyNames();
for(String key : set){
System.out.println(key+"..."+pro.getProperty(key));
}
}
}
package cn.it.demo1;
import java.io.Serializable;
public class Person implements Serializable{
public String name;
public /*transient阻止成员变量序列化*/ int age;
//类,自定义了序列号,编译器不会计算序列号
private static final long serialVersionUID = 1478652478456L;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
package cn.it.demo1;
public class Demo {
public static void main(String[] args) {
Person p = new Person("a",22);
System.out.println(p);
}
}
package cn.it.demo1;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
* IO流对象,实现对象Person序列化,和反序列化
* ObjectOutputStream 写对象,实现序列化
* ObjectInputStream 读取对象,实现反序列化
*/
public class ObjectStreamDemo {
public static void main(String[] args)throws IOException, ClassNotFoundException {
// writeObject();
readObject();
}
/*
* ObjectInputStream
* 构造方法:ObjectInputStream(InputStream in)
* 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
* Object readObject() 读取对象
*/
public static void readObject() throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream("c:\\person.txt");
//创建反序列化流,构造方法中,传递字节输入流
ObjectInputStream ois = new ObjectInputStream(fis);
//调用反序列化流的方法 readObject()读取对象
Object obj =ois.readObject();
System.out.println(obj);
ois.close();
}
/*
* ObjectOutputStream
* 构造方法: ObjectOutputStream(OutputSteam out)
* 传递任意的字节输出流
* void writeObject(Object obj)写出对象的方法
*/
public static void writeObject() throws IOException{
//创建字节输出流,封装文件
FileOutputStream fos = new FileOutputStream("c:\\person.txt");
//创建写出对象的序列化流的对象,构造方法传递字节输出流
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person p = new Person("lisi",25);
//调用序列化流的方法writeObject,写出对象
oos.writeObject(p);
oos.close();
}
}
package cn.it.demo2;
/*
* String s = "abc";final char[] value
*/
public class Demo {
public static void main(String[] args) {
int[] arr = {1};
System.out.println(arr);
char[] ch = {'a','b'};
System.out.println(ch);
byte[] b = {};
System.out.println(b);
}
}
package cn.it.demo2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流
* PrintStream
* PrintWriter
* 打印流的特点:
* 1. 此流不负责数据源,只负责数据目的
* 2. 为其他输出流,添加功能
* 3. 永远不会抛出IOException
* 但是,可能抛出别的异常
*
* 两个打印流的方法,完全一致
* 构造方法,就是打印流的输出目的端
* PrintStream
* 构造方法,接收File类型,接收字符串文件名,接收字节输出流OutputStream
* PrintWriter
* 构造方法,接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer
*
*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
function_3();
}
/*
* 打印流,可以开启自动刷新功能
* 满足2个条件:
* 1. 输出的数据目的必须是流对象
* OutputStream Writer
* 2. 必须调用println,printf,format三个方法中的一个,启用自动刷新
*/
public static void function_3()throws IOException{
//File f = new File("XXX.txt");
FileOutputStream fos = new FileOutputStream("c:\\5.txt");
PrintWriter pw = new PrintWriter(fos,true);
pw.println("i");
pw.println("love");
pw.println("java");
pw.close();
}
/*
* 打印流,输出目的,是流对象
* 可以是字节输出流,可以是字符的输出流
* OutputStream Writer
*/
public static void function_2() throws IOException{
// FileOutputStream fos = new FileOutputStream("c:\\3.txt");
FileWriter fw = new FileWriter("c:\\4.txt");
PrintWriter pw = new PrintWriter(fw);
pw.println("打印流");
pw.close();
}
/*
* 打印流,输出目的,String文件名
*/
public static void function_1() throws FileNotFoundException{
PrintWriter pw = new PrintWriter("c:\\2.txt");
pw.println(3.5);
pw.close();
}
/*
* 打印流,向File对象的数据目的写入数据
* 方法print println 原样输出
* write方法走码表
*/
public static void function() throws FileNotFoundException{
File file = new File("c:\\1.txt");
PrintWriter pw = new PrintWriter(file);
pw.println(true);
pw.write(100);
pw.close();
}
}
package cn.it.demo2;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流实现文本复制
* 读取数据源 BufferedReader+File 读取文本行
* 写入数据目的 PrintWriter+println 自动刷新
*/
public class PrintWriterDemo1 {
public static void main(String[] args) throws IOException{
BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("d:\\a.txt"),true);
String line = null;
while((line = bfr.readLine())!=null){
pw.println(line);
}
pw.close();
bfr.close();
}
}
package cn.it.demo3;
import org.apache.commons.io.FilenameUtils;
public class Commons_IODemo {
public static void main(String[] args) {
function_2();
}
/*
* FilenameUtils类的方法
* static boolean isExtension(String filename,String extension)
* 判断文件名的后缀是不是extension
*/
public static void function_2(){
boolean b = FilenameUtils.isExtension("Demo.java", "java");
System.out.println(b);
}
/*
* FilenameUtils类的方法
* static String getName(String filename)
* 获取文件名
*/
public static void function_1(){
String name = FilenameUtils.getName("c:\\windows\\");
System.out.println(name);
}
/*
* FilenameUtils类的方法
* static String getExtension(String filename)
* 获取文件名的扩展名
*/
public static void function(){
String name = FilenameUtils.getExtension("c:\\windows");
System.out.println(name);
}
}
package cn.it.demo3;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
public class Commons_IODemo1 {
public static void main(String[] args)throws IOException {
function_3();
}
/*
* FileUtils工具类方法
* static void copyDirectoryToDirectory(File src,File desc)
* 复制文件夹
*/
public static void function_3() throws IOException{
FileUtils.copyDirectoryToDirectory(new File("d:\\demo"), new File("c:\\"));
}
/*
* FileUtils工具类的方法
* static void copyFile(File src,File desc)
* 复制文件
*/
public static void function_2() throws IOException{
FileUtils.copyFile(new File("c:\\k.jpg"),new File("d:\\k.jpg"));
}
/*
* FileUtils工具类的方法
* static void writeStringToFile(File src,String date)
* 将字符串直接写到文件中
*/
public static void function_1() throws IOException{
FileUtils.writeStringToFile(new File("c:\\b.txt"),"我爱Java编程");
}
/*
* FileUtils工具类的方法
* static String readFileToString(File src)读取文本,返回字符串
*/
public static void function() throws IOException{
String s = FileUtils.readFileToString(new File("c:\\a.txt"));
System.out.println(s);
}
}
package com.it.demo01_outputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示字节输出流写数据.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/1.txt");
//2. 写数据.
//一次一个字节
fos.write(97);
fos.write("\r\n".getBytes());
//一次一个字节数组
byte[] bys = {65, 66, 67};
fos.write(bys);
fos.write("\r\n".getBytes());
//一次一个字节数组 的一部分
fos.write(bys, 1, 1);;
//3. 释放资源.
fos.close();
}
}
package com.it.demo01_outputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示 try.catch 处理 IO流异常.
*/
public class Demo02 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//System.out.println(1 / 0);
//1. 创建输出流, 关联目的地文件.
fos = new FileOutputStream("day12/data/1.txt");
//2. 写数据, 一次一个字节数组
byte[] bys = {65, 66, 67};
fos.write(bys);
fos.write("\r\n".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
//3. 释放资源.
try {
if (fos != null) {
fos.close();
fos = null; //GC会优先回收null对象.
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.it.demo01_outputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 制作空文件.
需求:
在指定的路径下(例如: d:/abc)创建一个大小为1G的空文件.
*/
public class Demo03 {
public static void main(String[] args) throws IOException {
//1. 创建字节输出流对象, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("D:\\BaseClass\\程德与牟老师(蓝光高清无码).avi");
//2. 往文件中写数据.
//1KB = 1024B
byte[] bys = new byte[1024];
//fos.write(bys); //造出来的文件只有1KB
/*
1GB = 1024MB
1MB = 1024KB
1KB = 1024B
*/
for (int i = 0; i < 1024 * 1024; i++) {
fos.write(bys);
}
//3. 释放资源.
fos.close();
//System.out.println("制造完成");
}
}
package com.it.demo02_Inputstream;
import java.io.FileInputStream;
import java.io.IOException;
/*
案例: 演示字节输入流入门.
普通的字节输入流简介
概述:
普通的字节输入流指的是FileInputStream, 它是以字节为单位来读取数据的.
构造方法:
public FileInputStream(String pathName); 创建字节输入流对象, 关联数据源文件(字符串形式)
public FileInputStream(File pathName); 创建字节输入流对象, 关联数据源文件(File对象形式)
成员方法:
public int read(); 一次读取一个字节, 并返回该字节对应的ASCII码值, 读不到返回-1 'a' -> 97
public int read(byte[] bys); 一次读取一个字节数组, 把读取到的数据存储到字节数组中,
并返回读取到的有效字节数, 读不到返回-1 'a' -> 1
public void close(); 关闭流, 释放资源的.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1. 创建输入流对象, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 读取数据.
//3. 将读取到的数据打印到控制台上.
//一次读取一个字节, 返回的是该字节对应的ASCII码值.
//分解版
/*int len1 = fis.read();
System.out.println(len1);
int len2 = fis.read();
System.out.println(len2);
int len3 = fis.read();
System.out.println(len3);
int len4 = fis.read();
System.out.println(len4);*/
//合并版
int len;
/*
(len = fis.read()) != -1 这行代码做了3件事儿:
1. 执行 fis.read() 采用一次读取一个字节的形式读取数据.
2. 执行 len = fis.read() 把读取到的数据(ASCII码值, 有效字节数)赋值给变量
3. 执行 len != -1 判断是否读取到了数据, 如果不为-1说明有数据.
*/
while((len = fis.read()) != -1) {
System.out.println(len);
}
//4. 释放资源.
fis.close();
}
}
package com.it.demo02_Inputstream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
/*
案例: 演示字节输入流一次读写一个字节数组.
核心细节:
public int read(byte[] bys); 一次读取一个字节数组, 把读取到的数据存储到字节数组中,
并返回读取到的有效字节数, 读不到返回-1
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
//1. 创建字节输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 采用一次读取一个字节数组的形式读取数据.
byte[] bys = new byte[3]; //0, 0, 0
int len; //记录的是有效字节数.
while((len = fis.read(bys)) != -1) {
//输出读取到的数据, 转成字符串, 然后输出.
String s = new String(bys, 0, len);
System.out.println(s);
}
//分解版
/*//第一次读取
int len1 = fis.read(bys);
System.out.println(Arrays.toString(bys)); //97, 98, 99
System.out.println(len1); //3
//第二次读取
int len2 = fis.read(bys);
System.out.println(Arrays.toString(bys)); //100, 101, 102
System.out.println(len2); //3
//第三次读取
int len3 = fis.read(bys);
System.out.println(Arrays.toString(bys)); //103, 101, 102
System.out.println(len3); //1
//第四次读取
int len4 = fis.read(bys);
System.out.println(Arrays.toString(bys)); //103, 101, 102
System.out.println(len4); //-1*/
//3. 释放资源.
fis.close();
}
}
package com.it.demo04_bufferedinputstream;
import java.io.*;
/*
案例: 字节缓冲流入门.
需求:
1.通过字节缓冲输出流往文件中写一句话.
2.通过字节缓冲输入流读取文件中的内容.
字节缓冲流简介:
概述:
字节缓冲流也叫: 缓冲字节流, 高效字节流, 字节高效流, 它仅仅是提供了一个缓冲区, 具体的读写操作还是由普通的字节流实现的.
分类:
字节缓冲输入流: BufferedInputStream
构造方法:
public BufferedInputStream(InputStream is); 创建字节缓冲输入流对象,用来给 普通的字节输入流对象提供缓冲区.
字节缓冲输出流: BufferedOutputStream
构造方法:
public BufferedOutputStream(OutputStream os); 创建字节缓冲输出流对象,用来给 普通的字节输出流对象提供缓冲区.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1.通过字节缓冲输出流往文件中写一句话.
//分解版
//1.1 创建普通的字节输出流, 没有默认的缓冲区.
//FileOutputStream fos = new FileOutputStream("day12/data/1.txt"); //化妆之前的妹子.
//1.2 创建字节缓冲输出流, 关联普通的字节输出流, 给他提供缓冲区.
//BufferedOutputStream bos = new BufferedOutputStream(fos); //化妆之后的妹子..
//合并版
//提供缓冲区 关联目的地文件, 写数据.
/* BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day12/data/1.txt"));
//1.3 往文件中写数据.
bos.write("abc, 你好, 我是缓冲字节流".getBytes());
//1.4 关流, 释放资源
bos.close(); */ //关联的fos对象, 会自动关闭.
//需求2: 通过字节缓冲输入流读取文件中的内容.
//2.1 创建字节缓冲输入流对象, 关联数据源文件.
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day12/data/1.txt"));
//2.2 读取数据中的数据.
byte[] bys = new byte[1024];
int len = bis.read(bys);
String s = new String(bys, 0, len); //把读取到的数据转成字符串.
//2.3 把读取到的数据打印到控制台.
System.out.println(s);
//2.4 释放资源.
bis.close();
}
}
package com.it.demo05_reader;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
/*
案例: 演示字节流一次读取一个字节的形式, 读取中文数据.
需求:
1.已知项目下的data文件夹下的1.txt文件中包含数据"abc中国".
2.请通过字节流一次读取一个字节的形式, 将上述文件中的内容读取出来.
3.将上述读取到的数据打印到控制台上.
结论:
用字节流虽然也能操作纯文本文件, 但是效率相对比较低, 因为中文在不同的码表中,
占用的字节数也不同.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 读取数据.
int len;
while ((len = fis.read()) != -1) {
//3. 打印读取到的数据.
System.out.println((byte)len);
}
//4. 释放资源.
fis.close();
System.out.println("-------------------------");
//演示: 如何将字符串内容转成其对应的字节数组形式
/*
涉及到的String类中的成员方法:
public byte[] getBytes(); 采用默认码表, 将字符串转成其对应的字节数组形式.
public byte[] getBytes(String charsetName); 采用指定码表, , 将字符串转成其对应的字节数组形式.
*/
byte[] bys1 = "你好".getBytes(); //默认: UTF-8
byte[] bys2 = "你好".getBytes("utf-8"); //默认: UTF-8
byte[] bys3 = "你好".getBytes("gbk"); //默认: UTF-8
System.out.println(Arrays.toString(bys1));
System.out.println(Arrays.toString(bys2));
System.out.println(Arrays.toString(bys3));
}
}
package com.it.demo05_reader;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/*
案例: 编码表简介.
概述:
编码表就是用来描述字符和数字的对应关系的, 因为计算机能直接识别二进制的数据, 所以我们的
代码在存储数据的时候, 如非必要, 一般是把数据转成二进制形式的存, 然后再做操作.
常用的码表:
ASCII: 美国通用信息交互码表, 就是描述char和int范围的.
IOS-8859-1: 主要针对于欧洲的.
GBK: 主要是针对于国内的(字符)
utf-8: 也叫万国码, 主要是针对所有的语言的
细节:
用什么码表编码, 就用指定的码表解码. 大白话举例: 编解码一致.
编码涉及到的方法: 我们看的懂的数据 -> 我们看不懂的数据.
即: String --> byte[] bys
解码涉及到的方法: 我们看不懂的数据 -> 我们看的懂的数据
public String();
public String(String s);
public String(byte[] bys, int start, int len);
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
//编码: 把我们能看懂的数据, 变成我们看不懂的.
String s1 = "传智播客";
//编码
byte[] bys = s1.getBytes("utf-8"); //字符串s1转成 byte[] bys
//输出
System.out.println(Arrays.toString(bys));
System.out.println("-----------------------------");
//解码: 把我们看不懂的数据, 解析成我们能看懂的数据.
String s = new String(bys); //byte[] bys -> 字符串s
System.out.println(s);
}
}
package com.it.demo05_reader;
import java.io.*;
/*
案例: 演示转换流入门.
需求:
1.通过转换流, 将项目下data文件夹中1.txt文件的内容, 拷贝到data文件夹下2.txt文件中.
2.运行, 并查看返回值结果.
概述:
转换流就是用来把字节流封装成字符流的, 转换流只有两个:
InputStreamReader(); 把字节输入流 封装成 字符输入流.
涉及到的构造方法:
public InputStreamReader(字节输入流);
public InputStreamReader(字节输入流, "码表);
OutputStreamWriter(): 把字节输出流 封装撤回 字符输出流.
public OutputStreamWriter(字节输出流);
public OutputStreamWriter(字节输出流, "码表");
细节:
1. 字符流 = 字节流 + 编码表
2. 谁是字节流通向字符流的桥梁, 谁是字符流通向字节流的桥梁?
字节流通向字符流的桥梁: InputStreamReader
字符流通向字节流的桥梁: OutputStreamWriter
*/
public class Demo03 {
public static void main(String[] args) throws IOException {
//1. 创建输入流, 关联数据源文件.
//InputStreamReader isr = new InputStreamReader(new FileInputStream("day12/data/1.txt"),"utf-8");
//上述代码可以简写成
InputStreamReader isr = new InputStreamReader(new FileInputStream("day12/data/1.txt"));
//2. 创建输出流, 关联目的地文件.
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day12/data/2.txt"),"utf-8");
//3. 定义变量, 用来记录读取到的数据(字符).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = isr.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
osw.write(len);
}
//6. 关流, 释放资源.
isr.close();
osw.close();
}
}
package com.it.demo06_bufferedreader;
import java.io.*;
/*
案例: 演示字符缓冲流入门.
需求:
1.通过字符缓冲输出流往文件中写一句话.
2.通过字符缓冲输入流读取文件中的内容.
字符缓冲流涉及到的内容:
概述:
所谓的字符串缓冲流也叫: 缓冲字符流, 高效字符流, 字符高效流, 它仅仅是提供了一个缓冲区, 具体的读写还是普通的字符流来做的.
所以在创建字符缓冲流的时候, 需要关联一个普通的字符流. 字符缓冲流主要有: BufferedReader 和 BufferedWriter.
涉及到构造方法:
BufferedReader类中的构造方法:
public BufferedReader(Reader r); 创建字符缓冲输入流对象, 关联普通的字符输入流
BufferedWriter类中的构造方法:
public BufferedWriter(Writer w); 创建字符缓冲输出流对象, 关联普通的字符输出流.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1.通过字符缓冲输出流往文件中写一句话.
//1.1 创建输出流, 关联目的地文件.
//分解版
/*FileWriter fw = new FileWriter("day12/data/1.txt");
BufferedWriter bw = new BufferedWriter(fw);*/
/* //合并版
BufferedWriter bw = new BufferedWriter( new FileWriter("day12/data/1.txt"));
//1.2 往文件中写数据.
bw.write("风和日丽, 晴空万里!");
//1.3 释放资源.
bw.close();*/
//2.通过字符缓冲输入流读取文件中的内容.
//2.1 创建输入流, 关联数据源文件.
BufferedReader br = new BufferedReader(new FileReader("day12/data/1.txt"));
//2.2 读取数据.
char[] chs = new char[1024];
int len = br.read(chs);
//把读取到的数据转成字符串
String s = new String(chs, 0, len);
//2.3 打印读取到的数据.
System.out.println(s);
//2.4 释放资源.
br.close();
}
}
package com.it.demo06_bufferedreader;
import java.io.*;
/*
案例: 演示字符缓冲流拷贝文件.
需求:
通过字符缓冲流一次读写一个字符的方式复制文件.
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
//方式一: 通过字符缓冲流一次读写一个字符的方式复制文件.
//method01();
//方式二: 通过字符缓冲流一次读写一个字符数组的方式复制文件.
//1. 创建输入流, 关联数据源文件.
BufferedReader br = new BufferedReader(new FileReader("day12/data/1.txt"));
//2. 创建输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day12/data/2.txt"));
//3. 定义变量, 用来记录读取到的数据(字节, 字符, 有效字节数, 有效字符数).
int len;
char[] chs = new char[1024];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = br.read(chs)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
bw.write(chs, 0, len);
}
//6. 关流, 释放资源.
br.close();
bw.close();
}
public static void method01() throws IOException {
//1. 创建输入流, 关联数据源文件.
BufferedReader br = new BufferedReader(new FileReader("day12/data/1.txt"));
//2. 创建输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day12/data/2.txt"));
//3. 定义变量, 用来记录读取到的数据(字节, 字符, 有效字节数, 有效字符数).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = br.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
bw.write(len);
}
//6. 关流, 释放资源.
br.close();
bw.close();
}
}
package com.it.pojo;
import java.io.Serializable;
//学生类
public class Student implements Serializable {
//为了防止序列化号一直变化, 我们手动给出.
public static final long serialVersionUID = 2L;
private String name;
private transient int age; //transient: 瞬态关键字.
private String gender;
private String email;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.it.demo07_serializable;
import com.it.pojo.Student;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/*
案例: 演示对象的序列化 和 反序列化操作.
序列化流和反序列化流简介:
ObjectOutputStream: 对象序列化流
作用: 把对象写入到指定的文件中.
涉及到的成员:
public ObjectOutputStream(OutputStream os);
public void writeObject(Object obj); //把对象写入到文件中.
ObjectInputStream: 对象反序列化流
作用: 从文件中读取对象.
涉及到的成员:
public ObjectInputStream(InputStream is);
public Object readObject();
Serializable接口简介:
它是一个标记接口, 任何想实现序列化和反序列化操作的类, 必须实现该接口.
该接口只是用来做标记的, 它里边没有任何的成员.
细节:
1. 一个类的对象想实现序列化或者反序列化操作,则该对象所在的类必须实现: Serializable接口.
2. 如果要同时序列化多个对象, 可以尝试把这些对象都放在同一个集合中, 然后把集合对象序列化到文件中,
将来反序列化的时候, 读取到的也是集合对象, 然后遍历集合, 即可获取每个对象.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//需求: 演示序列化操作, 即: 把学生对象写到 1.txt 文件中.
//1. 创建序列化流. 关联目的地文件.
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day12/data/1.txt"));
//2. 创建JavaBean对象.
Student s1 = new Student("刘亦菲", 33);
//Student s2 = new Student("赵丽颖", 31);
//3. 把对象写到文件中, 序列化操作.
oos.writeObject(s1);
//oos.writeObject(s2);
//4. 释放资源.
oos.close();
}
}
package com.it.demo07_serializable;
import com.it.pojo.Student;
import java.io.*;
/*
案例: 演示对象的反序列化操作, 涉及到的流是: ObjectInputStream
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
//需求: 演示反序列化操作, 即: 从1.txt文件中读取 Student对象.
//1. 创建反序列化流. 关联数据源文件.
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12/data/1.txt"));
//2. 从到文件中读取对象, 反序列化操作.
//细节: 需要向下转型.
Student stu = (Student)ois.readObject();
//Student stu2 = (Student)ois.readObject();
//3. 打印读取到的对象.
System.out.println(stu); //刘亦菲, 33
//System.out.println(stu2); //赵丽颖, 31
//4. 释放资源.
ois.close();
}
}
package com.it.demo07_serializable;
/*
案例: 演示序列化操作时候的细节问题.
问题1: 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
会出问题，会抛出InvalidClassException异常
问题2: 如何解决上述的问题?
方式一: 重新序列化.
方式二: 自己给类定义一个成员变量 serialVersionUID, 它是一个long类型的变量.
这样的话, 即使类中的成员变化了, serialVersionUID也不会跟着变化, 必须手动设置(修改).
问题3: 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程
transient关键字解释:
它表示瞬态关键字, 被它标记的成员变量不参与序列化过程.
*/
public class Demo03 {
public static void main(String[] args) {
}
}
package com.it.demo07_serializable;
import java.io.FileWriter;
import java.io.IOException;
/*
案例: 演示close() 和 flush()方法的区别.
close(): 用来关闭流, 释放资源的, 关闭之前, 会自动刷新一次缓冲区, 关闭之后, 流对象就不能继续使用了.
flush(): 用来刷新缓冲区的, 把缓冲区的数据给刷新出来. 刷新之后, 流对象还可以继续使用.
*/
public class Demo04 {
public static void main(String[] args) throws IOException {
//需求: 往1.txt文件中写数据.
FileWriter fw = new FileWriter("day12/data/1.txt");
fw.write("你好啊\r\n");
fw.write("我是字节缓冲流"); //这些数据在缓冲区.
//方式一: flush()方式实现, 刷新缓冲区
fw.flush();
fw.write("看看我写到文件中了吗?");
//方式二: 关流, 释放资源.
fw.close();
}
}
package com.it.demo07_serializable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示IO流的标准异常处理代码.
JDK1.7以前的处理方案.
*/
public class Demo05 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1. 创建输入流, 关联数据源文件.
fis = new FileInputStream("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
fos = new FileOutputStream("day12/data/3.txt");
//3. 定义变量, 用来记录读取到的数据(有效字节数).
int len;
byte[] bys = new byte[1024];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read(bys)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(bys, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//6. 关流, 释放资源.
try {
System.out.println(1/0);
if (fis != null) {
fis.close();
fis = null; //GC会优先回收null对象
System.out.println("fis关闭了");
}
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
if (fos != null) {
fos.close();
fos = null; //GC会优先回收null对象
System.out.println("fos关闭了");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.it.demo07_serializable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/*
案例: 演示IO流的标准异常处理代码.
JDK1.7及其以后的处理方案: try.with.resources语句
try.with.resources语句简介:
概述:
try(
//这里写对象.
){
//这里写逻辑代码
} catch(异常类型 对象名) {
出现异常后的解决方案
}
特点:
写在try小括号中的对象, 会在大括号中的内容执行完毕后, 自动释放.
前提要求:
写在try小括号中的对象所在的类, 必须实现 AutoCloseable接口.
*/
public class Demo06 {
public static void main(String[] args) {
try(
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/3.txt");
Demo07 d = new Demo07();
) {
//3. 定义变量, 用来记录读取到的数据(有效字节数).
int len;
byte[] bys = new byte[1024];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read(bys)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(bys, 0, len);
}
//6. 关流, 释放资源.
fis.close();
fos.close();
} catch(Exception e) {
e.printStackTrace();
}
}
}
package com.it.demo07_serializable;
//为了演示, try.with.resources语句的特点.
public class Demo07 implements AutoCloseable{
@Override
public void close() throws Exception {
System.out.println("看看我执行了吗? 执行了, 就表示Demo07对象, 被释放资源了.");
}
}
package com.it.demo03_exercise;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示普通的字节流 拷贝 文本文件.
拷贝方式:
方式一: 一次读写一个字节.
方式二: 一次读写一个字节数组.
IO流的核心操作步骤:
1. 创建输入流, 关联数据源文件.
2. 创建输出流, 关联目的地文件.
3. 定义变量, 用来记录读取到的数据(字节, 字符, 有效字节数, 有效字符数).
4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
5. 将读取到的数据写入到目的地文件中.
6. 关流, 释放资源.
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//方式一: 一次读写一个字节
//method01();
//方式二: 一次读写一个字节数组.
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/3.txt");
//3. 定义变量, 用来记录读取到的数据(有效字节数).
int len;
byte[] bys = new byte[1024];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read(bys)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(bys, 0, len);
}
//6. 关流, 释放资源.
fis.close();
fos.close();
System.out.println("拷贝成功!");
}
public static void method01() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/2.txt");
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(len);
}
//6. 关流, 释放资源.
fis.close();
fos.close();
}
}
package com.it.demo03_exercise;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
案例: 演示图片加密.
需求:
1.对项目下的a.jpg图片进行加密, 获取到一个新的加密图片b.jpg.
2.对加密后的图片b.jpg进行解密, 获取解密后的图片c.jpg.
核心: 通过运算符 ^ 实现.
位异或运算符^的用法: 一个数字被同一个数字位异或两次, 该数字值不变.
例如: 5 ^ 10 ^ 10 = 5
流程:
a.jpg -> b.jgp //加密动作
b.jpg -> c.jpg //解密动作
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
/*System.out.println(5 ^ 10 ^ 10); //5
System.out.println(5 ^ 10 ^ 5); //10*/
//需求: 图片加密, 要求: 你要自己记住密钥
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/b.jpg"); //已经和 56 位异或过的值, 即: len ^ 56
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/c.jpg");
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(len^ 56); //加密: len ^ 56(密钥) //解密: len ^ 56(密钥) ^ 56(密钥)
}
//6. 关流, 释放资源.
fis.close();
fos.close();
}
}
package com.it.demo03_exercise;
import java.io.*;
import java.util.Date;
/*
案例: 演示字节流拷贝文件的四种方式的效率问题.
需求:
1.分别通过四种方式拷贝视频文件, 并观察它们的效率.
2.通过普通的字节流一次读写一个字节的形式实现.
3.通过普通的字节流一次读写一个字节数组的形式实现.
4.通过高效的字节流一次读写一个字节的形式实现.
5.通过高效的字节流一次读写一个字节数组的形式实现.
结论(四种拷贝方式效率从高到底分别是):
1. 高效的字节流一次读写一个字节数组. 29毫秒
2. 普通的字节流一次读写一个字节数组. 19毫秒
小细节:
因为字节缓冲流的默认缓冲区的大小是 8192个字节, 所以理论上来讲, 如果自定义的数组(当做缓冲区来用)长度是8192的话,
该拷贝方式效率会比 字节高效流一次一个字节数组的方式 快一点点, 因为如果是采用 字节高效流, 虽然他有内置的缓冲区,
但是创建及初始化缓冲区也需要消耗一定的时间,
3. 高效的字节流一次读写一个字节. 294毫秒
4. 普通的字节流一次读写一个字节. 55062毫秒
*/
public class Demo03 {
public static void main(String[] args) throws IOException {
//long start = new Date().getTime(); //获取当前时间的毫秒值
long start = System.currentTimeMillis(); //获取当前时间的毫秒值
//1. 通过普通的字节流一次读写一个字节的形式实现.
//method01();
//2. 通过普通的字节流一次读写一个字节数组的形式实现.
//method02();
//3. 通过高效的字节流一次读写一个字节的形式实现.
//method03();
//4. 通过高效的字节流一次读写一个字节数组的形式实现.
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.avi");
BufferedInputStream bis = new BufferedInputStream(fis);
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/copy4.avi");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
byte[] bys = new byte[8192];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = bis.read(bys)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
bos.write(bys, 0, len);
}
//6. 关流, 释放资源.
bis.close();
bos.close();
long end = System.currentTimeMillis(); //获取当前时间的毫秒值
System.out.println("程序执行时间为: " + (end - start) + "毫秒");
}
public static void method03() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.avi");
BufferedInputStream bis = new BufferedInputStream(fis);
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/copy3.avi");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = bis.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
bos.write(len);
}
//6. 关流, 释放资源.
bis.close();
bos.close();
}
public static void method02() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.avi");
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/copy2.avi");
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
byte[] bys = new byte[8192];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read(bys)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(bys, 0, len);
}
//6. 关流, 释放资源.
fis.close();
fos.close();
}
public static void method01() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileInputStream fis = new FileInputStream("day12/data/1.avi");
//2. 创建输出流, 关联目的地文件.
FileOutputStream fos = new FileOutputStream("day12/data/copy1.avi");
//3. 定义变量, 用来记录读取到的数据(字节).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fis.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fos.write(len);
}
//6. 关流, 释放资源.
fis.close();
fos.close();
}
}
package com.it.demo03_exercise;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
案例: 演示普通的字符流拷贝文件.
拷贝方式:
方式一: 一次读写一个字符.
方式二: 一次读写一个字符数组.
*/
public class Demo04 {
public static void main(String[] args) throws IOException {
//演示 方式一: 一次读写一个字符.
//method01();
//演示 方式二: 一次读写一个字符数组.
//method02();
}
public static void method02() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileReader fr = new FileReader("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
FileWriter fw = new FileWriter("day12/data/2.txt");
//3. 定义变量, 用来记录读取到的数据(字符).
int len;
char[] chs = new char[1024];
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fr.read(chs)) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fw.write(chs, 0, len);
}
//6. 关流, 释放资源.
fr.close();
fw.close();
}
public static void method01() throws IOException {
//1. 创建输入流, 关联数据源文件.
FileReader fr = new FileReader("day12/data/1.txt");
//2. 创建输出流, 关联目的地文件.
FileWriter fw = new FileWriter("day12/data/2.txt");
//3. 定义变量, 用来记录读取到的数据(字符).
int len;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((len = fr.read()) != -1) {
//5. 将读取到的数据写入到目的地文件中.
fw.write(len);
}
//6. 关流, 释放资源.
fr.close();
fw.close();
}
}
package com.it.demo03_exercise;
import java.io.*;
/*
案例: 演示字符缓冲流独有的拷贝文件的方式, 一次读写一行.
涉及到的成员方法:
BufferedReader类中的成员方法:
public String readLine(); 一次读取一行数据, 并返回读取到的内容, 读不到返回 null
BufferedWriter类中的成员方法:
public void newLine(); 根据当前操作系统, 给出对应的换行符.
例如; window系统 \r\n, linux系统: \n mac系统: \r
通过IO流拷贝文件的几种方式如下:
需求1: 拷贝纯文本文件.
FileInputStream && FileOutputStream
1. 普通的字节流一次读写一个字节.
2. 普通的字节流一次读写一个字节数组. //掌握
BufferedInputStream && BufferedOutputStream
3. 高效的字节流一次读写一个字节. //掌握
4. 高效的字节流一次读写一个字节数组.
InputStreamReader && OutputStreamWriter
5. 转换流一次读写一个字符.
6. 转换流一次读写一个字符数组.
FileReader && FileWriter
7. 普通的字符流一次读写一个字符.
8. 普通的字符流一次读写一个字符数组.
BufferedReader && BufferedWriter
9. 高效的字符流一次读写一个字符.
10. 高效的字符流一次读写一个字符数组.
11. 高效的字符流一次读写一行. //掌握
需求2: 拷贝任意类型的文件.
1. 普通的字节流一次读写一个字节.
2. 普通的字节流一次读写一个字节数组.
3. 高效的字节流一次读写一个字节.
4. 高效的字节流一次读写一个字节数组.
*/
public class Demo05 {
public static void main(String[] args) throws IOException {
//1. 创建输入流, 关联数据源文件.
BufferedReader br = new BufferedReader(new FileReader("day12/data/1.txt"));
//2. 创建输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day12/data/2.txt"));
//3. 定义变量, 用来记录读取到的数据(一行数据).
String line;
//4. 循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
while ((line = br.readLine()) != null) {
//5. 将读取到的数据写入到目的地文件中.
bw.write(line);
//核心细节: 千万别忘记加换行, 因为readLine()方法结束标记是换行符, 但是该方法不获取换行符.
bw.newLine();
}
//6. 关流, 释放资源.
br.close();
bw.close();
}
}
浙公网安备 33010602011771号