io流练习

1io基础练习

字节流

package org.IOsummary;

import javax.swing.*;
import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;

/**
 * 文件流:内存->文件,文件->内存的工具之一
 * 1.每种流怎么使用
 *
 */

public class TestIO {

    /**
     * 流的类型
     * 1. Output/InPut 类型的流，字节(byte)流 范围是 0000 0000 - 1111 1111  也就是0 - 255
     *          文件输入/输出流 FileOutputStream/FileInputStream
     *          对象输入/输出流  ObjectOutputStream/ObjectInputStream
     * 2. Read/Write 类型的流，字符(char)流 范围是 0000 0000 0000 0000 - 1111 1111 1111 1111  也就是 0 -65535
     *          读文件 Read    写文件  Write
     *          FileRead FileWrite
     *
     */

    /**
     * 常见操作
     *
     */

    /**
     * 文件字节流常见错误和异常
     * 创建流-- 初始化建立流对象
     *          文件不存在--自动创建吗？(不创建/尝试创建)--目录不存在异常
     *                  1.读文件时候不可能给你创建
     *                  2.写文件时：1.重名2.父目录
     *          是否追加
     *              1不追加会把文件清空，重新写
     *              2只存在写文件，读文件不会清空，除非你打开它了。
     *                      不仅读文件而且写文件，需要在文件读完之后，实例化写的流
     * 使用流--
     *          连续读，已经结束了,无意义但是不会出错
     * 刷新流
     *          1.刷新写入的流，有缓冲的不刷新不会写。
     *          2.读的时候，就不用了，操作的时候不会影响。
     * 关闭流
     *      1.有自动关闭，
     *      2.自动关闭会刷新流
     */
    public static void test0(){
        File file = new File("d:/notfound");
        try (FileInputStream fileInputStream = new FileInputStream(file)){

        }
        catch (FileNotFoundException e){
            System.out.println("文件没找到，不能为您创建");
            throw new RuntimeException(e);
        }
        catch (IOException e){
            System.out.println("文件写入异常");
            throw new RuntimeException(e);
        }
    }

    public static void test00(){
        File file = new File("d:/notfound");
        file.mkdirs();
        try(FileOutputStream fos = new FileOutputStream(file,true)){

        }
        catch (FileNotFoundException e){
            System.out.println("写入文件未找到，尝试为您创建失败");
        }
        catch (IOException e){

        }
        file = new File("d:/notfound/notfound");
        try(FileOutputStream fos = new FileOutputStream(file,true)){

        }
        catch (FileNotFoundException e){
            System.out.println("写入文件未找到，尝试为您创建失败");
            throw new RuntimeException(e);
        }
        catch (IOException e){

        }
    }
    public static void test000(){
        File file = new File("d:/iosummary/test000.txt");
        file.getParentFile().mkdirs();
        try {
            file.createNewFile();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try(FileOutputStream fos = new FileOutputStream(file,true)){
            byte[] bytes = "io流练习".getBytes(Charset.defaultCharset());
            fos.write(bytes);
            fos.write("你好！中国".getBytes());
            fos.write('\r');
            fos.write('\n');
            fos.write(98);
            fos.write('\r');
            fos.write('\n');
            fos.flush();//及时刷新写的流,不刷新它不会写入文件，文件是空的，这个会刷新是因为文件最后会关闭
        }
        catch (FileNotFoundException e){
            System.out.println("文件不存在，文件尝试创建失败");
        }
        catch (IOException e){
            System.out.println("写入文件异常");
        }

        try (FileInputStream fis = new FileInputStream(file)){
            //一个一个的读
            /**
             * 小知识
             * 为什么可以用short去存储int的-1，因为int里面的-1截一下也是short的-1
             * 即   -1  = 1111 1111 1111 1111 = 1111 1111 1111 1111 1111 1111 1111 1111
             * 同样 -2 = f f f e = 0xffff 0xfffe
             * 但是强制类型转换不推荐
             * 用int数据更大啊，一会可能有更多的字符
             */
            int flag;
            /*
             */
//            ArrayList<Byte> bytes = new ArrayList<>();//错了
            //必须用到 length  还需要类型转换
            byte[] bytes = new byte[(int)file.length()];
            //用for循环 i是计数器
            for (int i = 0 ,len;(len = fis.read())!=-1;i++){
                bytes[i] = (byte)(len);
            }
            //解码需要知道文件编码类型，当然了，就是我用java写的，它的类型就是默认类型，Charset.defaultCharset().name() UTF-8
//            System.out.println(new String(bytes,Charset.defaultCharset()));
//            int b = fis.read();可以继续读但是已经是文件结尾了
        }
        catch (FileNotFoundException e){
            System.out.println("文件不存在");
        }
        catch (IOException e){
            System.out.println("读文件失败");
        }

        //一次读一群
        try(FileInputStream fisInp = new FileInputStream(file)){
//            byte[] bytes = fisInp.readAllBytes();//全部读到,这个更好
            byte[] bytes = new byte[1024];
            int len;
            String str = "";
            while((len = fisInp.read(bytes))!=-1){
                //这种方式等同把文件分成多分，显然会有中文乱码
                //len是真实读的
//                str += new String(bytes,Charset.defaultCharset());
                str += new String(bytes, 0,len,Charset.defaultCharset());
            }
            System.out.println(str);
        }
        catch (FileNotFoundException e){}
        catch (IOException e){}
    }

    /**
     * 序列化练习
     * 1.确定是存储对象
     * 2.需要实现java.io.Serializable接口，添加序列号 private static final long serialVersionUID = 8683452581122892189L;
     *
     * 异常：名字应该是 类初始化异常
     * 本质原因：修改了类，之前存储的可能和这次修改有冲突
     * 1.序列号不对
     * 2.序列号对但是类型不对，类型没有
     *
     * 存储的时候一般是全部覆盖，
     * 一般是一个list集合，类似数据库表对象
     *
     * 一个原则：内存使用，外存存储
     */

    /**
     * 字符流
     * 问题：
     * 1.字符流和字节流不匹配
     *      1.在UTF-8编码中
     *              一个中文字符，对应1个字符，3个字节
     *      2.写的时候用GBK和UTF-8写出来的结果一样，
     *              不论哪种编码，写的时候都是"中国"就行
     *2.及时刷新
     *      1.关闭时自动刷新
     *
     */
    public static void test1(){
        File file = new File("d:/iosummary/test1.txt");
        file.getParentFile().mkdirs();
        try {
            file.delete();
            file.createNewFile();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try (FileWriter fw = new FileWriter(file,true)){
            byte[] temp = "中国".getBytes("GBK");
            byte[] temp2 = "河南省".getBytes("UTF-8");
            fw.write("中国");
            fw.write("\r\n河南省");
            fw.write("\r\n南阳市\r\n");
            fw.write(new String(temp,"GBK"));
            fw.write(new String(temp2,"UTF-8"));
//            fw.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try (FileReader fileInputStream = new FileReader(file)){
            while(fileInputStream.ready()){
                //这里需要类型转换一下 返回值同样是int类型 这里-1到0xffff -1不是一个实际字符
                System.out.print((char)fileInputStream.read());
            }
        }
        catch (FileNotFoundException e){

        }
        catch (IOException e){

        }
    }
    public static void test10(){
        File file = new File("d:/iosummary/test1.txt");
        try (FileInputStream fileInputStream = new FileInputStream(file)){
            byte[] bytes = fileInputStream.readAllBytes();
            System.out.println(new String(bytes,"UTF-8"));
            System.out.println(new String(bytes,"GBK"));
        }
        catch (FileNotFoundException e){

        }
        catch (IOException e){

        }
    }
    /**
     * 缓冲流
     * 1.添加了缓冲区的流
     * 2.同样close和flush二者必须选一个
     */
    public static void test2(){
        File file = new File("d:/iosummary/test2");
        file.getParentFile().mkdirs();
        try {
            file.createNewFile();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try(BufferedWriter writer = new BufferedWriter(new FileWriter(file))){
            //9*9 9*8
            //8*8
            for (int i = 9;i>0;i--){
                for (int j = i;j>0;j--){
                    writer.write(i+"*"+j+"="+i*j+"\t");
                }
                writer.newLine();
            }
        }
        catch (IOException e){

        }
        try(BufferedReader reader = new BufferedReader(new FileReader(file))){
            while(reader.ready()){
                System.out.println(reader.readLine());
            }
        }catch (FileNotFoundException e){

        }
        catch (IOException e){

        }
    }

    public static void test22(){
        File file = new File("d:/iosummary/test2");
        file.getParentFile().mkdirs();
        try {
            file.createNewFile();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(file));
            writer.write("123123123123".getBytes());
//            writer.flush();
//            writer.close();
        }catch (FileNotFoundException e){

        }
        catch (IOException e){}
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
            byte bytes[] = bis.readAllBytes();
            System.out.println(new String(bytes));
        }
        catch (FileNotFoundException e){

        }
        catch (IOException e){

        }
    }
    /**
     * 文件字节流
     */
    public static void main(String[] args) {
//        test0();
//        test00();
//        test000();
//        test1();
//        System.out.println("------------------------------------------------------");
//        test10();
//        test2();
        test22();
    }
}

2图片和图片流

2.1图片

package org.imgio;

/**
 * 建立某种格式的图片
 *  1.内存中创建（不管文件是否存在） == 实例化/其它
 *  2.在外存中保存
 */

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

/**
 * 基本图像格式
 * 图片流：BufferedImage类
 * RGB真彩图像 TYPE_INT_RGB
 * 灰色图像 TYPE_BYTE_GRAY
 * 透明画布 TYPE_INT_ARGB
 */

public class TextImageType {
    /**
     * 灰度图片
     * 需要文件类型支持灰度
     * 默认是黑色画布
     */
    public static void testGrey(){
        int width = 200;
        int height = 150;
        int type = BufferedImage.TYPE_BYTE_GRAY;
        BufferedImage img = new BufferedImage(width, height,type);
        try {
            ImageIO.write(img,"png",new File("GRAY.png"));
            ImageIO.write(img,"jpg",new File("GRAY.jpg"));
            ImageIO.write(img,"gif",new File("GRAY.gif"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * RGB真彩图片
     * 需要文件类型支持RGB
     * 默认是黑色画布
     */
    public static void testRGB(){
        int width = 200;
        int height = 150;
        int type = BufferedImage.TYPE_INT_RGB;
        BufferedImage img = new BufferedImage(width, height,type);
        try {
            ImageIO.write(img,"png",new File("rgb.png"));
            ImageIO.write(img,"jpg",new File("rgb.jpg"));
            ImageIO.write(img,"gif",new File("rgb.gif"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 透明画布
     * 需要文件类型支持ARGB
     * 默认是透明画布
     * jpg不支持，创建不了；返回值为false
     */
    public static void testARGB(){
        int width = 200;
        int height = 150;
        int type = BufferedImage.TYPE_INT_ARGB;
        BufferedImage img = new BufferedImage(width, height,type);
        //写入外存
        try {
            ImageIO.write(img,"png",new File("ARGB.png"));
            System.out.println(ImageIO.write(img, "jpg", new File("ARGB.jpg")));
            ImageIO.write(img,"gif",new File("ARGB.gif"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        testGrey();
        testARGB();
        testRGB();
    }
}

2.2画图基本操作

package org.imgio;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * 画一个图片
 * 新建（Draw1）和追加(Draw2)
 */

public class TestDrawImg {
    /**
     * 拷贝图片并添加文字
     *
     * 1.文件格式 1:RGB; 2:ARGB;10GREY
     * 2.内存默认图片格式
     * 3.拿到内存图片的画笔--画笔构造方法是保护的，我们不实例化
     * 4.使用画笔将另一个图片画入
     * 5.使用画笔将字符串画入
     *      可以设置字符串颜色，
     *         //new Color(156, 156, 156, 255);RGBA的值 A越大越不透明
     *         //new Color(255);  RGBA设置颜色 8位差分 前八位 透明度， 接着红色，绿色，蓝色
     *         其它颜色变为灰白色规则
     *              三个值相同，1-224都是灰色，但是值越小越接近黑色，值越大，越接近白色。
     *                  使用取色板可以取一下
     *
     * 6.将内存文件写入磁盘
     */
    public static void testDraw1(){
        File imgFile = new File ("pic\\day28/pic5.jpg");//目标文件
        BufferedImage img=null;
        int width=0,height=0;
        try {
            img = ImageIO.read(imgFile);
            width = img.getHeight();
            height = img.getWidth();
            System.out.println(width+" "+height);
        }
        catch (IOException e){
            throw new RuntimeException(e);
        }
        BufferedImage bufferedImage = new BufferedImage(width,height,10);//内存图片

        Graphics2D g = bufferedImage.createGraphics();

        g.drawImage(img, 0,0,null);

        Color color = new Color(120, 120, 120);
        g.setColor(color);
        g.drawString("13782557165",50,50);

        try {
            ImageIO.write(bufferedImage,"png",new File("./pic/day28/draw1.png"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 错误点
     * 1.读的时候认为文件不是图片，返回为null.
     *          错误代码：File file = new File("./pic/day28/pic.txt");File file = new File("./pic/day28/pic4.webp");
     * 2.路径不能写错，特别是相对路径
     *          当前目录是工作目录，也是项目目录，但是它不是java包路径 package
     *          错误代码：如果coding为打开目录 ../pic/day28/pic4.webp"错误
     *          反之如果day28为打开目录./pic/day28/pic4.webp错误
     * 3.不熟练
     * Graphics2D(绘图);bufferedImage(缓冲文件);ImageIO（图片输入输出）
     * 4.画的时候，彩色变为灰白色， 图片颜色变了，字体颜色变了
     */

    /**
     * 在源图片中添加水印
     * 1.将图片读入内存
     * 2.得到长宽属性
     * 3.得到画笔，
     * 4.设置画笔格式和颜色
     * 5.画字符串，
     * 6.保存
     */
    public static void testDraw2(){
        File file = new File("./pic/day28/pic.jpg");
        BufferedImage bufferedImage = null;
        try {
            bufferedImage = ImageIO.read(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        if(bufferedImage==null){
            System.out.println("图片不能识别，");
        }

        Graphics2D graphics2D = bufferedImage.createGraphics();

        String text = "版权所有 13782557165";

        Color color = new Color(233, 245, 230,255);

        //水印文字的坐标位置
        int weight = 100;
        int height = 200;
        //控制字体格式
        //系统中有的
        Font font = new Font("宋体",Font.BOLD,30);
        //保存字体设置
        graphics2D.setFont(font);
        //保存颜色设置
        graphics2D.setColor(color);

        graphics2D.drawString(text,weight,height);

        try{
            ImageIO.write(bufferedImage,"jpg",new File("./pic/day28/gt.jpg"));
        }
       catch (IOException e){

       }
    }
    /**
     * Draw1和Draw2比较
     * 相同点，都是图像处理，处理方法都差不多
     * 不同点，处理的文件不同。
     *      Draw1是在内存中新建图片，我们通过new实例化
     *      Draw2是读文件然后将内存地址拿到并赋值。
     *
     * 画图更加清晰了
     * 图片处理就是将图片读入内存，然后在存入外存。或者直接在内存中写，然后存入外存。
     */

    /**
     * 清除锯齿和文件定位
     */
    public static void testDraw3(){
        //缓冲图片和原图片
        File file = new File("./pic/day28/pic1.jpg");
        BufferedImage bufferedImage;
        try {
            bufferedImage = ImageIO.read(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        //画笔graphics
        Graphics2D graphics2D = bufferedImage.createGraphics();
        graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
        graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
        graphics2D.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,RenderingHints.VALUE_STROKE_DEFAULT);
        Map<RenderingHints.Key,Object> map = new HashMap<>();
//        Map<Object,Object> map = new HashMap<>();
//        map.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
//        map.put(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
//        map.put(RenderingHints.KEY_STROKE_CONTROL,RenderingHints.VALUE_STROKE_DEFAULT);
//        graphics2D.setRenderingHints(map);
        String text = "纸上得来终觉浅，绝知此事要躬行。";
        Color color = Color.RED;
        graphics2D.setColor(color);
        Font font = new Font("宋体",Font.BOLD,30);
        graphics2D.setFont(font);
        graphics2D.drawString(text,50,50);
        graphics2D.fillOval(200,200,100,100);
        graphics2D.drawOval(500,500,200,100);
        //目标图片
        try{
           ImageIO.write(bufferedImage,"jpg",new File("./Draw3.jpg"));
        }
        catch (IOException e){
            System.out.println("保存失败");
        }
    }

    public static void draw4(){
        BufferedImage bufferedImage = new BufferedImage(1000,1000,1);
        Graphics2D graphics2D = bufferedImage.createGraphics();
//        graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
//        graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
//        graphics2D.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,RenderingHints.VALUE_STROKE_DEFAULT);

        Map<RenderingHints.Key,Object> map = new HashMap<>();
        map.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
        map.put(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
        map.put(RenderingHints.KEY_STROKE_CONTROL,RenderingHints.VALUE_STROKE_DEFAULT);
        graphics2D.setRenderingHints(map);
        graphics2D.fillOval(100,200,200,300);
        graphics2D.setStroke(new BasicStroke(20f));
        graphics2D.setColor(getRandomRGB());
        graphics2D.drawOval(500,200,200,300);
        graphics2D.setColor(getRandomRGB());
        graphics2D.drawOval(550,200,200,300);
        graphics2D.setColor(getRandomRGB());
        graphics2D.drawOval(600,200,200,300);
        try {
            ImageIO.write(bufferedImage,"jpg",new File("draw4.jpg"));
        }catch (IOException e){

        }
    }
    /**
     * 易错点
     * Map map = new HashMap<>(); 和Map<RenderingHints.Key,Object> map = new HashMap<>();的区别
     *          1.前者是万能的，等同于Map<Object,Object>map = new HashMap<>();比较灵活，可放任何对象
     *          2.前者编译时不会提示类型不匹配
     *          3.前者是作为Object的实现类使用，后者是RenderingHints.Key的实现类使用
     *                  toString方法
     *                  RenderingHints.Key独有方法不知道啊  这里是独有方法
     *          4.如果不知道类型那么用前者，知道类型用后者较好。
     *          5.用泛型可以存储，可以表示数据结构
     *          6.这里不能用Object
     *
     */

    //得到一个随机RGBA颜色
    public static Color getRandomRGBA(){
        int red = (int)(Math.random()*256);
        int green = (int)(Math.random()*256);
        int blue = (int)(Math.random()*256);
        int alpha = (int)(Math.random()*256);
        return new Color(red,green,blue,alpha);
    }
    //得到一个随机RGB颜色
    public static Color getRandomRGB(){
        return new Color((int)(Math.random()*0x01000000));
    }
    /**
     * 随机性
     *  总而言之就是一个数据，
     *  前者是随机控制三原色，后者是随机值，后者不能做到三原色随机，但是也是随机颜色
     *  前者随机性更好
     */
    
    public static void main(String[] args) {
//        testDraw1();//复制图片
//        testDraw2();//在原图片上添加
//        testDraw3();
        draw4();
    }

}

2.3画图补充练习

 

package org.imgio;

import com.google.zxing.*;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.QRCodeReader;
import com.google.zxing.qrcode.QRCodeWriter;
import com.google.zxing.qrcode.encoder.QRCode;
import org.jsoup.Jsoup;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.*;
import java.util.List;

public class TestOther {
    /**
     * 描述：实现java程序自动打开文件
     * cmd start指令可以打开
     * 1.不能执行路径有空格的程序
     *
     * 直接写路径名的
     * 可运行的程序或批处理文件。
     */
    //用java程序自动打开百度网页

    /**
     * 不等于开机启动
     */
    public static void test() {
        //程序启动打开百度
        String url = "http://www.baidu.com";
        Runtime run = Runtime.getRuntime();
        //相当于在命令行输入 start指令
        //注意：空格分隔
        try {
//            run.exec("\"C:\\Program Files (x86)\\Tencent\\QQ\\Bin/qq.exe\"");
            run.exec("\"C:\\Program Files (x86)\\Tencent\\WeChat\\wechat.exe\"");
//            run.exec("\"C:\\Program Files (x86)\\Tencent\\WeChat\\微信.exe\"");//支持中文，必须是可执行和批处理
//            run.exec("cmd /k start http://www.baidu.com");
            run.exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" draw4.jpg");
            //只有火狐浏览器支持相对路径
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 文件资源定位符（文件没有放到网上，在我们本地）
     * file:///文件路径
     * file:///C:/Users/28700/Pictures/Saved%20Pictures/2054727.jpg 1是一个超链接，可以点击
     * 浏览器是帮我们补充了，类似还有 www.baidu.com
     */

    /**
     * Color颜色对象使用
     * 画图：可以控制画笔颜色画东西
     * 如画字符串，画图形，拷贝应该也是有颜色的(对应颜色转换)
     * 初始化
     * 颜色对象:代表了一个颜色
     * 使用某一种颜色（是一个对应的rgb常量）
     * RGB:第一个表示红色值是多少，第二个绿色值是多少，第三个蓝色值是多少
     * 1如果是红色，是 255，0，0；红色值满的是鲜红
     * 2如果是白色，是 255，255，255 特殊的颜色
     * 3如果是黑色，是 0，0，0 特殊的颜色
     * 4灰白色是三个值相等，不为0，0，0的颜色，值越小越接近黑色，值越大越接近白色
     * 5还有就是颜色合成，红+绿=黄色，红色绿色值越大黄色颜色会变深
     * RGBA：在RGB基础上添加了透明度
     * 1.A值越小越透明，
     * 2.用一个int表示 16位的更好操作
     * 3.前8位透明度 接着是红色 然后是绿色 最后是蓝色
     * <p>
     * 使用（设置颜色）
     */
    public static void testColor() {
        BufferedImage bufferedImage = new BufferedImage(1000, 1000, 1);
        Graphics2D graphics2D = bufferedImage.createGraphics();


        Color color = Color.WHITE;
        color = new Color(255, 255, 0);
        color = new Color(200, 200, 0);

        color = new Color(0, 0, 0, 0);
        color = new Color(0xff0000ff);
        graphics2D.setColor(color);
    }

    /**
     * 字体Font:
     * 画图的时候，需要画字符串，字符串就是字体内容，java通过设置字体格式控制画的字符串样式
     * 1.字体类型
     * 1.系统中的所有字体
     * 2.系统默认字体
     * 2.字体格式：0-2 常规(0),加粗(1)，斜体(2)， driveFont(int)
     * 3.字体大小 driveFont(float)
     * 默认字体样式，我们其实都是在修改样式
     * 加载外部字体（感觉有很多问题）
     * 文字控制--用一种系统字体就好了
     * 画布透明在网页上不会把背景给挡着
     * 还有就是有些外部字体不能表示所有中文
     * 初始化Font时候字体大小是int类型，但是deriveFont类型是int，大小是float 小建议就是 类型用byte 大小是int; 这就是设计好的
     */
    public static void testFont1() {
        //灰度图片--背景黑色，颜色默认白色
        BufferedImage bufferedImage = new BufferedImage(1000, 1000, 10);
        //        Graphics2D graphics2D = bufferedImage.getGraphics();
        Graphics2D graphics2D = bufferedImage.createGraphics();
//普通画笔设计
        Color color = new Color(233, 245, 230);
        graphics2D.setColor(color);

        graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        String text = "系统字体";
        //字体的横纵坐标x,y 不归字体管，实际是画笔管
        int x = 30, y = 30;
        graphics2D.drawString(text, x, y);

        //控制字体效果
        Font font = new Font("楷体", Font.ITALIC, 30);

        //画笔设置字体样式
        graphics2D.setFont(font);

        graphics2D.drawString(text, 100, 100);
        //保存
        try {
            ImageIO.write(bufferedImage, "png", new File("other.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" " + "other.png");
        } catch (IOException e) {
            System.out.println("内存写入磁盘异常");
            throw new RuntimeException(e);
        }
    }

    public static void testFont2() {
        BufferedImage bufferedImage = new BufferedImage(1000, 1000, 10);
        Graphics2D graphics2D = bufferedImage.createGraphics();
        Color color = new Color(233, 245, 230);
        graphics2D.setColor(color);
        graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        String text = "外部字体";
        int x = 30, y = 30;
        graphics2D.drawString(text, x, y);
        //建立加载外部文件
        Font font = null;
        try {
            //设置真显格式支持TTF字体文件
            //真显格式:
            font = Font.createFont(Font.TRUETYPE_FONT, new File("./font/经典楷体简.TTF"));
            //控制字号-- 也可以用样式（3个值） --- font自己本身不变，拷贝
            font = font.deriveFont(30f);
            font = font.deriveFont(1);
        } catch (FontFormatException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        graphics2D.setFont(font);
        graphics2D.setColor(color);
        graphics2D.drawString(text, 100, 100);
        try {
            ImageIO.write(bufferedImage, "png", new File("other.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" " + "other.png");
        } catch (IOException e) {
            System.out.println("内存写入磁盘异常");
            throw new RuntimeException(e);
        }
    }

    /**
     * 1.拿到字体样式的高，字符串的长度
     * 使用FontMetrics类 并不是我们实例化的，是画笔实例化的
     * getFontMetrics() 类似 createGraphics()
     * 获取字符串的宽度 stringWidth
     * 获取字体的高度 getAscent
     * 注意：避免字符串太长了：只有一行的
     * 2、字符串定位规则。
     * 1.是在左下角的位置开始画字符串
     * (0.0)开始字体会写在画的上方
     * 2.水平坐标增加是向右移动；垂直坐标增加是向下移动；坐标轴比较特殊
     * 案例：
     * 水平居中：(imgWidth-stringWidth)/2 , (imgHeight+fontHeight)/2
     * 右下角位置 imgWidth - stringWidth -10  , imgHeight -10;
     * 左上角位置 10 , fontHeight +10
     */
    public static void testFont3() {
        //画布宽高
        int imgWidth = 600;
        int imgHeight = 220;
        //几个字 没有用
        int len = 3;
        BufferedImage img = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_ARGB);
        Graphics2D pen = img.createGraphics();
        Font font = new Font("楷体", 1, 30);
        Color c = new Color(0x0fffafef);
        pen.setColor(c);
        pen.setFont(font);
        String text = "刘高源";

        //从画笔对象中获得指定的font对象的FontMetrics
        FontMetrics fm = pen.getFontMetrics(font);

        //获得字符串宽度
        int stringWidth = fm.stringWidth(text);
        //搞定水平居中
        // +imgwidth/2（画布中间）
        //减少 stringWidth/2  字符串开始
        int x = imgWidth / 2 - stringWidth / 2;
        x = (imgWidth - stringWidth) / 2;

        //获得字符串高度--这并不是字符串高度
        int fontHeight = fm.getAscent();
        //水平居中
        int y = (imgHeight - fontHeight) / 2;
        //发现偏移的不对，

        y = imgHeight / 2;

//        pen.drawString(text,x,y);
        //找到中间位置
        pen.setColor(new Color(0));
        //两点确定一条直线
        //水平中间线
        pen.drawRect(0, imgHeight / 2 + 1, imgWidth, imgHeight / 2 + 1);
        //在水平线上方，说明高度有点低
        y = imgHeight / 2 + fontHeight;
//        pen.drawString(text,x,y);

        //恰好发现直线就是对称线下方
        y = imgHeight / 2 + 1 + fontHeight / 2;
        y = (imgHeight + fontHeight) / 2;

        //中间
        pen.setColor(c);
//        pen.drawString(text,x,y);
        //右下角
        x = imgWidth - fm.stringWidth(text) - 10;
        y = imgHeight - 10;
        pen.drawString(text, x, y);
        //左上角
        x = 10;
        y = fontHeight + 10;
        pen.drawString(text, x, y);

        //使用一下Height测试英文 发现 相对于Ascent , Height太大了
        //英文相对汉字偏下一些
        fontHeight = fm.getHeight();
        text = "张三abcdefg";
        stringWidth = fm.stringWidth(text);
        x = (imgWidth - stringWidth) / 2;
        y = (imgHeight + fontHeight) / 2;
        pen.drawString(text, x, y);
        //结果 getHeight也控制不了英文
        try {
//            ImageIO.write(img,"png","drawfont3.png");
            ImageIO.write(img, "png", new File("drawfont3.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" drawfont3.png");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 所有系统字体
     */
    public static List getSystemFont() {
        java.util.List<String> list = new ArrayList<>();
        GraphicsEnvironment e = GraphicsEnvironment.getLocalGraphicsEnvironment();
        for (Font font : e.getAllFonts()) {
            list.add(font.getName());
        }
        return list;
    }


    /**
     * 实战：二维码基础
     * 一、写二维码
     * 功能
     * 1.将字符串变为图片：看一下字符串内容
     * 2.将网址变为图片：访问网址(地址)--这个需要联网
     * 3.将tel变为图片：打电话
     * 4。.apk扫码下载
     * 特点：
     * 1.不同的应用扫码结果不同，因为关系到他们的规划，总而言之二维码本质就是字符串
     * 2.怎么生成二维码
     * 导入google二维码组件（模块依赖）jar,
     * 导入类QRCodeWriter并实例化对象
     * 实例化类的encode方法能将字符串编成一个图片存起来
     * 24,10 10:40
     *
     * 生成二维码方法步骤：
     * 设置二维码内容（可以是中文）  String
     * 设置编码样式Map集合  Map<EncodeHintType,String>
     * 得到编码  BitMatrix（位矩阵）   QRCodeWriter().encode方法
     * 将编码变为图片   MatrixToImage的toBufferedImage 将 位矩阵变为 图片BufferedImage
     * 将图片存入外存/输出
     * 其它问题：
     * 1.中文乱码
     * 2.二维码不在乎颜色，有检错，有3个角，矩阵Matrix
     */
    public static void testQr() {
        //二维码内容
        String homePage = "http://192.168.16.13:8080/liu11/2054232.jpg";
        try {
            BitMatrix bitMatrix = new QRCodeWriter().encode(homePage, BarcodeFormat.QR_CODE, 400, 400, null);
            BufferedImage img = MatrixToImageWriter.toBufferedImage(bitMatrix);
            ImageIO.write(img, "png", new File("qr.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" qr.png");
        } catch (WriterException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {

        }
    }

    public static void testQr2(){
        //中文乱码;底层是byte[]
        String chinese = "姓名：刘高源";
        Map<EncodeHintType,String> hints = new HashMap<>(1);
        hints.put(EncodeHintType.CHARACTER_SET,"utf-8");
        try {
            BitMatrix bitMatrix = new QRCodeWriter().encode(chinese,BarcodeFormat.QR_CODE,400,400,hints);
            BufferedImage img = MatrixToImageWriter.toBufferedImage(bitMatrix);
            ImageIO.write(img,"png",new File("liugaoyuan.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" liugaoyuan.png");
        }
        catch (WriterException e) {

        }
        catch (IOException e) {

        }
    }
    public static void testQr3(){
        String tel = "tel://13782557165";
        try {
            BitMatrix bitMatrix = new QRCodeWriter().encode(tel,BarcodeFormat.QR_CODE,400,400);
            BufferedImage img = MatrixToImageWriter.toBufferedImage(bitMatrix);
            ImageIO.write(img,"png",new File("tel.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" tel.png");
        }
        catch (WriterException e) {

        }
        catch(IOException e){

        }
    }


    //二、二维码解析==读二维码
    //检查一个图里面有没有二维码
    public static void testQr4(){
        try {
//            BufferedImage img = ImageIO.read(new File("draw31.jpg"));
            BufferedImage img = ImageIO.read(new File("qrthree.png"));
//            BufferedImage img = ImageIO.read(new File("draw3.txt"));
//            BufferedImage img = ImageIO.read(new File("draw3.jpg"));
            BufferedImageLuminanceSource source = new BufferedImageLuminanceSource(img);
            //二进制解析器
            HybridBinarizer hybridBinarizer = new HybridBinarizer(source);
            BinaryBitmap bitmap = new BinaryBitmap(hybridBinarizer);
            Result result = new QRCodeReader().decode(bitmap);
            if (result.getText()!=null){
                System.out.println(result.getText());
            }
            else{
                System.out.println("没有找到二维码");
            }
        }
        catch (IOException e) {
            System.out.println("没有此文件，文件非图片不可读");
            throw new RuntimeException(e);
        } catch (ChecksumException e) {
            System.out.println("图片中二维码数量过多");
            throw new RuntimeException(e);
        } catch (NotFoundException e) {
            System.out.println("图片中没有找到二维码");
            throw new RuntimeException(e);
        } catch (FormatException e) {
            System.out.println("图片中没有二维码3");
            throw new RuntimeException(e);
        }
    }

    public static void test11(){
        //将多张个图片和成一个
        BufferedImage image = new BufferedImage(1000,1000,2);
        try {
            BufferedImage img = ImageIO.read(new File("liugaoyuan.png"));
            Graphics2D pen = image.createGraphics();
            pen.drawImage(img, 0,0,400,400, null);
            img = ImageIO.read(new File("qr.png"));//这个位置的二维码先被识别
            pen.drawImage(img, 450,0,400,400, null);
            img = ImageIO.read(new File("tel.png"));
            pen.drawImage(img, 0,450,400,400, null);
            ImageIO.write(image,"png",new File("qrthree.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" qrthree.png");
        }
        catch (IOException e) {
            System.out.println("文件没有找到，文件读失败");
        }
    }
    /**
     * 错误点，
     * 读的图片和写的是同一个，造成问题。
     * 正确做法应该新建一个图片
     */

    /**
     * 思路：编写一个二维码工具类，getQrCode()方法实现生成二维码
     *
     * 如何让别人扫描访问自己的电脑资源
     * 1.自己建服务器 java18可以，tomcat可以，内部都有服务器
     *      java18 代码 jwebserver -b 0.0.0.0 -p 80
     * 2.别人和你在同一个局域网，或者都连接了互联网，WiFi热点等能访问你
     *
     * 3.资源部署到服务器的网上
     *          资源的路径是c:/share/share.png。服务器应该在share/c盘上部署
     *
     */
    public static void getQrCode(int w,int h,String text){
        File file = new File("c:/share/myshare.png");
        if (!file.getParentFile().isDirectory()){
            file.getParentFile().mkdirs();
        }
        //支持中文
        Map<EncodeHintType,String> hints = new HashMap<>();
        hints.put(EncodeHintType.CHARACTER_SET,"UTF-8");
        try {
            BitMatrix bitMatrix =new QRCodeWriter().encode(text,BarcodeFormat.QR_CODE,w,h,hints);
            BufferedImage image = MatrixToImageWriter.toBufferedImage(bitMatrix);

            ImageIO.write(image,"png",file);
            Runtime.getRuntime().exec(" \"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" "+file.getAbsolutePath());
        }
        catch (IOException e){

        }
        catch (WriterException e){

        }


    }
    /**
     * 输入然后生成相应翻译图片
     * 1.二维码内容过多太密集可能无法表达
     * 2.在电脑上上输入，手机扫描，有点不方便
     */

    public static void getInfo(){
        String w = JOptionPane.showInputDialog("请输入词汇");
        String u = String.format("https://youdao.com/w/eng/%s/#keyfrom=dict2.index",w);

        try {
            String t = Jsoup.connect(u).get().select("div[class=trans-container]").get(0).text();
            System.out.println(w+":"+t);
            //翻译结果生成二维码：
            getQrCode(400,400,w+":"+t);
        }
        catch (Exception e){
            e.printStackTrace();
        }

    }

    /**
     * 实战：验证码基础
     * 验证码原理：
     * 功能：为了防止网络暴力破解
     * 一闪一闪的，多张图片合成的
     *      人都容易看错的验证码，好的验证码
     *      难度级别随意调
     * 验证码是通过会话机制走的，每个人每次登陆都不同，都需要验证
     *
     * 思路：建立一个图像，随机写一个字符串，图片保存下来，
     * （将图片的字符串，保存到session会话中，和表单提交的验证码验证）
     *
     * 得到图像属性:宽高字体个数，一个字体宽度，字体高度
     * 一个一个随机输出字体，应该保证一定顺序（之后验证）
     */
    public static void testcoding(){
        String letter = "abcdefghijklmnopqrstuvwsyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        int imgWidth = 160;
        int imgHeight = 60;
        int len= 4;
        BufferedImage img = new BufferedImage(160,60,2);

        Graphics2D pen = img.createGraphics();

        FontMetrics metrics = pen.getFontMetrics();
        int sh = metrics.getAscent();
        int sw = metrics.stringWidth("a");
        String text;
        int width = imgWidth/len;
        pen.setFont(new Font("",1,30));
        for (int i = 0,x = 20;i<len;i++){
            int y = (int)(Math.random()*(imgHeight-sh)) + sh +5;
            text = String.valueOf( letter.charAt((int)(Math.random()*62)));
            pen.setColor(new Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*100)+100));
            pen.drawString(text,x,y);
            System.out.print(text);
            x+=width;
        }
        //添加干扰
        int l = 50;
        for (int i = 0,x,y;i<l;i++){
            x = (int)(Math.random()*(imgWidth));
            y = (int)(Math.random()*(imgHeight));
            text = String.valueOf( letter.charAt((int)(Math.random()*62)));
            pen.setColor(new Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*50)));
            pen.setFont(new Font("楷体",2,(int)(Math.random()*20)));
            pen.drawString(text,x,y);
        }
        //添加正弦干扰线,弯曲的线
        //在字体后面添加会覆盖字体，增加识别难度
        //斜率不同 根据图片高度控制这里0-1合适
        boolean flag = true;
        pen.setColor(new Color(0xff543));
        pen.setStroke(new BasicStroke(5f));
        for (int x=0,y = imgHeight/2,k;x<imgWidth;){
            k = (int)(Math.random()*(2));
            if (flag){
                pen.drawLine(x,y,x+1,y-=k);
                y-=2*k;
                if (y<imgHeight/4){
                    flag = false;
                }
            }
            else{
                pen.drawLine(x,y,x+1,y+=k);
                y+=2*k;
                if (y>imgHeight/4 *3){
                    flag = true;
                }
            }
            x+=2;
        }
        try {
            ImageIO.write(img,"png",new File("coding1.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" coding1.png");
        }
        catch(IOException e){
            System.out.println("IO异常");
        }
    }
    /**
     * 锦上添花：
     * 1.字体的颜色，字体的样式容易忘记设置
     *          1.是每次随机（每个字都可能不同）还是都一样（每个字都一样）
     *
     * 2.干扰
     *       1.添加字体
     *       2.选择某种颜色的字体
     *       3.干扰线
     *
     * 3.提示我说Math.random可以取到0，并且获得随机整数应该用Random
     */

    /**
     * 基本图形
     * 1.图形类型
     * 基础图形：
     * 矩形：rect->正方向，边框
     * 椭圆：oval->圆
     * 直线：line->对角线（斜率），虚线
     * 进阶图形
     * roundRect->圆，椭圆
     * arc->圆，扇形，椭圆
     * 2.图形颜色
     * 就是通过画笔颜色
     * 3.粗细
     * BasicStroke对象
     * 4.定位
     *      1.左上角开始
     *      2.width，height是图形宽高
     *      3.中心位置公式 （x+width/2,y+height/2）
     * 5.填充(fill)/不填充(draw)
     */
    public static void testFigures() {
        int imageWidth = 660;
        int imageHeight = 220;
        BufferedImage img = new BufferedImage(imageWidth, imageHeight, 2);
        Graphics2D pen = img.createGraphics();

        Color c = new Color(0xffaaaafa);

        int k = imageWidth / (imageHeight);
        int x = 0, y = 0;
        //多条线组成的实线
        for (;x<imageWidth&&y<imageHeight;){
            pen.drawLine(x,y,x+k,y+1);
            x+=k;
            y++;
        }
//        //虚线过度
//        for (int i =1;x<imageWidth&&y<imageHeight;i++){if ((i&1)==1){System.out.println(i);pen.drawLine(x,y,x+k,y+1);}x+=k;y++;}
        x = imageWidth;
        y = 0;
        while (x>0&&y<imageHeight) {
            pen.drawLine(x, y, x - k, y + 1);
            x -= 2 * k;
            y += 2;
        }

        //矩形
        //位置:是在左上角开始
        pen.fillRect(0, 0, 50, 50);
        pen.fillRect(50, 50, 50, 50);

        //不填充
        pen.drawRect(100, 0, 50, 50);

        //圆
        pen.drawOval(150, 50, 50, 50);
        pen.fillOval(200, 0, 50, 50);
        //椭圆
        pen.fillOval(250, 50, 25, 50);
        pen.fillOval(300, 0, 50, 25);

        //圆角矩形
        //可以画椭圆和圆
        pen.drawRoundRect(350, 50, 50, 25, 50, 25);
        pen.fillRoundRect(400, 0, 50, 50, 50, 50);
        pen.fillRoundRect(450, 50, 50, 25, 50, 24);

        //设置线条粗细(宽度)
        BasicStroke bs = new BasicStroke(15f);
        pen.setStroke(bs);
        pen.drawRoundRect(500, 0, 50, 25, 50, 25);
        //没有消除棱角
        try {
            ImageIO.write(img, "png", new File("Figures.png"));
            Runtime.getRuntime().exec("\"C:/Program Files/Mozilla Firefox/firefox.exe\" Figures.png");
        } catch (IOException e) {

        }
    }
    /**
     * 双鱼线实战
     * 1.后面的可以将前面的替代了
     * 2.开始并不是圆心
     *         圆心坐标公式（x+width/2,y+height/2） 所以开始坐标小一点
     *         公式还适用于其它规则图形
     * 3.设置背景颜色:也是自己画的
     */
    public static void fish() {
        int imageWidth = 800;
        int imageHeight = 800;
        BufferedImage img = new BufferedImage(imageWidth, imageHeight, 2);
        Graphics2D pen = img.createGraphics();
        //抗锯齿平滑
        pen.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        pen.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
        pen.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_DEFAULT);

        Color color = Color.YELLOW;
        pen.setColor(color);
        pen.fillRect(0,0,800,800);
        Color white = Color.WHITE;
        Color black = Color.black;

        pen.setColor(black);
        pen.fillArc(0,0,800,800,-90,-180);
        pen.setColor(white);
        pen.fillArc(0,0,800,800,-90,180);
        pen.setColor(black);
        pen.fillArc(200,0,400,400,-90,180);
        pen.setColor(white);
        pen.fillArc(200,400,400,400,-90,-180);
        pen.fillArc(350,150,100,100,0,360);
        pen.setColor(black);
        pen.fillArc(350,550,100,100,0,360);

        try {
            ImageIO.write(img, "png", new File("fish.png"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" fish.png");
        } catch (IOException e) {

        }
    }
    

    public static void main(String[] args) {
//        test();
//        System.out.println(getSystemFont());
//        testFont1();
//        testFont2();
//        testFont3();
//        testFigures();
//        fish();
//        testQr();
//        testQr2();//中文（多字节编码）
//        testQr3();
//        testQr4();
//        test11();
//        getQrCode(400,400,"https://www.baidu.com");
//        getInfo();
        testcoding();
    }

}

 

3.1EIO

package org.nio;

/**
 * 简述：
 * Java NIO（New IO）是一个1可以替代标准java IO API的IO（从java1.4开始）
 * Java NIO提供了与标准IO不同的工作方式：通道和缓冲区
 * 标准的IO基于字节流和字符流进行IO操作，而NIO是基于通道和缓冲区进行操作，
 * 数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。
 * Java NIO：非阻塞IO，
 * Java NIO引入了选择器的概念，选择器用于监听多个通道的时间，单线程可以监听多个数据通道
 * <p>
 * 经过试验验证
 * 1.如果IO次数是1，2次，选择IO，如果IO次数很多NIO效率稍稍高一点点
 * 2.他们本质都是IO操作工作方式不同
 * 3.NIO是官方在IO（字节）基础上封装了一下
 */


import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;

/**
 * 新的类 都看成是工具，专门处理文件，目录，流
 * import java.nio.file.DirectoryStream; 处理目录流
 * import java.nio.file.FileSystem; 处理文件流
 * import java.nio.file.FileSystems; 处理文件流
 * import java.nio.file.Files; 处理文件
 * import java.nio.file.Paths; 处理文件
 * import java.nio.file.attribute.FileAttribute; 处理文件
 * import java.nio.file.attribute.PosixFilePermission; 处理文件
 * import java.nio.file.attribute.PosixFilePermissions; 处理文件
 *
 */

/**
 * 常用方法
 * Paths常用方法
 *
 * 1.获取Path实例化对象   Paths.get("d:/user")
 *
 * Files常用方法
 * 1.判断文件（包括目录）是否存在  Files.exists  文件最基础的操作--建议每一个操作前都添加
 *          判断是否是目录 Files.isDirectory()
 * 2.创建目录/文件  Files.createDirectory/Files.createFile
 *          多级目录 Files.createDirectories（目录存在不会报错） ; 不能建立多级文件
 * 3.删除目录/文件 ： Files.delete()  只能删除空目录 没有返回值， Files.deleteIfExists(f);
 * );
 *          练习：递归删除非空目录 delDir
 * 4.查看目录下的文件， Files.newDirectoryStream  返回是一个目录流（这个方法很好）  DirectoryStream<Path>
 *          练习：
 *          递归遍历目录 seekDir
 *          统计某目录下有多少个java文件
 * 5.新建文件并在文件中写字符串 Files.writeString(Path,String)
 *          1.可以追加，选择编码 UTF_16 ,  StandardOpenOption.APPEND
 *
 * 6.创建文本文件读取流
 *          Files.newBufferedReader(Path,Charset)
 * 7.创建文本文件写入流
 *          Files.newBufferedWriter(Path,Charset)
 * 8.文件移动
 *          Files.move(Path,Path) 文件不存在会有异常
 * 9.复制（拷贝）文件
 *          Files.copy()
 *
 * 异常
 *java.nio.file.NoSuchFileException
 *java.nio.file.FileAlreadyExistsException
 */

public class Test {
    public static void test() {
        try {
            if (!Files.exists(Paths.get("d:/user"))) {
                Path path = Files.createDirectory(Paths.get("d:/user"));
                System.out.println(path);
            }
            Path path = Files.createDirectories(Paths.get("d:/user/a/b/c/d"));
            System.out.println(path);
            if (!Files.exists(Paths.get("d:/user/ab/g.txt"))) {
                path = Files.createFile(Paths.get("d:/user/ab/g.txt"));
                System.out.println(path);
            }
        } catch (FileAlreadyExistsException e) {
            System.out.println("文件已经存在了，请你添加判断");
        } catch (IOException e) {
            System.out.println("IO异常，请检查");
            e.printStackTrace();
        }
    }

    public static void delDir(Path dir) {
        if (dir == null) {
            return;
        }
        if (Files.exists(dir)) {
            if (Files.isDirectory(dir)) {
                try {
                    //目录下的文件是流对象--会自动关闭，用完了（只能用一次）也会关闭。
                    DirectoryStream<Path> paths = Files.newDirectoryStream(dir);
                    //流处理--真正执行操作
                    paths.forEach(path -> {
                        try {
                            if (Files.isDirectory(path)) {
                                delDir(path);
                            } else {
                                Files.delete(path);
                            }
                        } catch (IOException e) {
                            System.out.println("删除文件异常，请检查");
                            throw new RuntimeException(e);
                        }
                    });
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        try {
            Files.delete(dir);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    //遍历目录，返回总的文件数，包括目录
    public static int seekDir(Path dir) {
        if (dir == null) {
            return 0;
        }
        AtomicInteger count = new AtomicInteger(1);
        if (Files.isDirectory(dir)) {
            System.out.println("遍历目录：" + dir.getFileName());
            try {
                DirectoryStream<Path> dirs = Files.newDirectoryStream(dir);
                if (dirs != null) {
                    dirs.forEach(path -> {
                        if (Files.isDirectory(path)) {
                            count.addAndGet(seekDir(path));
                        } else {
                            System.out.println(path.getFileName());
//                            count++;
                            count.addAndGet(1);
                        }
                    });
                }
            } catch (IOException e) {

            }
        }
        return count.get();
    }

    /**
     * 小知识
     * forEach里面不能用++，不能修改，基础数据类型，应该改变，并且调用方法 addAndGet增加
     */

    public static int seekJavaFile(Path dir) {
        if (dir == null) {
            return 0;
        }
        int count = 0;
        if (Files.exists(dir)) {
            if (Files.isDirectory(dir)) {
                DirectoryStream<Path> paths;
                try {
                    paths = Files.newDirectoryStream(dir);
                    Iterator<Path> it = paths.iterator();
                    while (it.hasNext()) {
                        Path temp = it.next();
                        if (Files.isDirectory(temp)) {
                            count += seekJavaFile(temp);
                        } else {
                            if (temp.toString().endsWith(".java")) {
                                count++;
                            }
                        }
                    }
                } catch (IOException e) {
                    System.out.println("io异常，请检查");
                    e.printStackTrace();
                }
                return count;
            } else {
                if (dir.getFileName().toString().endsWith(".java")) {
                    return 1;
                }
            }
        }
        return 0;
    }
    /**
     * 易错点
     * Path也有endsWith()。但是和java的不同,它是看看文件路径结尾的文件
     * 必须变为toString() Path里面也有endsWith（）
     */


    /**
     * 文件写入
     */
    public static void test2() {
        try {
//            Files.writeString(Paths.get("my.txt"),"你好！\r\n学习javaIO");
            byte[] bytes = "你好！\n学习javaIO".getBytes("UTF_16");
            System.out.println(Arrays.toString(bytes) + new String(bytes, "UTF_16"));
            bytes = "你好！\n学习javaIO".getBytes("utf-8");
            System.out.println(Arrays.toString(bytes));
            //不能同时用两种编码格式，文本只能用一种方式，所以只能识别英文
            Files.writeString(Paths.get("my.txt"), new String("你好！\n学习javaIO".getBytes("UTF_16"), "UTF_16"), StandardCharsets.UTF_16);
//            Files.writeString(Paths.get("my.txt"),new String("你好！\n学习javaIO".getBytes("ISO_8859_1"),"ISO_8859_1"), StandardCharsets.ISO_8859_1,StandardOpenOption.APPEND);
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" my.txt");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 小知识
     *1.ISO_8859_1 不支持中文 -- 不能用 部分欧洲人用
     *2.写文件不能同时用两种编码格式，文本只能用一种方式打开，所以只能识别英文公共部分
     */

    /**
     * 文件添加行号
     */
    public static void addLineSign(Path path) {
        if (Files.exists(path)) {
            System.out.println("文件存在");
            if (!Files.isDirectory(path)) {
                System.out.println("是一个文件");
                try {
                    List<String> strings = Files.readAllLines(path);
                    System.out.println("文件的总行数是" + strings.size());
                    //向文件中写
                    Iterator<String> it = strings.iterator();
                    System.out.println(strings);
                    int count = 0;
//            Files.delete(path);
                    Files.writeString(path, "");
                    while (it.hasNext()) {
                        String temp = it.next();
                        System.out.println(temp);
                        Files.writeString(path, ++count + temp + "\r\n", StandardOpenOption.APPEND);
                    }
//                    Files.writeString(path,++count,StandardOpenOption.APPEND);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
    /**
     * 易错点：
     * 1.流每次都是覆盖，没有用一个写入流。
     *      结果并不是没有写入（说明流关闭了），而是只有最后一次写入（前面的都被覆盖了）--故需要已追加方式，并且第一次需要把文件清空
     * 2.读的时候一定保证文件存在
     * 3.同样最后一行没法处理,
     *            想处理了自己添加
     *          -- 最后一行没有换行自己多写了
     *            行尾添加换行会导致，自己需要在循环结束后补，并且会额外多一行。
     * 4.读取的时候会把换行去掉，需要自己添加
     */

    public static void addLineSign2(Path path){
        //使用之前的方法
        BufferedReader br = null;
        try {
            br = Files.newBufferedReader(path, StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        String st = null;
        try {
            Stream<String> lines = br.lines();

            BufferedWriter write = Files.newBufferedWriter(Paths.get("eidLine.txt"), StandardCharsets.UTF_8);
            AtomicInteger count = new AtomicInteger();
            lines.forEach(line -> {
                try {
                    write.write(count.incrementAndGet() + line +"\r\n");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        catch(IOException e) {

        }
    }
    /**
     * 其它
     * foreach写入时候只写了一点
     */
    /**
     * String类的format方法
     */
    public static void testStringFormat(){
        byte[] bytes = String.format("姓名：%s、年龄：%d","张三",11).getBytes();
        System.out.println(new String(bytes));
        try {
            Files.writeString(Paths.get("aaaa.txt"),String.format("年龄：%02d、姓名：%s",11,"张三"));
            Runtime.getRuntime().exec("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" aaaa.txt");

        }
       catch (IOException e) {

       }
    }

    /**
     * 文件移动
     *      剪贴粘贴
     *      特殊的移动，改名
     * 文件拷贝
     *      copy
     *      transferTo jdk 9
     *
     * 1.异常：Files.copy 文件不存在，文件已经有了都会出现问题
     * 2.transferTo 底层是一个缓冲
     */
    public static void test3(){
        try {
//            Files.move(Paths.get("a.txt"),Paths.get("b.txt"));
//            Files.copy(Paths.get("a.txt"),Paths.get("b.txt"));
            FileInputStream fis= new FileInputStream("a.txt");
            fis.transferTo(new FileOutputStream("bb.txt"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
//        test();
//        delDir(Paths.get("d:/user/a"));
//        System.out.println("工作目录一共"+seekDir(Paths.get(System.getProperty("user.dir")))+"个文件（包含目录）");
//        System.out.println("工作目录一共"+seekDir(Paths.get(""))+"个文件（包含目录）");
//        System.out.println("工作目录一共"+seekDir(Paths.get("."))+"个文件（包含目录）");
//        System.out.println("工作目录一共"+seekJavaFile(Paths.get("."))+"个java文件");
//        System.out.println(Paths.get("d:/user/a/b").endsWith("a/b"));//true
//        System.out.println(Paths.get("d:/user/a/b").endsWith("a"));//false
//        test2();
//        addLineSign(Paths.get("eid.java"));
//        addLineSign2(Paths.get("eid.java"));
//        testStringFormat();
        test3();
    }
    /**
     * 小知识
     * 表示当前目录（工作路径）的3种方式
     *  "AAA"  和"aaa" 和 "./aaa""./AAA" 和"AAA/"  和"aaa/"和"AAA/."  和"aaa/."一样
     * 1.System.getProperty("user.dir")
     * 2.相对路径  ""  "."
     */
}