加油哒哒哒

11.IO流--黑马程序员

File、IO流

D:\code\黑马\code\IO-app

File：读写，操作文件
IO流：读写、操作文件中的数据

一、File

1. 概念

File是java.io.包下的类，File类的对象用于代表当前操作系统中的文件（可以是文件、或文件夹）

File类只能对文件本身进行操作，不能读写文件里面存储的数据

2. 构造器

2.1常用构造器

构造器	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	根据父路径和子路径名字创建文件对象
public File(File parent, String child)	根据父路径对应文件对象和子路径名字创建文件对象

public class Test1 {
    public static void main(String[] args) {
        //创建File对象的三种方式

        //1. 通过文件路径创建File对象
        //public File(String pathname)
        File f1 = new File("E:/A/a.txt");
        System.out.println(f1);//E:\A\a.txt

        //2. 通过父路径和子路径创建File对象
        //public File(String parent, String child)
        File f2 = new File("E:/A", "a.txt");
        System.out.println(f2);//E:\A\a.txt

        //3. 通过父路径对象和子路径创建File对象
        //public File(File parent, String child)
        File parentFile = new File("E:/A");
        File f3 = new File(parentFile, "a.txt");
        System.out.println(f3);//E:\A\a.txt
    }
}

2.1.1 注意

File对象既可以代表文件、也可以代表文件夹
Fil封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的

public class Test2 {
    public static void main(String[] args) {
        //File对象既可以代表文件、也可以代表文件夹。

        //File对象代表文件
        File f1 = new File("E:/A/a.txt");
        System.out.println(f1.exists());//true
        //File对象代表文件夹
        File f2 = new File("E:/A");
        System.out.println(f2.exists());//true

        //Fil封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。
        File f3 = new File("E:/A/dw");//路径下的文件夹dw不存在
        System.out.println(f3.exists());//false
        File f4 = new File("E:/A/d.txt");//路径下的文件d.txt不存在
        System.out.println(f4.exists());//false
    }
}

2.2 路径分隔符写法

使用’/'表示路径分隔符
使用’\\'表示路径分隔符，第一个\表示转义
使用File类提供的常量File.separator

public class Test3 {
    public static void main(String[] args) {
        //路径分隔符三种写法

        //1.使用'/'表示路径分隔符
        File f1 = new File("E:/A/a.txt");
        System.out.println(f1);//E:\A\a.txt

        //2.使用'\\'表示路径分隔符
        File f2 = new File("E:\\A\\a.txt");
        System.out.println(f2);//E:\A\a.txt

        //3.使用File.separator表示路径分隔符
        File f3 = new File("E:" + File.separator + "A" + File.separator + "a.txt");
        System.out.println(f3);//E:\A\a.txt
    }
}

2.3 绝对路径与相对路径

绝对路径：从盘符开始
- D:\code\黑马\code\IO-app\src\a.txt
相对路径：不带盘符，默认直接到当前工程下的目录寻找文件
- 项目名为IO-app，项目路径为D:\code\黑马\code\IO-app，所以项目下文件的相对路径可以直接写成下面格式，如果直接在项目路径下，直接写文件名即可
- src\a.txt

public class Test4 {
    public static void main(String[] args) {
        //绝对路径和相对路径

        //1. 绝对路径：从盘符开始的路径，这种路径一般都是写死的。
        File f1 = new File("D:\\code\\黑马\\code\\IO-app\\src\\a.txt");
        System.out.println(f1.exists());//true

        //2. 相对路径：相对于当前项目而言的，这种路径建议写活的。
        File f2 = new File("src\\a.txt");
        System.out.println(f2.exists());//true
        //如果直接在项目下，不在src下，直接写a.txt即可。
    }
}

3. 常用方法

3.1 判断文件类型、获取文件信息的方法

方法	说明
public boolean exists( )	判断当前文件对象对应的文件路径是否存在，存在返回true
public boolean isFile( )	判断当前文件对象指代的是否是文件，是文件返回true
public boolean isDirectory( )	判断当前文件对象指代的是否是文件夹，是文件夹返回true
public String getName( )	获取文件的名称（包含后缀）
public long length( )	获取文件的大小，返回字节个数
public long lastModified( )	获取文件的最后修改时间。
public String getPath( )	获取创建文件对象时所使用的路径
public String getAbsolutePath( )	获取文件对象的绝对路径

public class Test5 {
    public static void main(String[] args) {
        //判断文件类型、获取文件信息的方法
        File file1 = new File("src/a.txt");//相对路径
        File file3 = new File("D:\\code\\黑马\\code\\IO-app\\src\\a.txt");//绝对路径
        File file2= new File("src");
        //1.判断路径是否存在
        //public boolean exists( )，存在返回true，不存在返回false
        System.out.println(file1.exists());//true

        //2.判断是否是文件
        //public boolean isFile( )，是文件返回true，不是文件返回false
        System.out.println(file1.isFile());//true

        //3.判断是否是文件夹
        //public boolean isDirectory( )，是文件夹返回true，不是文件夹返回false
        System.out.println(file1.isDirectory());//false
        System.out.println(file2.isDirectory());//true

        //4.获取文件或文件夹名
        //public String getName( )，返回文件或文件夹名
        System.out.println(file1.getName());//a.txt
        System.out.println(file2.getName());//src

        //5.获取文件或文件夹的大小
        //public long length( )，返回文件或文件夹的大小，单位是字节
        System.out.println(file1.length());//6

        //6.获取文件或文件夹的最后修改时间
        //public long lastModified( )，返回文件或文件夹的最后修改时间，单位是毫秒
        long time = file1.lastModified();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd " +
                "HH:mm:ss");
        System.out.println(simpleDateFormat.format(time));//2023-08-09 11:05:36

        //7.获取常见File对象时使用的路径
        //public String getPath( )，返回常见File对象时使用的路径
        System.out.println(file1.getPath());//src\a.txt
        System.out.println(file3.getPath());//D:\code\黑马\code\IO-app\src\a.txt

        //8.获取绝对路径
        //public String getAbsolutePath( )，返回绝对路径
//无论创建File对象时使用的是绝对路径还是相对路径，都可以使用getAbsolutePath()方法获取绝对路径
        System.out.println(file1.getAbsolutePath());//D:\code\黑马\code\IO-app\src\a.txt
        System.out.println(file3.getAbsolutePath());//D:\code\黑马\code\IO-app\src\a.txt
    }
}

3.2 创建文件、删除文件的方法

创建文件方法	说明
public boolean createNewFile( )	创建一个新的空文件
public boolean mkdir( )	只能创建一级文件夹
public boolean mkdirs( )	可以创建多级文件夹

删除创建文件方法	说明
public boolean delete( )	默认只能删除文件或空文件夹，无法删除非空文件夹，删除后的文件不会放入回收站，不允许使用相对路径

public class Test {
    public static void main(String[] args) throws IOException {
        //1. 创建新的空文件
        //public boolean createNewFile( )
        //创建成功返回true，如果已有该文件则返回false
        File f1 = new File("D:\\code\\黑马\\code\\IO-app\\src\\b.txt");//当前不存在该文件
        //创建File对象时传入的必须是绝对路径，相对路径会报错
        System.out.println(f1.createNewFile());//true
        System.out.println(f1.createNewFile());//false
        //第二次创建失败，因为已经存在该文件

        //2. 创建空的一级文件夹
        //public boolean mkdir( )
        //创建成功返回true，如果已有该文件夹则返回false
        File f2 = new File("D:\\code\\黑马\\code\\IO-app\\src\\c");
        System.out.println(f2.mkdir());//true
        System.out.println(f2.mkdir());//false
        //如果父目录也不存在，则属于创建二级文件夹，会创建失败
        File f3 = new File("D:\\code\\黑马\\code\\IO-app\\src\\d\\e");
        System.out.println(f3.mkdir());//false

        //3. 创建空的多级文件夹
        //public boolean mkdirs( )
        //创建成功返回true，如果已有该文件夹则返回false
        File f4 = new File("D:\\code\\黑马\\code\\IO-app\\src\\d\\e");
        System.out.println(f4.mkdirs());//true
        System.out.println(f4.mkdirs());//false

        //4. 删除文件或文件夹，如果是文件夹，则必须是空的才能删除
        //public boolean delete( )
        //删除成功返回true，如果不存在该文件或文件夹或文件夹不为空则返回false
        File f5 = new File("D:\\code\\黑马\\code\\IO-app\\src\\a.txt");
        System.out.println(f5.delete());//true 删除有内容的文件
        File f6 = new File("D:\\code\\黑马\\code\\IO-app\\src\\b.txt");
        System.out.println(f6.delete());//true 删除空文件
        File f7 = new File("D:\\code\\黑马\\code\\IO-app\\src\\c");
        System.out.println(f7.delete());//true 删除空文件夹
        File f8 = new File("D:\\code\\黑马\\code\\IO-app\\src");
        System.out.println(f8.delete());//false 删除非空文件夹
    }
}

3.3 遍历文件夹的方法

3.3.1 遍历当前File对象的一级目录的方法

方法(只能遍历一级目录)	说明
public String[ ] list( )	获取当前目录下所有的"一级文件名称“到一个字符串数组中去返回
public File[ ] listFiles( )	获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回

public class Test6 {
    public static void main(String[] args) {
        //获取当前目录下所有的"一级文件名称“到一个字符串数组中去返回
        //返回所有当前路径文件夹下的文件夹和文件（隐藏文件也会返回），不包含子文件夹中的内容
        //public String[] list( )
        File f1 = new File("src\\file");
        String[] names = f1.list();
        System.out.println(Arrays.toString(names));
        //[Test.java, Test1.java, Test2.java, Test3.java, 
        // Test4.java, Test5.java, Test6.java]

        //获取当前目录下所有的"一级文件对象”到一个File数组中去返回
        //public File[] listFiles( )
        File[] files = f1.listFiles();
        System.out.println(Arrays.toString(files));//数组中的元素是File对象
        //[src\file\Test.java, src\file\Test1.java, src\file\Test2.java,
        // src\file\Test3.java, src\file\Test4.java, src\file\Test5.java, 
        // src\file\Test6.java]
        System.out.println(files[0].getAbsolutePath());
        //D:\code\黑马\code\IO-app\src\file\Test.java
    }
}

使用ListFiles方法时的注意事项：

当File对象是文件，或者路径不存在时，返回null
当File对象是空文件夹时，返回一个长度为0的数组
当File对象是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
当File对象是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当File对象是一个文件夹，但是没有权限访问该文件夹时，返回null

案例

public class Test8 {
    public static void main(String[] args) {
        //将文件夹下的视频的序号从19开始重新命名
        //原文件格式： 1、... .mp4 2、... .mp4 3、... .mp4等

        //创建文件夹对象
        File f = new File("D:\\Java\\video");//该文件夹下有视频文件
        //获取文件夹下的所有文件
        File[] videos = f.listFiles();

        for (File video : videos) {
            String name = video.getName();
            String index = name.substring(0, name.indexOf("、"));
            String lastName = name.substring(name.indexOf("、"));
            String newName = (Integer.parseInt(index) + 18) + lastName;

            //重命名
            video.renameTo(new File(f,newName));
        }
    }
}

3.3.2 遍历当前File对象的多级子目录的方法（递归）

（1）前置知识：递归

概念

递归是一种算法，在程序设计语言中广泛应用。
从形式上说：方法调用自身的形式称为方法递归（recursion)。

递归的形式

直接递归：方法自己调用自己。
间接递归：方法调用其他方法，其他方法又回调方法自己。

递归三要素（解题的关键）

递归的公式
递归的终结点（出口）
递归的方向必须走向终结点

注意的问题

递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出错误

public class tests {
    public static void main(String[] args) {
        say();//直接递归
        say1();//间接递归
    }
    
    //直接递归,下面代码会报错，因为递归太深了，没有出口，栈内存溢出
    public static void say(){
        System.out.println("say");
        say();
    }
    
    //间接递归，同样会报错，因为递归太深了，没有出口，栈内存溢出
    public static void say1(){
        System.out.println("say1");
        say2();
    }
    
    public static void say2(){
        say1();
    }
}

案例1：计算n的阶乘

需求：计算n的阶乘

分析：

公式：f(n) = f(n-1) * n
终结点：f(1) = 1
递归方向：根据传入参数从n减到1，到终结点后，根据返回的1逐步计算（必须走向终结点）

public class Test9 {
    public static void main(String[] args) {
        int reuslt = getJieCheng(5);
        System.out.println(reuslt);
    }

    public static int getJieCheng(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n * getJieCheng(n - 1);
        }
    }
}

案例2：计算1到n的和

需求：计算1到n的和

分析：

公式：f(n) = f(n-1) + n
终结点：f(1) = 1
递归方向：根据传入参数从n减到1，到终结点后，根据返回的1逐步计算（必须走向终结点）

public class Test9 {
    public static void main(String[] args) {
        int reuslt = getSum(5);
        System.out.println(reuslt);
    }

    public static int getSum(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n + getSum(n - 1);
        }
    }
}

案例3：猴子吃桃问题

需求：

猴子第一天摘下若干桃子，当即吃了一半，觉得好不过瘾，于是又多吃了一个
第二天又吃了前天剩余桃子数量的一半，觉得好不过瘾，于是又多吃了一个
以后每天都是吃前一天剩余桃子数量的一半，觉得好不过瘾，又多吃了一个
等到第10天的时候发现桃子只有1个了。
需求：请问猴子第1天摘了多少个桃子？

分析：

f(n) = f(n - 1)/2 - 1 => 2f(n + 1) = f(n) - 2 => f(n) = 2f(n + 1) + 2
- 由于递归的方向要达到终结点，所以需要return的f中的参数必须每次+1
终结点：f(10) = 1
递归方向：从1加到10，达到终结点后逐步返回

public class Test9 {
    public static void main(String[] args) {
        int reuslt = peach(1);
        System.out.println(reuslt);
    }

    public static int peach(int n){
        if (n == 10) {
            return 1;
        }else {
            return (peach(n + 1) + 1) * 2;
        }
    }
}

案例4：啤酒问题

啤酒2元一瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，请问10元可以喝多少瓶？

public class T1 {
    public static void main(String[] args) {
        buy(10,0,0,0);
        //参数列表：钱数，总瓶数，剩余盖子数，剩余空瓶数
    }

    public static void buy(int money,int allNumber,int coverNumber,int bottleNumber ){
        int buyBottle = money / 2;//用钱买的瓶数
        money %= 2;
        allNumber += buyBottle;//总瓶数加上用钱买的瓶数
        coverNumber += buyBottle;//剩余盖子数加上用钱买的瓶数
        bottleNumber += buyBottle;//剩余空瓶数加上用钱买的瓶数

        if (coverNumber >= 4){//如果剩余盖子数大于4，可以换瓶
            buyBottle = coverNumber / 4;//用盖子换的瓶数
            allNumber += buyBottle;//总瓶数等于总瓶数加上用盖子换的瓶数
            coverNumber = coverNumber % 4 + buyBottle;
            //剩余盖子数等于剩余盖子数除以4的余数加上用盖子换的瓶数
            bottleNumber += buyBottle;//剩余空瓶数等于剩余空瓶数加上用盖子换的瓶数
        }

        if (bottleNumber >= 2){//如果剩余空瓶数大于2，可以换瓶
            buyBottle = bottleNumber / 2;//用空瓶换的瓶数
            allNumber += buyBottle;//总瓶数等于总瓶数加上用空瓶换的瓶数
            bottleNumber = bottleNumber % 2 + buyBottle;
            //剩余空瓶数等于剩余空瓶数除以2的余数加上用空瓶换的瓶数
            coverNumber += buyBottle;//剩余盖子数等于剩余盖子数加上用空瓶换的瓶数
        }

        if (coverNumber >= 4 || bottleNumber >= 2){
            //如果剩余盖子数大于4或者剩余空瓶数大于2，继续买
            buy(money,allNumber,coverNumber,bottleNumber);
        }else {
            System.out.printf("一共买了 %d 瓶%n", allNumber);
            System.out.println("剩余盖子数：" + coverNumber);
            System.out.println("剩余空瓶数：" + bottleNumber);
            return;
        }
    }
}

（2）遍历多级子目录案例1：搜索指定的文件

需求：从E盘中搜索“System4.0.exe”文件，找到后输出所在位置并启动

分析：

先找出E盘下的所有一级文件对象
遍历全部一级文件对象，判断文件对象的类型
如果是文件，判断是否是自己想要的文件
如果是文件夹，需要继续进入到该文件夹查找，重复上述过程

public class Test10 {
    public static void main(String[] args) throws Exception {
        File file = new File("E:\\");
        findFile(file, "System4.0.exe");
    }

    public static void findFile(File file, String name) throws Exception {
   //判断第一次传入的file是否存在或是否为文件，如果为文件并且文件名与name相同，则输出路径并打开
        if(!file.exists() || file == null || file.isFile()){
            if(file.isFile() && file.getName().equals(name)){
                System.out.println(file.getAbsolutePath());
                Runtime runtime = Runtime.getRuntime();
                //"cmd /c "是防止权限不够，无法打开文件
                runtime.exec("cmd /c " + file.getAbsolutePath());
            }
            return;
        }

        //当前传入的一定是一个文件夹
        File[] fs = file.listFiles();//获取当前文件夹下的所有文件和文件夹
        if (fs != null){
            for (File f : fs) {//遍历
                if (f.isFile()){//如果是文件
                    if(f.getName().equals(name)){//如果文件名与name相同，则输出路径并打开
                        System.out.println(f.getAbsolutePath());
                        Runtime runtime = Runtime.getRuntime();
                        runtime.exec("cmd /c " + f.getAbsolutePath());
                    }
                }else {
                    //如果是文件夹,重复上面的操作
                    findFile(f, name);
                }
            }
        }
    }
}

（3）遍历多级子目录案例2：删除非空文件夹

需求：删除非空文件夹

分析

File默认不可以删除非空文件夹
遍历文件夹，先删除里面的内容，再删除自己

public class T {
    public static void main(String[] args) {
        File file = new File("E:\\B");
        delectDic(file);
    }

    public static void delectDic(File file){
        if (!file.exists() || file == null){
            return;//文件不存在
        }
        if (file.isFile()){//存在且为文件
            file.delete();
        }else {
            //存在且一定为文件夹
            if (file == null){
                return;//没有删除的权限，直接return
            }
            File[] files = file.listFiles();
//            if (files.length == 0){
//                file.delete();
//                return;
//            }
            for (File f : files) {
                if (f.isFile()){
                    f.delete();
                }else {
                    delectDic(f);//删除下级目录
                }
            }
            file.delete();//删除自己
            //无论当前文件夹下是否为空，经过上面的for后，
            //都已经没有下一级文件了，所以无需写上面注释的代码
        }
    }
}

二、IO流

用于读写数据（可以读写文件，或网络中的数据.…）

1. 前置知识

1.1 计算机存储单位

位（bit）：计算机内部数据存储的最小单位，用b表示。11001100是一个八位二进制数

字节（byte）：计算机数据处理的基本单位，用B表示

1TB = 1024G
1G = 1024M
1M = 1024KB
1KB = 1024B
1B = 8bit

1.2 常见字符集

1.2.1 标准ASCII字符集（美国码）

ASCll：美国信息交换标准代码，包括数字，字母和常见符号，不包含汉字
标准ASC使用1个字节存储一个字符(即八位二进制数)，首位是0，总共可表示128个字符
- 0xxx xxxx 八位二进制数，以0开头
- 2的7次方 = 128

1.2.2 GBK字符集（中国码）

包含了2万多个汉字等字符，GBK中一个中文字符编码成**两个字节(16位二进制数)**的形式存储。
- 16位除去第一位必须是1，还可以有15位二进制数，可以表示2的15次方个汉字
兼容ASCII字符集，ASCII字符集以0开头，占一个字节；汉字占两个字节，以1开头
- 汉字：1xxxxxxx xxxxxxxxx
- ASCII字符集：0xxxxxxxx

1.2.3 Unicode字符集（统一码）

Unicode是国际组织制定的，可以容纳世界上所有文字、符号的字符集。

（1）UTF-32

用四个字节(32位二进制数)表示一个字符
缺点：占用的存储空间太大，通信效率变低

（2）UTF-8(最常用)

是Unicode字符集的一种编码方案，采取可变长编码方案，共分四个长度区：1个字节，2个字节，3个字节，4个字节
兼容标准ASCll编码，ASCll编码中的英文字符、数字等只占1个字节
汉字字符占三个字节

UTF-8编码格式（二进制形式,必须以表格中对应的数字开头）
1个字节的表示形式：0xxxxxxx（ASCll字符集）
2个字节的表示形式：110xxxxx 10xxxxxx
3个字节的表示形式：1110xxxx 10xxxxxx 10xxxxxx
4个字节的表示形式：11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

1.3 总结

ASCll字符集：只有英文、数字、符号等，占1个字节。
GBK字符集：汉字占2个字节，英文、数字占1个字节。
UTF-8字符集：汉字占3个字节，英文、数字占1个字节。

1.3.1 注意事项

字符编码时使用的字符集，和解码时使用的字符集必须一致，否则会出现乱码
英文，数字一般不会乱码，因为很多字符集都兼容了ASCll字符集编码。

例：“a我d”

使用GBK编码
- 0xxxxxx 1xxxxxxx xxxxxxxx 0xxxxxxx
如果使用UTF-8解码
- 0xxxxxx：以0开头，根据后面七位解码成a
- 1xxxxxxx：以1开头根据上面表格无匹配项，返回？
- xxxxxxxx：可能也没有匹配项，返回？
- 0xxxxxxx：以0开头，根据后面七位解码成d
- 最后解码为a??d

1.4 字符集的编码和解码

String提供的编码方法	说明
byte[ ] getBytes( )	使用平台的默认字符集将该String编码为字节数组
byte[ ] getBytes( String charsetName)	使用入参指定的字符集将该String编码为字节数组

String提供的解码方法（构造器）	说明
String( byte[ ] bytes )	使用平台的默认字符集将输入的字节数组解码为字符串
String( byte[ ] bytes, String charsetName)	使用入参指定的字符集将输入的字节数组解码为字符串

public class T2 {
    public static void main(String[] args) throws Exception {
        //字符串编码

        //1.使用平台的默认字符集将该String编码为字节数组
        //byte[ ] getBytes( )
        String s = "a你c";
        byte[] bytes1 = s.getBytes();
        System.out.println(Arrays.toString(bytes1));
        //[97, -28, -67, -96, 99]
        //第一个代表a的ASCII码，后面三个代表你的UTF-8编码，最后一个代表c的ASCII码
        //正常应该用二进制表示，这里自动转换成了十进制表示

        //2.使用指定的字符集将该String编码为字节数组
        //byte[ ] getBytes(String charsetName)
        byte[] bytes2 = s.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));
        //[97, -60, -29, 99]
        //GBK中ASCII码占一个字节，中文占两个字节
        //第一个代表a的ASCII码，后面两个代表汉字你的GBK编码，最后一个代表c的ASCII码

        //字符串解码

        //1.使用平台的默认字符集将字节数组解码为String
        //String(byte[] bytes)
        String s1 = new String(bytes1);
        System.out.println(s1);//a你c

        //2.使用指定的字符集将字节数组解码为String
        //String(byte[] bytes, String charsetName)
        String s2 = new String(bytes1, "GBK");
        System.out.println(s2);//a浣燾，因为编码与解码方式不同
        String s3 = new String(bytes2, "GBK");
        System.out.println(s3);//a你c，因为编码与解码方式相同
    }
}

2. IO流概述

2.1 IO流的概念

I指Input,称为输入流：负责把数据读到内存中去
O指Output,称为输出流：负责写数据出去

2.2 IO流的分类

字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中的流
字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中的流。
字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中的流。
字符输出流：以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中的流。

2.3 IO流的体系

3. 字节流（原始流）

适用于一切文件的文件的复制、转移；不适合读取中文内容输出。

3.1 字节输入流FileInputStream

作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。

3.1.1 构造器

构造器	说明
public FileInputstream(File file)	根据输入的File对象创建字节输入流管道与源文件接通
public FileInputstream(String pathname)	根据输入的路径创建字节输入流管道与源文件接通

public class Test1 {
    public static void main(String[] args) throws FileNotFoundException {
        
        //1.根据输入的File对象创建字节输入流管道与源文件接通
        //public FileInputstream(File file)
        File file = new File("src/a.txt");
        InputStream fis1 = new FileInputStream(file);
        
        //2.根据输入的字符串路径创建字节输入流管道与源文件接通(推荐使用)
        //public FileInputStream(String path)
        InputStream fis2 = new FileInputStream("src/a.txt");
    }
}

3.1.2 常用方法

常用方法	说明
public int read( )	每次读取一个字节返回，如果发现没有数据可读会返回-1
public int read(byte[ ] buffer)	每次用一个字节数组去读取数据，返回字节数组读取了多少个字节，如果发现没有数据可读会返回-1
public byte[ ] readAllBytes( )	直接将当前字节输入流对应的文件对象的字节数据装到一个字节数组返回

(1) 使用public int read( )每次读取单个字节（不推荐）

public class Test1 {
    public static void main(String[] args) throws Exception {
        //a.txt中的内容：abcddwadawdna我
        InputStream fis = new FileInputStream("src/a.txt");

        //每次读取一个字节
        //public int read( )
        //每次返回一个字节即八位二进制数，读取到文件末尾返回-1
        int temp;
        while ((temp = fis.read()) != -1){
            System.out.print((char) temp);//abcddwadawdnaæˆ‘
            //如果不使用(char)强制转换，输出的是八位的二进制数转换成的十进制数
            //不使用(char)强制转换的十进制数为
            // 97 98 99 100 100 119 97 100 97 119 100 110 97 230 136 145
        }
        
		/*
		public int read( )方法的缺点：
		*/
        //1.每次只能读取一个字节，效率低，因为需要频繁的读取磁盘，
        //  每读取一个字节就要读取一次磁盘
        
        //2.读取的如果是中文，会出现乱码，不可避免
        //因为使用UTF-8时一个中文占三个字节，而一个字节只能读取一个字节，
        //一个中文被强制拆分成三个字节，所以会出现乱码
        //上面的输出结果中230 136 145对应的二进制应该表示”我“，
        //但是被拆分成了三个字节分开读，导致了乱码æˆ‘
        
        //关闭流
        fis.close();
    }
}

缺点

每次只能读取一个字节，效率低，因为需要频繁的读取磁盘，假设读取30个字节，就要读取30次磁盘
读取的如果是中文，会出现乱码，不可避免，因为中文在任何编码规则下都不是一个字节

(2) 使用public int read(byte[ ] buffer)每次读取自定义数量的字节

public class Test2 {
    public static void main(String[] args) throws Exception {
        //a.txt中的内容：abcddw的ada哈哈哈wdna我
        InputStream inputStream = new FileInputStream("src/a.txt");

        //使用public int read(byte[ ] buffer)每次读取自定义数量的字节
        byte[] buffer = new byte[6];//每次读取6个字节，一个字节表示8位二进制数
        int len;//每次读取的字节数
        while ((len = inputStream.read(buffer)) != -1){
            String str = new String(buffer,0,len);
            System.out.print(str);
            //结果：abcddw的ada哈哈哈wdna我
        }
        inputStream.close();
    }
}

/*
	深度理解public int read(byte[ ] buffer)方法给byte数组赋值的机制
	如果读取的字节数达不到数组的长度，剩余长度的数组保持上次的值
	使用String的public String(byte[] bytes,int offset,int length)构造方法可以解决输出重复的问题
*/
public class Test4 {
    public static void main(String[] args) throws Exception {
        //a.txt中的内容：abcdefd
        InputStream inputStream = new FileInputStream("src/a.txt");
        //给byte数组赋值的机制是将读到的字节赋值给数组的每一个元素，
        // 但是如果读到的字节数不足数组长度时，剩余的元素不会被赋值，会保持上一次赋值的状态
        byte[] bytes = new byte[5];
        int len1 = inputStream.read(bytes);
        System.out.println(new String(bytes));//abcde
        System.out.println(len1);//5
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 100, 101]

        int len2 = inputStream.read(bytes);
        System.out.println(new String(bytes));
        //fbcde，后面的元素没有被赋值，保持上一次的状态
        System.out.println(len2);//2
        System.out.println(Arrays.toString(bytes));
        //[102, 100, 99, 100, 101]，后面的元素没有被赋值，保持上一次的状态

        //保证输出正确，不会输出重复内容的解决方案
        //每次根据获取到的字节长度创建用于解码的String对象
        System.out.println(new String(bytes,0,len2));//fd
        inputStream.close();
    }
}

优点：解决了每次读取单个文件时效率低的问题，读取性能得到了提升。因为原来读30个字节需要操作系统调用30次磁盘，现在则是根据传入数组的长度，如果数组长度为3，则调用10次磁盘即可，因为一次读取3个字节

缺点：中文乱码问题还是没有得到解决

(3) 一次读取文件中全部字节

方式一：使用public int read(byte[ ] buffer)，自定义数组长度为文件中数据的字节数
方式二：使用**public byte[ ] readAllBytes( )**直接返回所有的字节

public class Test3 {
    public static void main(String[] args) throws Exception {
        //a.txt的内容：abcddw的ada哈哈哈wdna我
        //一次读取所有字节

        //方式一：使用public int read(byte[ ] buffer)
        InputStream inputStream = new FileInputStream("src/a.txt");
        long size = new File("src/a.txt").length();
        //获取文件的大小，单位是字节
        byte[] buffer1 = new byte[(int) size];
        //创建一个和文件大小一样的字节数组
        int len = inputStream.read(buffer1);
        //将文件中的内容读取到字节数组中，返回值为读取到的字节数
        System.out.println(new String(buffer1));
        //将字节数组解码成字符串输出，使用默认的UTF-8解码
        //输出结果：abcddw的ada哈哈哈wdna我
        inputStream.close();

        //方式二：使用public byte[ ] readAllBytes( )直接返回所有的字节
        InputStream inputStream2 = new FileInputStream("src/a.txt");
        //必须重写定义一个FileInputStream对象，
        //因为上面的FileInputStream对象已经读取到文件末尾了，不能再读取了
        byte[] buffer2 = inputStream2.readAllBytes();//JDK9之后才有
        System.out.println(new String(buffer2));
        //将字节数组解码成字符串输出，使用默认的UTF-8解码
        //输出结果：abcddw的ada哈哈哈wdna我
        inputStream2.close();
    }
}

优点：读取速度得到了明显提升并且解决了读取中文乱码的问题

缺点：如果文件过大，就会导致创建的字节数组也会过大，可能会导致内存溢出

3.2 字节输出流FileOutputStream

作用：以内存为基准，把内存中的数据以字节的形式写出到文件中

3.2.1 构造器

构造器	说明
public FileOutputStream(File file)	创建字节输出流管道与源文件对象接通，默认会清空原来文件中数据
public FileOutputStream(String filepath)	创建字节输出流管道与源文件路径接通，默认会清空原来文件中数据
public FileOutputStream(File file, boolean append)	创建字节输出流管道与源文件对象接通，如果后面参数为true则允许追加数据，不会清空原有数据
public FileOutputStream(String filepath, boolean append)	创建字节输出流管道与源文件路径接通，如果后面参数为true则允许追加数据，不会清空原有数据

public class Test5 {
    public static void main(String[] args) throws Exception {
        //public FileOutputStream(String filepath)，会覆盖原文件，每次写入都会清空原文件
        OutputStream fo1 = new FileOutputStream("src\\B.txt");
        fo1.close();
        //public FileOutputStream(String filepath, boolean append)
        // 如果append为true则不会覆盖原文件，每次写入都会在原文件末尾追加
        OutputStream fo2 = new FileOutputStream("src\\B.txt", true);
        fo2.close();
    }
}

3.2.2 常用方法

方法	说明
public void write( int a )	写一个字节到硬盘指定位置
public void write( byte[ ] buffer )	写一个字节数组到硬盘指定位置
public void write( byte[ ] buffer, int pos , int len)	写一个字节数组的一部分到硬盘指定位置，pos为开始索引，len为要写入的长度

public class Test6 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("src\\B.txt", true);
        //常用方法
        //1.public void write(int b)：写入一个字节
        fo.write(97);
        fo.write('b');//'b'会被自动转为int类型，对应的ASCII码为98
        fo.write('哈');
        //'哈'会被自动转为int类型，但是有三个字节，所以只会写入第一个字节，会乱码
        //当前文件内容：：ab�

        //写入回车：\r\n
        fo.write("\r\n".getBytes());

        //2.public void write(byte[] b)：写入一个字节数组
        byte[] b1 = "一起传入就不会乱码了".getBytes();
        fo.write(b1);
        byte[] b2 = {98, 99, 'a'};
        fo.write(b2);
        fo.write("\r\n".getBytes());
        //当前文件内容：
        // ab�
        //一起传入就不会乱码了bca

        //3.public void write(byte[] b, int off, int len)：写入一个字节数组的一部分
        byte[] b3 = "一起传入就不会乱码了".getBytes();
        fo.write(b3, 0, 3);//写入前三个字节,也就是一个字，因为一个字在UTF-8中占三个字节
        //当前文件内容：
        // ab�
        //一起传入就不会乱码了bca一
        //一
        
        fo.close();
    }
}

3.2.3 案例：文件复制

将一张图片复制到磁盘的另一个位置

PS：下面的两个程序可以用于复制一切文件

//方法一
public class Test7 {
    public static void main(String[] args) throws Exception{
        // 读取图片为字节数组
        FileInputStream inputStream = new FileInputStream("E:\\Pictures\\Camera Roll" +
                "\\1.jpg");
        byte[] picture = inputStream.readAllBytes();
        // 将读取到的字节数组写入指定路径
        FileOutputStream outputStream = new FileOutputStream("src/1.jpg");
        outputStream.write(picture);
        outputStream.close();
        inputStream.close();
    }
}

//方法二
public class Test8 {
    public static void main(String[] args) throws Exception{
        FileInputStream inputStream = new FileInputStream("E:\\Pictures\\Camera Roll" +
                "\\1.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream("src/2.jpg");
        byte[] picture = new byte[1024];// 一次读取1024个字节即1KB
        int len;
        while ((len = inputStream.read(picture)) != -1) {
            fileOutputStream.write(picture, 0, len);
        }
        fileOutputStream.close();
        inputStream.close();
    }
}

3.2.4 资源释放的两种方案

目的：因为调用流的close( )方法在最后，如果中间代码出现异常会导致程序异常终止，close方法不会被执行，流无法被正常释放

（1）try-catch-finally

特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。

作用：一般用于在程序执行完成后进行资源的释放操作（专业级做法）

案例：使用try-catch-finally优化上面文件复制案例的代码**（优化后代码过于臃肿）**

//释放资源的标准写法
public class Test8 {
    public static void main(String[] args){
        FileInputStream is = null;
        FileOutputStream os = null;
        try {
            is = new FileInputStream("E:\\Pictures\\Camera Roll" +
                    "\\1.jpg");
            os = new FileOutputStream("src/2.jpg");
            byte[] picture = new byte[1024];// 一次读取1024个字节即1KB
            int len;
            while ((len = is.read(picture)) != -1) {
                os.write(picture, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
            if (os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
            if (is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

（2）try-with-resource

作用与try-catch-finally相同，只不过使代码更加简洁

资源对象：资源对象是指资源对象对应的类必须实现AutoCloseable接口并且重写close方法

try-with-resource格式

try(定义资源对象1，定义资源对象2...)
{
  方法体
}catch(){
    
}

注意：

try( )的括号中只能放置资源对象，即实现AutoCloseable接口并且重写close方法的类定义的对象
在资源使用完毕后，无论try中的代码是否出现异常，都会自动调用资源对象的close( )方法来完成对资源的释放

案例：再次改进try-catch-finally优化的代码，减少代码的臃肿

public class Test8 {
    public static void main(String[] args){
        try (
             FileInputStream is  = new FileInputStream("E:\\Pictures\\Camera Roll" +
                     "\\1.jpg");
             FileOutputStream os = new FileOutputStream("src/2.jpg");
             ){
            byte[] picture = new byte[1024];// 一次读取1024个字节即1KB
            int len;
            while ((len = is.read(picture)) != -1) {
                os.write(picture, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

自定义资源类

允许自定义资源类，只需要让类实现AutoCloseable接口并且重写close方法接口

//自定义资源类
public class resource implements AutoCloseable{
    public void use(){
        System.out.println("资源被使用了");
    }
    @Override
    public void close() {
        System.out.println("资源被关闭了");
    }
}

public class Test9 {
    public static void main(String[] args) {
        try(
            resource s = new resource();
        ){
            s.use();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
/*
输出结果：
        资源被使用了
        资源被关闭了
*/

4. 字符流（原始流）

适用于读写文件的内容

构造器与方法与字节流基本一致，但是由于每次读取到的是字符，所以不会出现乱码问题

相当于根据当前文件的编码方式读取字符

如果是UTF-8编码，则读取一个英文字符会返回一个字节即八位二进制数
读取一个中文字符会返回三个字节即24位二进制数，不会出现将3个字节拆分的问题，作为整体返回

4.1 字符输入流FileReader

作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。

4.1.1 构造器

构造器	说明
public FileReader(File file)	根据输入的File对象创建字符输入流管道与源文件接通
public FileReader(String pathname)	根据输入的路径创建字符输入流管道与源文件接通

4.1.2 常用方法

常用方法	说明
public int read( )	每次读取一个字符返回，如果发现没有数据可读会返回-1
public int read(char[ ] buffer)	每次用一个字符数组去读取数据，返回字符数组读取了多少个字符，如果发现没有数据可读会返回-1

public class Test1 {
    public static void main(String[] args) {
        //a.txt中的内容为：ab我的你打c打完了电脑defd
        try (
            Reader fileReader1 = new FileReader("src/a.txt");
            Reader fileReader2 = new FileReader("src/a.txt");
        ) {
            // 每次读取一个字符
            // public int read()
            // 每次返回一个字符，读取到文件末尾返回-1
            int temp;
            while((temp = fileReader1.read()) != -1){
                System.out.print((char) temp);
                //返回的是每个字符对应的十进制数，需要强制转换成char
                //结果：ab我的你打c打完了电脑defd
                //因为每次读取的是一个字符，所以不会出现乱码问题
            }
            System.out.println();

            // 每次读取一个字符数组
            // public int read(char[] buffer)
            // 每次返回读取到的字符个数，读取到文件末尾返回-1
            char[] buffer = new char[4];//每次读取四个字符
            int len;
            while ((len = fileReader2.read(buffer)) != -1){
                System.out.print(new String(buffer, 0, len));
                //输出结果：ab我的你打c打完了电脑defd
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4.2 字符输出流FileWriter

作用：以内存为基准，把内存中的数据以字符的形式写出到文件中

4.2.1 构造器

构造器	说明
public FileWriter(File file)	创建字符输出流管道与源文件对象接通，默认会清空原来文件中数据
public FileWriter(String filepath)	创建字符输出流管道与源文件路径接通，默认会清空原来文件中数据
public FileWriter(File file, boolean append)	创建字符输出流管道与源文件对象接通，如果后面参数为true则允许追加数据，不会清空原有数据
public FileWriter(String filepath, boolean append)	创建字符输出流管道与源文件路径接通，如果后面参数为true则允许追加数据，不会清空原有数据

4.2.2 常用方法

方法	说明
public void write( int a )	写一个字符到硬盘指定位置
public void write(String str)	写一个字符串到硬盘指定位置
public void write(String str, int off , int len)	写一个字符串的一部分到磁盘的指定位置
public void write( char[ ] buffer )	写一个字符数组到硬盘指定位置
public void write( char[ ] buffer, int off , int len)	写一个字符数组的一部分到硬盘指定位置，pos为开始索引，len为要写入的长度

public class Test2 {
    public static void main(String[] args) {
        try (
            Writer fileWriter = new FileWriter("src/b.txt")
            
            )
        {
            //常用方法

            //1.public void write(int c)，每次写入一个字符
            fileWriter.write(97);
            fileWriter.write('b');
            fileWriter.write('哈');//不会乱码，因为将三个字节打包为一个字符写入
            fileWriter.write("\r\n");//写入回车
            /*
            当前文件内容：ab哈
             */

            //2.public void write(String str)，每次写入一个字符串
            fileWriter.write("字符输出流！\r\n");
            /*
            当前文件内容：
                        ab哈
                        字符输出流！
             */

            //3.public void write(String str, int off, int len)，每次写入一个字符串一部分
            fileWriter.write("字符输出流！\r\n", 2, 6);
            //从索引为2的字符开始写入，写入3个字符
            /*
            当前文件内容：
                        ab哈
                        字符输出流！
                        输出流！
             */

            //4. public void write(char[] cbuf)，每次写入一个字符数组
            char[] chars = {'a', '我', 'c', 97, 'e','\r','\n'};
            fileWriter.write(chars);
            /*
            当前文件内容：
                        ab哈
                        字符输出流！
                        输出流！
                        a我cae
             */

            //5.public void write(char[] cbuf, int off, int len)，每次写入字符数组的一部分
            fileWriter.write(chars, 1, 3);//从索引为1的字符开始写入，写入3个字符
            /*
            当前文件内容：
                        ab哈
                        字符输出流！
                        输出流！
                        a我cae
                        我ca
             */
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2.3 注意事项（很重要）

字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

在调用write方法将数据写入磁盘，在遇到刷新流( public void flush( ) )或关闭流( public void close( ) )的方法前都会先将write传入的数据先放入缓冲区中，在遇到刷新流或关闭流的方法后才会调用系统的资源将缓冲区中的内容一次写入到磁盘中，这样做可以避免浪费系统资源，提高整体的性能。

刷新流与关闭流的区别

刷新流可以多次使用，每使用一次就将之前的缓冲区的内容写入磁盘中
关闭流包含刷新流操作，但是只能使用一次，使用后流关闭，无法再使用该流。

5. 缓冲流

作用：对原始流(字节流、字符流)讲行包装，通过减少磁盘调用量以提高原始流读写数据的性能

5.1 字节缓冲流BufferedInputStream/BufferedOutputStream

5.1.1 分类

字节缓冲输入流和字节缓冲输出流，分别用于包装字节输入流和字节输出流

5.1.2 作用

通过增加缓冲池减少调用磁盘的次数来提高字节流读写数据的性能

5.1.3 原理：

字节缓冲输入流相比于字节输入流自带了8KB缓冲池；
字节缓冲输出流相比于字节输入流也自带了8KB缓冲池。

5.1.4 原始字节流与字节缓冲流的原理对比

（1）原始字节流

（2）字节缓冲流

构造器

方法	说明
public BufferedInputStream( InputStream is )	把低级的字节输入流包装成一个高级的缓冲字节输入流，入参为字节输入流对象，继承了所有字节输入流的方法
public BufferedOutputStream( OutputStream os )	把低级的字节输出流包装成一个高级的缓冲字节输出流，入参为字节输出流对象，继承了所有字节输出流的方法

//原始的字节输入输出流拷贝数据的方法
public class Test8 {
    public static void main(String[] args){
        try (
             FileInputStream is  = new FileInputStream("E:\\Pictures\\Camera Roll" +
                     "\\1.jpg");
             FileOutputStream os = new FileOutputStream("src/3.jpg");
             ){
            byte[] picture = new byte[1024];// 一次读取1024个字节即1KB
            int len;
            while ((len = is.read(picture)) != -1) {
                os.write(picture, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//将原始的字节输入输出流包装成字节缓冲流后拷贝数据的方法
public class Test1 {
    public static void main(String[] args){
        try (
                FileInputStream is  = new FileInputStream("E:\\Pictures\\Camera Roll" +
                        "\\1.jpg");
                //包装成字节缓冲输入流
                BufferedInputStream bis = new BufferedInputStream(is);
            
                FileOutputStream os = new FileOutputStream("src/3.jpg");
                //包装成字节缓冲输出流
                BufferedOutputStream bos = new BufferedOutputStream(os);
                //BufferedOutputStream bos = new BufferedOutputStream(os,1024 * 16);
                //允许指定缓冲区大小，默认为8192，即8KB，上面自定义为16KB
        ){
            byte[] picture = new byte[1024];
            int len;
            //使用字节缓冲流对象代替原始字节流对象
            while ((len = bis.read(picture)) != -1) {
                bos.write(picture, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.2 字符缓冲流

5.2.1 字符缓冲输入流BufferedReader

（1）作用

包装字符输入流，继承了所有字符输入流的方法，自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能。

（2）原理

同字节缓冲输入流

（3）构造器与新增方法

构造器	说明
public BufferedReader( Reader r )	把低级的字符输入流包装成一个高级的缓冲字符输入流，入参为字符输入流对象，继承了所有字符输入流的方法

方法	说明
public String readLine( )	每次读取一行数据返回，如果没有数据可读了，会返回null

public class Test3 {
    public static void main(String[] args) {
        try (
                Reader re = new FileReader("src/a.txt");
                BufferedReader br = new BufferedReader(re)
        ){
            String line;
            //一次读一行
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

5.2.2 字符缓冲输出流BufferedWriter

（1）作用

包装字符输出流，继承了所有字符输出流的方法，自带8K的字符缓冲池，可以提高字符输出流向磁盘写字符数据的性能。虽然原始的字符输出流也自带了缓冲池，但是达不到8k的大小且不能自定义

（2）原理

同字节缓冲输出流

（3）构造器与新增的功能

构造器	说明
public BufferedWriter( Writer r )	把低级的字符输出流包装成一个高级的缓冲字符输出流，入参为字符输出流对象，继承了所有字符输出流的方法

方法	说明
public void newLine( )	换行写入

public class Test2 {
    public static void main(String[] args) {
        try (
                FileWriter fw = new FileWriter("src/b.txt");
                BufferedWriter bf = new BufferedWriter(fw)
        ) {
            bf.write("Hello World");
            bf.newLine();// 换行
            bf.write("Hello World");
            bf.write("ddd");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.2.3 案例：拷贝出师表到另一个文件，恢复顺序

需求：把《出师表》的文章顺序进行恢复到一个新文件中。

分析：

定义一个缓存字符输入流管道与源文件接通。
定义一个TreeSet集合存储读取的每行数据。
定义一个循环按照行读取数据，存入到TreeSet集合中去。
定义一个缓存字符输出管道与目标文件接通。
遍历TreeSet集合中的每个元素，用缓冲输出管道写出并换行。

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必能裨补阙漏，有所广益。
1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
4.将军向宠，性行淑均，晓畅军事，试用于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
9.今当远离，临表涕零，不知所言。
7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐托付不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。

public class Test3 {
    public static void main(String[] args) {

        try (
                BufferedReader br = new BufferedReader(new FileReader("src/c.txt"));
                BufferedWriter bw = new BufferedWriter(new FileWriter("src/d.txt"))
        ) {
            TreeSet<String> tree = new TreeSet<>();
            String line;
            while ((line = br.readLine()) != null) {
                tree.add(line);
            }
            for (String s : tree) {
                bw.write(s);
                bw.newLine();
            }
            System.out.println("拷贝成功");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6. 原始流与缓冲流性能对比（重点）

6.1 测试用例

分别使用原始的字节流，以及字节缓冲流复制一个很大视频。

6.2 测试步骤

使用低级的字节流按照一个一个字节的形式复制文件。（不使用，淘汰）
使用低级的字节流按照字节数组的形式复制文件。（通过改变数组长度可以实现高效率复制）
使用高级的缓冲字节流按照一个一个字节的形式复制文件。（不推荐使用）
使用高级的缓冲字节流按照字节数组的形式复制文件。

public class Test4 {
    private static final String COPY_PATH = "E:/TASHISHUI/长风渡/1.mp4";
    private static final String FINAL_PATH1 = "E:/TASHISHUI/长风渡/2.mp4";
    private static final String FINAL_PATH2 = "E:/TASHISHUI/长风渡/3.mp4";
    private static final String FINAL_PATH3 = "E:/TASHISHUI/长风渡/4.mp4";
    private static final String FINAL_PATH4 = "E:/TASHISHUI/长风渡/5.mp4";
    public static void main(String[] args) {
        //文件大小为1.5G
        //copy1();//特别慢，根本无法接受，淘汰
        copy2();//使用低级的字节流按照字节数组的形式复制文件耗时：6秒
        copy3();//使用字节缓冲流按照一个一个字节的形式复制文件耗时：4秒
        copy4();//使用字节缓冲流按照字节数组的形式复制文件耗时：1秒
        copy5();//使用低级的字节流按照字节数组的形式复制文件并更改数组大小为8kb耗时：1秒
    }

    public static void copy1() {
        long start = System.currentTimeMillis();
        try (
                FileInputStream is = new FileInputStream(COPY_PATH);
                FileOutputStream os = new FileOutputStream(FINAL_PATH1);
            ){
            int temp;
            while ((temp = is.read()) != -1) {
                os.write(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时："
                + (end - start)/1000 + "秒");
    }

    public static void copy2(){
        long start = System.currentTimeMillis();
        try (
                FileInputStream is = new FileInputStream(COPY_PATH);
                FileOutputStream os = new FileOutputStream(FINAL_PATH2);
            ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照字节数组的形式复制文件耗时："
                + (end - start)/1000 + "秒");
    }

    public static void copy3(){
        long start = System.currentTimeMillis();
        try (
                BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream(COPY_PATH));
                BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(FINAL_PATH3));
            ){
            int temp;
            while ((temp = bis.read( )) != -1) {
                bos.write(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用字节缓冲流按照一个一个字节的形式复制文件耗时："
                + (end - start)/1000 + "秒");
    }

    public static void copy4(){
        long start = System.currentTimeMillis();
        try (
                BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream(COPY_PATH));
                BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(FINAL_PATH4));
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用字节缓冲流按照字节数组的形式复制文件耗时："
                + (end - start)/1000 + "秒");
    }
    public static void copy5(){
        long start = System.currentTimeMillis();
        try (
                FileInputStream is = new FileInputStream(COPY_PATH);
                FileOutputStream os = new FileOutputStream(FINAL_PATH4);
        ){
            byte[] buffer = new byte[8192];
            int len;
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照字节数组的形式复制文件" + 
                           + "并更改数组大小为8kb耗时：" + (end - start)/1000 + "秒");
    }
}

7. 转换流

7.1 问题：不同编码读取出现乱码问题

如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码！
如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码！

public class Test1 {
    public static void main(String[] args) {
        //a.txt与b.txt文件内容相同，但是编码不同
        readSame();//txt文件使用UTF8编码，读取时使用UTF8编码
        /*
        使用UTF8编码
        ab我efd
        dwa单d
        dbrdb
        drgs
         */
        readDif();//txt文件使用GBK编码，读取时使用UTF8编码
        /*
        ʹ��GBK����
        ab��efd
        dwa��d
        dbrdb
        drgs
         */
    }

    public static void readSame() {
        try (
            Reader fr = new FileReader("src/a.txt");
            BufferedReader br = new BufferedReader(fr)
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void readDif(){
        try (
                Reader fr = new FileReader("src/b.txt");
                BufferedReader br = new BufferedReader(fr)
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7.2 字符输入转换流InputStreamReader

解决不同编码时，字符流读取文本内容乱码的问题
解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。

构造器	说明
public InputStreamReader( InputStream is )	把传入的原始的字节输入流，按照代码默认编码转成字符输入流（与直接用FileReader的效果一样）
public InputStreamReader( Inputstream is , String charset )	把传入的原始的字节输入流，按照指定字符集编码转成字符输入流（经常使用）

public class Test2 {
    public static void main(String[] args) {
        //默认使用UTF8编码，b.txt使用GBK编码
        try (
                //获取原始字节流
                InputStream is = new FileInputStream("src/b.txt");
                //将原始字节流转换为字符流，编码为GBK
                InputStreamReader isr = new InputStreamReader(is, "GBK");
                //将字符流包装为缓冲流
                BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/*
        使用GBK编码
        ab我efd
        dwa单d
        dbrdb
        drgs
 */

7.3 字符输出转换流OutputStreamWriter

7.3.1 问题引入

如何控制写出的字符使用指定的字符集编码？

使用String提供的getBytes方法

String data = "我爱你中国abd";
byte[] bytes = data.getBytes("GBK")

使用字符输出转换流

7.3.2 作用

作用：可以控制写出去的字符使用什么字符集编码。
解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

7.3.2 构造器

构造器	说明
public OutputstreamWriter( OutputStream os )	可以把原始的字节输出流，按照代码默认编码转换成字符输出流。
public OutputStreamWriter( OutputStream os , String charset )	可以把原始的字节输出流，按照指定编码转换成字符输出流（经常使用）

public class Test3 {
    public static void main(String[] args) {
        try (
              OutputStream os = new FileOutputStream("src/e.txt");
              OutputStreamWriter osw = new OutputStreamWriter(os, "GBK");
              BufferedWriter bw = new BufferedWriter(osw);
        ) {
            bw.write("我是中国人");
            bw.newLine();
            bw.write("我爱中国");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

8. 打印流PrintStream/PrintWriter

作用：打印流可以实现更方便、更高效的打印数据出去

PrintStream继承自字节输出流OutputStream,因此write方法只支持写字节类型数据出去
PrintWriter继承自字符输出流Writer,因此write方法支持写字符类型数据出去

8.1 PrintStream

构造器	说明
public PrintStream( OutputStream/File/String )	打印流直接通向字节输出流/文件/文件路径
public Printstream( String fileName, Charset charset )	可以指定写出去的字符编码
public PrintStream( Outputstream out, boolean autoFlush )	可以指定实现自动刷新
public PrintStream( Outputstream out, boolean autoFlush, String encoding )	可以指定实现自动刷新，并可指定字符的编码

方法	说明
public void println( Xxx )	打印任意类型的数据出去，并自动换行
public void write( int/byte[ ]/byte[ ]中的一部分 )	只支持写字节数据出去

public class Test1 {
    public static void main(String[] args) {
        try (
            PrintStream ps = new PrintStream("src/f.txt", Charset.forName("GBK"))
        ) {
            ps.println("普通字符串");
            ps.println(23);
            ps.write(88);
            //ps.write("d");//会报错，因为无法写入字符
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/*
        普通字符串
        23
        X
 */

8.2 PrintWriter

构造器	说明
public PrintWriter(Outputstream/Writer/File/String)	打印流直接通向字节输出流/文件/文件路径
public Printwriter(String fileName,Charset charset)	可以指定写出去的字符编码
public PrintWriter(Outputstream out/Writer,boolean autoFlush)	可以指定实现自动刷新
public Printwriter(Outputstream out,boolean autoFlush,String encoding)	可以指定实现自动刷新，并可指定字符的编码

方法	说明
public void println(Xxx)	打印任意类型的数据出去，并自动换行
public void write(int/String/char[ ]/…)	可以支持写字符数据出去

public class Test1 {
    public static void main(String[] args) {
        try (
            PrintWriter pw = new PrintWriter("src/f.txt", Charset.forName("GBK"))
        ) {
            pw.println("普通字符串");
            pw.println(23);
            pw.write(88);//88的ASCII码为X
            pw.write('\n');
            pw.write("d");//不会报错，因为PrintWriter的write方法允许写入字符
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/*
        普通字符串
        23
        X
        d
 */

补充：在原有内容的基础上追加数据

public class Test1 {
    public static void main(String[] args) {
        try (
            //需要使用低级流来指定追加，高级流不允许直接追加
            PrintWriter pw = new PrintWriter(new FileWriter("src/f.txt",true))
        ) {
            pw.println("新增");
            pw.println(23);
            pw.println('X');
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/*
        普通字符串
        23
        X
        d新增
        23
        X
 */

8.3 应用：输出语句的重定向

将输出到控制台的内容输出到文件中去

public class Test2 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        System.out.println("sda");
        try (
            PrintStream pw = new PrintStream("src/1.txt")
        ) {
            // 重定向输出流, 将输出流重定向到文件中
            System.setOut(pw);
            System.out.println("dasda");
            System.out.println("grng");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

9. 数据流

9.1 数据输出流DataOutputStream

将数据与数据类型一起写入到指定文件中，但是并不是给我们看的，只有使用DataInputStream才能看到写入的实际内容

构造器	说明
public DataOutputstream( OutputStream out )	创建数据输出流包装传入的基础的字节输出流

方法	说明
public final void writeByte( int v )	将byte类型的数据写入基础字节流对应的文件
public final void writeInt( int v )	将int类型的数据写入基础字节流对应的文件
public final void writeDouble( Double v )	将double类型的数据写入基础字节流对应的文件
public final void writeUTF( String str )	将字符串数据以UTF-8编码成字节写入基础字节流对应的文件
public void write(int/byte[ ]/byte[ ]的一部分)	将字节数据写入基础字节流对应的文件

public class Test1 {
    public static void main(String[] args) {
        try (DataOutputStream dos =
                     new DataOutputStream(new FileOutputStream("src/1.txt")))
        {
            dos.writeInt(10);
            dos.writeInt(-10);
            dos.writeLong(10L);
            dos.writeDouble(10.5);
            dos.writeUTF("中国");
            dos.writeChar('中');
            dos.writeBoolean(true);
            dos.writeByte(0x41);// A
            dos.writeShort(0x3a);// 58
            dos.writeChar('A');
            dos.writeFloat(10.5f);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

必须使用数据输入流来读取

9.2 数据输入流DataInputStream

读取数据输出流写入的数据

构造器	说明
public DataInputStream(InputStream is)	创建数据输入流包装传入的基础的字节输入流

方法	说明
Public final byte readByte( )	读取字节数据并返回
public final int readInt( )	读取int类型的数据并返回
public final double readDouble( )	读取double类型的数据并返回
public final String readUTF( )	读取字符串类型数据(UTF8)并返回
public int readInt( )/read(byte[ ])	读取字节数据

public class Test1 {
    public static void main(String[] args) {
        try (DataInputStream dis =
                     new DataInputStream(new FileInputStream("src/1.txt")))
        {
            System.out.println(dis.readInt());
            System.out.println(dis.readInt());
            System.out.println(dis.readLong());
            System.out.println(dis.readDouble());
            System.out.println(dis.readUTF());
            System.out.println(dis.readChar());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readByte());// A
            System.out.println(dis.readShort());// 58
            System.out.println(dis.readChar());
            System.out.println(dis.readFloat());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
/*
        10
        -10
        10
        10.5
        中国
        中
        true
        65
        58
        A
        10.5
 */

10. 序列化流

对象序列化：把Java对象写入到文件中去
对象反序列化：把文件里的Java对象读出来

10.1 对象字节输出流ObjectOutputStream

可以把Java对象进行序列化：把]ava对象存入到文件中去。

构造器	方法
public objectoutputstream( Outputstream out )	创建对象字节输出流，包装基础的字节输出流

方法	说明
public final void writeobject( object o )	将对象写入文件中

注意事项

对象想要进行序列化，必须在对象对应的实体类中实现接口（java.io.Serializable）
如果希望对象中的某个成员变量不参与序列化，需要将该成员变量使用transient修饰

//想要被序列化必须实现序列化接口
public class Student implements Serializable {
    private String name;
    private int age;
    private transient Double score;//使用transient关键字修饰的属性不会被序列化

    public Student() {
    }

    public Student(String name, int age, Double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

public class Test1 {
    public static void main(String[] args) {
        try (
               ObjectOutputStream oos = 
                        new ObjectOutputStream(new FileOutputStream("src/2.txt"))
        ){
            Student s1 = new Student("张三", 18, 99.9);
            oos.writeObject(s1);
            System.out.println("序列化成功");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

10.2 对象字节输入流ObjectInputStream

可以把]ava对象进行反序列化：把存储在文件中的]ava对象读入到内存中来。

构造器	说明
public objectInputstream( InputStream is )	创建对象字节输入流，包装基础的字节输入流

方法	说明
public final object readObject( )	读取对象字节输出流写到文件中的对象

public class Test2 {
    public static void main(String[] args) {
        try (
                ObjectInputStream ois =
                        new ObjectInputStream(new FileInputStream("src/2.txt"))
        ){
            Student s1 = (Student) ois.readObject();
            System.out.println(s1);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
//Student{name='张三', age=18, score=null} score没有被序列化

一次序列化多个对象

用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可

ArrayList集合已经实现了序列化接口

public class Test3 {
    public static void main(String[] args) {
        try (
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("src/2.txt"))
        ){
            List<Student> students = new ArrayList<>();
            Student s1 = new Student("张三", 18, 99.9);
            Student s2 = new Student("李四", 19, 98.9);
            Student s3 = new Student("王五", 20, 97.9);
            students.add(s1);
            students.add(s2);
            students.add(s3);
            oos.writeObject(students);
            System.out.println("序列化成功");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        try (
                ObjectInputStream ois =
                        new ObjectInputStream(new FileInputStream("src/2.txt"))
        ){
            List<Student> s1 = (List)ois.readObject();
            System.out.println(s1);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
//[Student{name='张三', age=18, score=null}, 
// Student{name='李四', age=19, score=null}, 
// Student{name='王五', age=20, score=null}]

11. 补充知识：IO框架

11.1 框架

解决某类问题，编写的一套类、接口等，可以理解成一个半成品，大多框架都是第三方研发的。
好处：在框架的基础上开发，可以得到优秀的软件架构，并能提高开发效率
框架的形式：一般是把类、接口等编译成class形式，再压缩成一个jar结尾的文件发行出去。

11.2 IO框架

封装了JAVA提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。

11.2.1Commons-io

Commons-io是apache开源基金组织提供的一组有关IO操作的小框架，目的是提高1O流的开发效率。

FileUtils类提供的部分方法	说明
public static void copyFile( File srcFile, File destFile )	复制文件
public static void copyDirectory( File srcDir,File destDir )	复制文件夹
public static void deleteDirectory(File directory)	删除文件夹，无论是否为空
public static String readFileTostring(File file, String encoding)	读数据
public static void writeStringToFile(File file, String data, String charname, boolean append)	写数据

IOUtils类提供的部分方法	说明
public static int copy( Inputstream inputstream,Outputstream outputstream )	字节流复制文件
public static int copy( Reader reader ,Writer writer )	字符流复制文件
public static void write(String data, OutputStream output, String charsetName)	写数据

（1）集合框架到项目中

搜索Commons-io，找到apach官网的下载路径，下载并解压

在项目的src下新建文件夹，起名为lib，并将commons-io-2.13.0.jar复制到lib中

在项目中右键该jar包，导入到项目中

（2）代码实例

public class test1 {
    public static void main(String[] args) throws IOException {
        // 复制文件,从a.txt到b.txt
        FileUtils.copyFile(new File("E:/A/a.txt"),new File("E:/A/b.txt"));
        // 复制文件夹，从A到B
        FileUtils.copyDirectory(new File("E:/A"),new File("E:/B"));
        //删除文件夹，无论文件夹是否为空
        FileUtils.deleteDirectory(new File("E:/B"));
        //向文件中写入数据
        FileUtils.writeStringToFile(new File("E:/A/a.txt"),"你好","UTF-8",true);
        //读取文件中数据
        String msg = FileUtils.readFileToString(new File("E:/A/a.txt"),"UTF-8");
        System.out.println(msg);
    }
}

public class Test2 {
    public static void main(String[] args) throws Exception {
        //字节流复制文件
        IOUtils.copy(new FileInputStream("E:/A/a.txt"),new FileOutputStream("E:/A/b.txt"));
        //字符流复制文件
        IOUtils.copy(new FileReader("E:/A/a.txt"),new FileWriter("E:/A/b.txt"));
        //向文件中写入数据
        IOUtils.write("HHHHH",new FileOutputStream("E:/A/a.txt"),"UTF-8");
    }
}

你可能感兴趣的:(黑马程序员JavaSE笔记,java)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
Enum用法不懂事的小屁孩 enum
以前的时候知道enum，但是真心不怎么用，在实际开发中，经常会用到以下代码: protected final static String XJ = "XJ"; protected final static String YHK = "YHK"; protected final static String PQ = "PQ";
【Spark九十七】RDD API之aggregateByKey bit1129 spark
1. aggregateByKey的运行机制 /** * Aggregate the values of each key, using given combine functions and a neutral "zero value". * This function can return a different result type
hive创建表是报错： Specified key was too long; max key length is 767 bytes daizj hive
今天在hive客户端创建表时报错，具体操作如下 hive> create table test2(id string); FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:javax.jdo.JDODataSto
Map 与 JavaBean之间的转换周凡杨 java 自省转换反射
最近项目里需要一个工具类，它的功能是传入一个Map后可以返回一个JavaBean对象。很喜欢写这样的Java服务，首先我想到的是要通过Java 的反射去实现匿名类的方法调用，这样才可以把Map里的值set 到JavaBean里。其实这里用Java的自省会更方便，下面两个方法就是一个通过反射，一个通过自省来实现本功能。 1：JavaBean类 1 &nb
java连接ftp下载 g21121 java
有的时候需要用到java连接ftp服务器下载，上传一些操作，下面写了一个小例子。 /** ftp服务器地址 */ private String ftpHost; /** ftp服务器用户名 */ private String ftpName; /** ftp服务器密码 */ private String ftpPass; /** ftp根目录 */ private String f
web报表工具FineReport使用中遇到的常见报错及解决办法（二）老A不折腾 finereport web报表 java报表总结
抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、没有返回数据集：在存储过程中的操作语句之前加上set nocount on 或者在数据集exec调用存储过程的前面加上这句。当S
linux 系统cpu 内存等信息查看墙头上一根草 cpu 内存 liunx
1 查看CPU 　　1.1 查看CPU个数　　# cat /proc/cpuinfo | grep "physical id" | uniq | wc -l 　　2 　　**uniq命令：删除重复行;wc –l命令：统计行数** 　　1.2 查看CPU核数　　# cat /proc/cpuinfo | grep "cpu cores" | u
Spring中的AOP aijuans spring AOP
Spring中的AOP Written by Tony Jiang @ 2012-1-18 （转）何为AOP AOP，面向切面编程。在不改动代码的前提下，灵活的在现有代码的执行顺序前后，添加进新规机能。来一个简单的Sample: 目标类： [java] view plain copy print ? package&nb
placeholder(HTML 5) IE 兼容插件 alxw4616 JavaScript jquery jQuery插件
placeholder 这个属性被越来越频繁的使用. 但为做HTML 5 特性IE没能实现这东西. 以下的jQuery插件就是用来在IE上实现该属性的. /** * [placeholder(HTML 5) IE 实现.IE9以下通过测试.] * v 1.0 by oTwo 2014年7月31日 11:45:29 */ $.fn.placeholder = function
Object类,值域,泛型等总结(适合有基础的人看) 百合不是茶泛型的继承和通配符变量的值域 Object类转换
java的作用域在编程的时候经常会遇到,而我经常会搞不清楚这个问题,所以在家的这几天回忆一下过去不知道的每个小知识点变量的值域; package 基础; /** * 作用域的范围 * * @author Administrator * */ public class zuoyongyu { public static vo
JDK1.5 Condition接口 bijian1013 java thread Condition java多线程
Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。条件（也称为条件队列或条件变量）为线程提供了一
开源中国OSC源创会记录 bijian1013 hadoop spark MemSQL
一.Strata+Hadoop World（SHW）大会是全世界最大的大数据大会之一。SHW大会为各种技术提供了深度交流的机会，还会看到最领先的大数据技术、最广泛的应用场景、最有趣的用例教学以及最全面的大数据行业和趋势探讨。二.Hadoop &nbs
【Java范型七】范型消除 bit1129 java
范型是Java1.5引入的语言特性，它是编译时的一个语法现象，也就是说，对于一个类，不管是范型类还是非范型类，编译得到的字节码是一样的，差别仅在于通过范型这种语法来进行编译时的类型检查，在运行时是没有范型或者类型参数这个说法的。范型跟反射刚好相反，反射是一种运行时行为，所以编译时不能访问的变量或者方法(比如private)，在运行时通过反射是可以访问的，也就是说，可见性也是一种编译时的行为，在
【Spark九十四】spark-sql工具的使用 bit1129 spark
spark-sql是Spark bin目录下的一个可执行脚本，它的目的是通过这个脚本执行Hive的命令，即原来通过 hive>输入的指令可以通过spark-sql>输入的指令来完成。 spark-sql可以使用内置的Hive metadata-store，也可以使用已经独立安装的Hive的metadata store 关于Hive build into Spark
js做的各种倒计时 ronin47 js 倒计时
第一种：精确到秒的javascript倒计时代码 HTML代码: <form name="form1"> <div align="center" align="middle"
java-37.有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接 bylijinnan java
public class MaxCatenate { /* * Q.37 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接， * 问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。 */ public static void main(String[] args){
mongoDB安装开窍的石头 mongodb安装基本操作
mongoDB的安装 1:mongoDB下载 https://www.mongodb.org/downloads 2:下载mongoDB下载后解压
[开源项目]引擎的关键意义 comsci 开源项目
一个系统，最核心的东西就是引擎。。。。。而要设计和制造出引擎，最关键的是要坚持。。。。。。现在最先进的引擎技术，也是从莱特兄弟那里出现的，但是中间一直没有断过研发的
软件度量的一些方法 cuiyadll 方法
软件度量的一些方法http://cuiyingfeng.blog.51cto.com/43841/6775/在前面我们已介绍了组成软件度量的几个方面。在这里我们将先给出关于这几个方面的一个纲要介绍。在后面我们还会作进一步具体的阐述。当我们不从高层次的概念级来看软件度量及其目标的时候，我们很容易把这些活动看成是不同而且毫不相干的。我们现在希望表明他们是怎样恰如其分地嵌入我们的框架的。也就是我们度量的
XSD中的targetNameSpace解释 darrenzhu xml namespace xsd targetnamespace
参考链接: http://blog.csdn.net/colin1014/article/details/357694 xsd文件中定义了一个targetNameSpace后，其内部定义的元素，属性，类型等都属于该targetNameSpace,其自身或外部xsd文件使用这些元素，属性等都必须从定义的targetNameSpace中找：例如：以下xsd文件，就出现了该错误，即便是在一
什么是RAID0、RAID1、RAID0+1、RAID5，等磁盘阵列模式? dcj3sjt126com raid
RAID 1又称为Mirror或Mirroring，它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半，因而，Mirror的磁盘空间利用率低，存储成本高。 Mir
yii2 restful web服务快速入门 dcj3sjt126com PHP yii2
快速入门 Yii 提供了一整套用来简化实现 RESTful 风格的 Web Service 服务的 API。特别是，Yii 支持以下关于 RESTful 风格的 API：支持 Active Record 类的通用API的快速原型涉及的响应格式（在默认情况下支持 JSON 和 XML) 支持可选输出字段的定制对象序列化适当的格式的数据采集和验证错误
MongoDB查询(3)——内嵌文档查询（七） eksliang MongoDB查询内嵌文档 MongoDB查询内嵌数组
MongoDB查询内嵌文档转载请出自出处：http://eksliang.iteye.com/blog/2177301 一、概述有两种方法可以查询内嵌文档：查询整个文档；针对键值对进行查询。这两种方式是不同的，下面我通过例子进行分别说明。二、查询整个文档例如:有如下文档 db.emp.insert({ &qu
android4.4从系统图库无法加载图片的问题 gundumw100 android
典型的使用场景就是要设置一个头像，头像需要从系统图库或者拍照获得，在android4.4之前，我用的代码没问题，但是今天使用android4.4的时候突然发现不灵了。baidu了一圈，终于解决了。下面是解决方案： private String[] items = new String[] { "图库","拍照" }; /* 头像名称 */
网页特效大全 jQuery等 ini JavaScript jquery css html5 ini
HTML5和CSS3知识和特效 asp.net ajax jquery实例分享一个下雪的特效 jQuery倾斜的动画导航菜单选美大赛示例你会选谁 jQuery实现HTML5时钟功能强大的滚动播放插件JQ-Slide 万圣节快乐！！！向上弹出菜单jQuery插件 htm5视差动画 jquery将列表倒转顺序推荐一个jQuery分页插件 jquery animate
swift objc_setAssociatedObject block(version1.2 xcode6.4) 啸笑天 version
import UIKit class LSObjectWrapper: NSObject { let value: ((barButton: UIButton?) -> Void)? init(value: (barButton: UIButton?) -> Void) { self.value = value
Aegis 默认的 Xfire 绑定方式，将 XML 映射为 POJO MagicMa_007 java POJO xml Aegis xfire
Aegis 是一个默认的 Xfire 绑定方式，它将 XML 映射为 POJO, 支持代码先行的开发.你开发服务类与 POJO,它为你生成 XML schema/wsdl XML 和注解映射概览默认情况下，你的 POJO 类被是基于他们的名字与命名空间被序列化。如果
js get max value in (json) Array qiaolevip 每天进步一点点学习永无止境 max 纵观千象
// Max value in Array var arr = [1,2,3,5,3,2];Math.max.apply(null, arr); // 5 // Max value in Jaon Array var arr = [{"x":"8/11/2009","y":0.026572007},{"x"
XMLhttpRequest 请求 XML,JSON ,POJO 数据 Luob. POJO json Ajax xml XMLhttpREquest
在使用XMlhttpRequest对象发送请求和响应之前，必须首先使用javaScript对象创建一个XMLHttpRquest对象。 var xmlhttp； function getXMLHttpRequest(){ if(window.ActiveXObject){ xmlhttp:new ActiveXObject("Microsoft.XMLHTTP
jquery wuai jquery
以下防止文档在完全加载之前运行Jquery代码，否则会出现试图隐藏一个不存在的元素、获得未完全加载的图像的大小等等 $(document).ready(function(){ jquery代码; }); <script type="text/javascript" src="c:/scripts/jquery-1.4.2.min.js&quo

11.IO流--黑马程序员

File、IO流

一、File

1. 概念

2. 构造器

2.1常用构造器

2.1.1 注意

2.2 路径分隔符写法

2.3 绝对路径与相对路径

3. 常用方法

3.1 判断文件类型、获取文件信息的方法

3.2 创建文件、删除文件的方法

3.3 遍历文件夹的方法

3.3.1 遍历当前File对象的一级目录的方法

3.3.2 遍历当前File对象的多级子目录的方法（递归）

（1）前置知识：递归

（2）遍历多级子目录案例1：搜索指定的文件

（3）遍历多级子目录案例2：删除非空文件夹

二、IO流

1. 前置知识

1.1 计算机存储单位

1.2 常见字符集

1.2.1 标准ASCII字符集（美国码）

1.2.2 GBK字符集（中国码）

1.2.3 Unicode字符集（统一码）

（1）UTF-32

（2）UTF-8(最常用)

1.3 总结

1.3.1 注意事项

例：“a我d”

1.4 字符集的编码和解码

2. IO流概述

2.1 IO流的概念

2.2 IO流的分类

2.3 IO流的体系

3. 字节流（原始流）

3.1 字节输入流FileInputStream

3.1.1 构造器

3.1.2 常用方法

(1) 使用public int read( )每次读取单个字节 （不推荐）

(2) 使用public int read(byte[ ] buffer)每次读取自定义数量的字节

(3) 一次读取文件中全部字节

3.2 字节输出流FileOutputStream

3.2.1 构造器

3.2.2 常用方法

3.2.3 案例：文件复制

3.2.4 资源释放的两种方案

（1）try-catch-finally

（2）try-with-resource

4. 字符流（原始流）

4.1 字符输入流FileReader

4.1.1 构造器

4.1.2 常用方法

4.2 字符输出流FileWriter

4.2.1 构造器

4.2.2 常用方法

4.2.3 注意事项（很重要）

5. 缓冲流

5.1 字节缓冲流BufferedInputStream/BufferedOutputStream

5.1.1 分类

5.1.2 作用

5.1.3 原理：

5.1.4 原始字节流与字节缓冲流的原理对比

（1）原始字节流

（2）字节缓冲流

构造器

5.2 字符缓冲流

5.2.1 字符缓冲输入流BufferedReader

（1）作用

（2）原理

（3）构造器与新增方法

5.2.2 字符缓冲输出流BufferedWriter

（1）作用

（2）原理

（3）构造器与新增的功能

5.2.3 案例：拷贝出师表到另一个文件，恢复顺序

6. 原始流与缓冲流性能对比（重点）

6.1 测试用例

6.2 测试步骤

7. 转换流

(1) 使用public int read( )每次读取单个字节（不推荐）