java代码实现窗口化输入

package com.montnets.file;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * @author GanJunnan
 * @date 2019/4/22 8:37
 */
public class JframeWindow {
    public static void main(String[] args){
//        createWindows();
        inputWindows();
    }


    /**
    * 实现简单的窗口创建
    * */
    public static void createWindows(){

        // 创建窗口对象，并且设置窗口名称
        JFrame jf = new JFrame("新创建窗口");

        // 设置窗口名称的第二种方式
        jf.setTitle("设置窗口名称的第二种方式");
        // 设置窗口的大小
        jf.setSize(300,300);
        // 设置窗口的位置
        jf.setLocation(200,200);

        // 创建一个面板对象
        JPanel jp = new JPanel();
        // 将面板加入到窗口中
        jf.setContentPane(jp);
        // 设置面板的背景色
        jp.setBackground(Color.cyan);

        // 创建一个按钮对象
        JButton jButton = new JButton("按钮");
        // 将按钮添加到面板中
        jp.add(jButton);

        // 窗口设置退出按钮 如果不设置的话 似乎关闭窗口之后不会退出程序
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //
        jf.setVisible(true);

    }

    /**
     * 创建一个弹出窗中可以输入的窗口
     */
    public static void inputWindows(){
        JFrame jf = new JFrame("页面输入地址");

        jf.setSize(400,400);
        jf.setLocation(150,150);



jf.setLayout(new FlowLayout(FlowLayout.CENTER,10,30));
        JPanel jp = new JPanel();
        JTextField textField = new JTextField(20);
        JTextField textField2 = new JTextField(20);
        JTextField textField3 = new JTextField(20);
        JButton jButton = new JButton("提交");

        JLabel title = new JLabel("请输入地址");


        JLabel title2 = new JLabel("请输入关键字：");

        JLabel title3 = new JLabel("结果路径：");
        JLabel title4 = new JLabel("");
        jButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String inputText = textField.getText().trim();
                String keyWord = textField2.getText().trim();
                String filePath = textField2.getText().trim();

                if(("").equals(inputText)){
                    JOptionPane.showMessageDialog(null,"请输入文件地址：");
                    return;
                }
                if(("").equals(keyWord)){
                    JOptionPane.showMessageDialog(null,"请输入关键字：");
                    return;
                }
                if(("").equals(filePath)){
                    JOptionPane.showMessageDialog(null,"请输入结果文件的名称和地址");
                    return;
                }
                if(inputText.indexOf("\\")>0 && inputText.indexOf(":")>0){
                  // 在这里对结果操作
                   TestSqlFile.testFile(inputText,keyWord,filePath);
                }
            }
        });

        // 加入顺序影响着在页面上的展示位置
        jf.add(jp);
        jf.add(title);
        jf.add(textField);
        jf.add(title2);
        jf.add(textField2);
        jf.add(title3);
        jf.add(textField3);
        jf.add(title4);
        jf.add(jButton);


        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

package com.montnets.file;

import java.io.*;
import java.util.*;

/**
 * @author GanJunnan
 * @date 2019/4/19 14:39
 */
public class TestSqlFile {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("本方法只能输入检测的文件所在目录或者文件所在的文件夹路径");
        System.out.println("请输入检测目录路径/文件路径");
        String filePath = scanner.nextLine();

//        if (filePath.indexOf("\\") > 0) {
//            testFile(filePath);
//        }
    }

    public static void testFile(String filePath,String keyWord,String filePath1) {
        // 用来存放单个文件包含过滤内容的sql
        Map<String, String> fileMap = null;

        Map<String, Map<String, String>> directoryMap = new HashMap<String, Map<String, String>>(10);
        // 创建本地文件
        File file = new File(filePath);

        // 判断改文件是文件夹还是文件
        boolean directory = file.isDirectory();
        // 如果创建的是文件夹
        if (directory) {
            //如果是文件夹的话，获取下面的文件名称的集合
            String[] fileArr = file.list();

            for (int i = 0; i < fileArr.length; i++) {
                String fileName = fileArr[i];
                // 创建该目录下面的文件
                File direcctoryFile = new File(filePath + "\\" + fileName);

                // 判断该路径创建的是不是文件，如果是文件的话就读取其中的内容，是目录的话就不做任何操作
                boolean file1 = direcctoryFile.isFile();
                // 如果是文件的话就处理文件
                if (file1 && direcctoryFile.exists()) {
                    // 调用处理文件的放大
                    fileMap = dealFileContent(direcctoryFile,keyWord);
                    // 将处理结果存放到map里面
                    directoryMap.put(fileName, fileMap);
                }
            }
        } else {
            String name = file.getName();
            // 调用处理文件的放大
            fileMap = dealFileContent(file,keyWord);
            // 将处理结果存放到map里面
            directoryMap.put(name, fileMap);
        }
        // 首先遍历目录的map，也就是directoryMap这个map
        Set<Map.Entry<String, Map<String, String>>> entries = directoryMap.entrySet();

        // 得到directoryMap对应的迭代器
        Iterator<Map.Entry<String, Map<String, String>>> iterator = entries.iterator();
        FileOutputStream outputStream = null;
        try {
            if(!filePath1.endsWith(".txt")){
                filePath1 = filePath1+"out.txt";
            }
            // 创建文件写出的流
            outputStream= new FileOutputStream(filePath1);

                // 判断迭代器中是否有值，然后循环取出
            while (iterator.hasNext()) {
                // 获取迭代器当中的值的对象，也就是当中的map对象
                Map.Entry<String, Map<String, String>> next = iterator.next();
                // 获取directoryMap这个map当中对应的键和值
                String key = next.getKey();
                // 因为directoryMap当中存放的也是一个map，对弈也要循环来取其中的值
                Map<String, String> mapValue = next.getValue();
                System.out.println("********************************开始*************************************");
                System.out.println("文件" + key + "当中不规范的sql如下：");
                // 获取fileMap的EntrySet对象
                Set<Map.Entry<String, String>> entries1 = mapValue.entrySet();
                // 获取fileMap对应的迭代器
                Iterator<Map.Entry<String, String>> iterator1 = entries1.iterator();
                // 判断该迭代器中是否有值
                while (iterator1.hasNext()) {
                    // 获取fileMap当中的对象
                    Map.Entry<String, String> next1 = iterator1.next();
                    // 获取对象相应的键和值
                    String key1 = next1.getKey();
                    String value = next1.getValue();
                    System.out.println("在文件中第" + key1 + "个SQL是删除表的。");
                    System.out.println("SQL语句如下：");
                    System.out.println(value);
                    String str1 = "在文件中第" + key1 + "个SQL是删除表的";
                    String str2 = "SQL语句如下："+value;

                    String str3 = str1+"      "+str2;
                    byte[] bytes = str3.getBytes();
                    outputStream.write(bytes);


                }
            }
            System.out.println("********************************结束*************************************");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                outputStream.flush();
                outputStream.close();
            } catch (Exception e){
                e.printStackTrace();
            }

        }


    }

    public static Map<String, String> dealFileContent(File direcctoryFile,String keyWord) {
        Map<String, String> map = new HashMap<String, String>(10);
        FileInputStream fileInputStream = null;
        BufferedReader buff = null;

        // 标志是否是注释
        Boolean isComment = false;

        try {
            // 创建流来读取文件内容
            fileInputStream = new FileInputStream(direcctoryFile);
            buff = new BufferedReader(new InputStreamReader(fileInputStream, "utf-8"));
            // 声明一个builder用来存放一个完整的sql
            StringBuilder stringBuilder = null;
            // 声明一个字符串用来存放读取的一行的内容
            String line = null;
            // 用来判断是否需要创建一个新的builder对象
            Boolean isCreateBuilderObject = true;
            // 用来存放是第几个sql有问题
            int lineNumber = 0;
            // 循环遍历文件当中的内容
            while ((line = buff.readLine()) != null) {
                // 根据标志位来判断是否需要创建Builder对象
//                if (isCreateBuilderObject) {
//                    stringBuilder = new StringBuilder();
//                    // 创建完之后修改标志位
//                    isCreateBuilderObject = false;
//                    // 数据自增，表示第几个sql
//                    lineNumber++;
//                }

//                stringBuilder = new StringBuilder();
                // 数据自增，表示第几个sql
                lineNumber++;
                if (line.startsWith("--") || (line.startsWith("<!-") && line.endsWith("->"))|| line.startsWith("/*")) {
                    isComment = true;
                } else if (line.endsWith("*/")) {
                    if (line.startsWith("/*")) {
                        isComment = true;
                    } else {
                        isComment = false;
                    }

                }
                String upperCaseLine = line.toUpperCase().replaceAll("\\s{1,}", " ");
                if (upperCaseLine.indexOf(keyWord.toUpperCase().replaceAll("\\s{1,}", " ")) > 0) {
                    // 是的话，将SQL存放到map中
                    map.put(lineNumber + "", line);
                }

                // 将文件当中读取的内容拼接到builder后面
//                stringBuilder.append(line).append(" ");

                // 判断是否到达sql的最后一行，是的话就更该标志位，然后判断这整条sql是否是删表的语句，如果是的话就存在map中
//                if (line.indexOf(";") > 0 || "go".equalsIgnoreCase(line)) {
//                    // 修改标志位，下次进来的时候创建一个新的Builder对象
//                    isCreateBuilderObject = true;
//                    //判断整个sql中是否包含删除表的语句
//                    if (stringBuilder.indexOf("drop table") > 0 || stringBuilder.indexOf("DROP TABLE") >0) {
//                        // 是的话，将SQL存放到map中
//                        map.put(lineNumber + "", stringBuilder.toString());
//                    }
//                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
                buff.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map;
    }
}