第二十二章《记事本》第3节：项目完整代码

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import javax.swing.event.*;
import javax.print.*;
import javax.print.attribute.*;
import java.nio.charset.Charset;
import java.util.*;
import java.text.*;

public class NoteBookFrame extends JFrame {

    JScrollPane JSPane;//放置文本区的滚动面板
    JTextArea text;//记事本文本区
    JMenuBar mainMenuBar;//菜单蓝
    JMenu fileMenu, editMenu, formatMenu, helpMenu;//各菜单
    //File菜单的菜单项
    JMenuItem newItem, openItem, saveItem, saveasItem, pageItem, printItem, exitItem;
    // 编辑菜单的菜单项
    JMenuItem undoItem, cutItem, copyItem, pasteItem, findItem, replaceItem, selectallItem, dateItem;
    //检查框菜单项，用于设置是否自动换行
    JCheckBoxMenuItem wrapItem;
    //字体设置菜单项
    JMenuItem fontItem;
    //帮助主题和关于菜单项
    JMenuItem helpItem, aboutItem;
    //右键菜单
    JPopupMenu popMenu;
    //字体设置对话框
    FontDialog myFontDialog = null;
    boolean changed = false;
    boolean haveName = false;
    //当前打开的这个文件
    File file = null;
    //当前文件的字符编码
    String charSet = new String("");
    //创建一个事件监听器对象
    ActionListenerImpl listener = new ActionListenerImpl();
    //初始化窗体组件
    private void init() {
        Container container = this.getContentPane();
        text = new JTextArea();
        JSPane = new JScrollPane(text);
        container.add(JSPane, BorderLayout.CENTER);
        createMenu();//创建主菜单
        createPopupMenu();//创建弹出式菜单
        this.setJMenuBar(mainMenuBar);//设置菜单
        text.setComponentPopupMenu(popMenu);
        //为文本区添加监听器
        text.getDocument().addDocumentListener(new DocumentListener() {
            @Override
            public void insertUpdate(DocumentEvent e) {
                changed = true;
            }

            @Override
            public void removeUpdate(DocumentEvent e) {
                changed = true;
            }

            @Override
            public void changedUpdate(DocumentEvent e) {
                //不需要动作
            }
        });
        //为文本区添加键盘监听器
        text.addKeyListener(new HandleKey());
        //为文本区添加键盘监听器
        text.addMouseListener(new HandleMouse());
    }

    //创建界面、安装各种监听器、
    public NoteBookFrame() {
        init();
    }

    //创建主菜单
    public void createMenu() {
        //创建JMenuBar
        mainMenuBar = new JMenuBar();
        //创建四个JMenu
        fileMenu = new JMenu("文件");
        editMenu = new JMenu("编辑");
        formatMenu = new JMenu("格式");
        helpMenu = new JMenu("帮助");
        //创建JMenuItem并添加到对应的JMenu中
        mainMenuBar.add(fileMenu);
        newItem = new JMenuItem("新建");
        openItem = new JMenuItem("打开..");
        saveItem = new JMenuItem("保存..");
        saveasItem = new JMenuItem("另存为..");
        pageItem = new JMenuItem("页面设置..");
        printItem = new JMenuItem("打印..");
        exitItem = new JMenuItem("退出");
        fileMenu.add(newItem);
        fileMenu.add(openItem);
        fileMenu.add(saveItem);
        fileMenu.add(saveasItem);
        fileMenu.addSeparator();
        fileMenu.add(pageItem);
        fileMenu.add(printItem);
        fileMenu.addSeparator();
        fileMenu.add(exitItem);

        mainMenuBar.add(editMenu);
        undoItem = new JMenuItem("撤消");
        cutItem = new JMenuItem("剪切");
        copyItem = new JMenuItem("复制");
        pasteItem = new JMenuItem("粘贴");
        findItem = new JMenuItem("查找..");
        replaceItem = new JMenuItem("替换..");
        selectallItem = new JMenuItem("全选");
        dateItem = new JMenuItem("时间/日期");
        editMenu.add(undoItem);
        editMenu.addSeparator();
        editMenu.add(cutItem);
        editMenu.add(copyItem);
        editMenu.add(pasteItem);
        editMenu.addSeparator();
        editMenu.add(findItem);
        editMenu.add(replaceItem);
        editMenu.addSeparator();
        editMenu.add(selectallItem);
        editMenu.add(dateItem);

        mainMenuBar.add(formatMenu);
        wrapItem = new JCheckBoxMenuItem("自动换行");
        fontItem = new JMenuItem("设置字体..");
        formatMenu.add(wrapItem);
        formatMenu.add(fontItem);
        mainMenuBar.add(helpMenu);
        helpItem = new JMenuItem("帮助主题");
        aboutItem = new JMenuItem("关于..");
        helpMenu.add(helpItem);
        helpMenu.add(aboutItem);

        exitItem.addActionListener(listener);
        saveItem.addActionListener(listener);
        saveasItem.addActionListener(listener);
        newItem.addActionListener(listener);
        printItem.addActionListener(listener);
        openItem.addActionListener(listener);
        cutItem.addActionListener(listener);
        copyItem.addActionListener(listener);
        pasteItem.addActionListener(listener);
        selectallItem.addActionListener(listener);
        dateItem.addActionListener(listener);
        wrapItem.addActionListener(listener);
        findItem.addActionListener(listener);
        fontItem.addActionListener(listener);
    }

    //创建弹出式菜单
    public void createPopupMenu() {
        popMenu = new JPopupMenu();
        popMenu.add("撤消");
        popMenu.addSeparator();
        popMenu.add("剪切");
        popMenu.add("复制");
        popMenu.add("粘贴");
        popMenu.addSeparator();
        popMenu.add("全选");
    }

    //重写父类方法，当用户按下窗口的“关闭”时，会自动调用此方法
    protected void processWindowEvent(WindowEvent e) {
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
            doExit();
        }
    }

    //根据用户选择文本的情况，修改菜单的状态
    void checkSelected() {
        if (text.getSelectedText() == null) {
            cutItem.setEnabled(false);
            copyItem.setEnabled(false);
        } else {
            cutItem.setEnabled(true);
            copyItem.setEnabled(true);
        }
    }

    //退出记事本
    void doExit() {
        int select;
        boolean flag = false;
        if (!changed)
            System.exit(0);
        else {
            select = JOptionPane.showConfirmDialog(this, "文件修改后尚未保存，要保存吗？");
            if(select==JOptionPane.YES_OPTION){
                flag = doSave();
                if (flag == true) {
                    System.exit(0);
                }
            }else if(select==JOptionPane.NO_OPTION){
                System.exit(0);
            }
        }
    }

    //保存用户编辑的文件，保存成功返回1，否则返回0
    boolean doSave() {
        FileWriter fr = null;
        String content;
        boolean flag;
        if (!haveName) {
            flag = doSaveAs();
        } else if (changed) {
            try {
                fr = new FileWriter(file,Charset.forName(charSet));
                content = text.getText();
                if (!"GBK".equals(charSet)) {//如果不是GBK(ANSI)则先写BOM
                    fr.write("\uFEFF");
                }
                fr.write(content);
                changed = false;//修改完后文件改变置为false
                flag = true;
            } catch (FileNotFoundException e) {
                JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
                flag = false;
            } catch (IOException e) {
                JOptionPane.showMessageDialog(this, "无法写文件，请检查文件是否被锁定");
                flag = false;
            } finally {
                closeWriter(fr);
            }
        } else {
            flag = true;
        }
        return flag;
    }

    //用"另存为"对话框保存文件。保存成功返回true，否则返回false
    boolean doSaveAs() {
        boolean flag = false;
        File tmpfile = null;
        ExampleFileFilter filter = new ExampleFileFilter();
        filter.addExtension("txt");
        filter.setDescription("文本文件");
        SaveDialog dialog;
        String thisCharSet = new String("");//本次保存的编码类型
        if (file == null) {//如果目前操作的是一个没被保存过的文件
            dialog = new SaveDialog(filter);
        } else {
            dialog = new SaveDialog(filter, file.getPath(),charSet);
        }
        SaveType saveType = dialog.getSaveType();
        if (saveType != null) {   //确定要保存文件
            String encode = saveType.getEncode();
            tmpfile = saveType.getFile();
            thisCharSet = getEncodeType(encode);
            String absolutePath = tmpfile.getAbsolutePath();
            if (saveType.isTxtFile()) {  //如果是文本文件方式存储
                String extension = absolutePath.substring(absolutePath.length() - 4);
                if (!extension.equalsIgnoreCase(".txt")) {//如果不以txt为后缀
                    absolutePath = absolutePath + ".txt";//为其增加后缀
                    tmpfile = new File(absolutePath);
                }
            }
            flag = true;
        } else {
            flag = false;
        }

        if (flag == true) {  //用户已经确定要以指定名称保存文件
            FileWriter fr = null;
            try {
                fr = new FileWriter(tmpfile,Charset.forName(thisCharSet));
                String content = text.getText();
                if (!"GBK".equals(thisCharSet)) {//如果不是GBK(ANSI)则先写BOM
                    fr.write("\uFEFF");
                }
                fr.write(content);
                flag = true;
            } catch (FileNotFoundException e) {
                JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
                flag = false;
            } catch (IOException e) {
                JOptionPane.showMessageDialog(this, "无法写文件，请检查文件是否被锁定");
                flag = false;
            }finally {
                closeWriter(fr);
            }
        }

        if (flag == true) {//文件保存成功，修改相关变量
            changed = false;
            haveName = true;
            file = tmpfile;
            charSet = thisCharSet;
            this.setTitle("记事本 -- " + file.getName());
        }
        return flag;
    }

    //新建一个文件
    void doNewFile() {
        int select;
        boolean flag = false;
        if (changed) {
            select = JOptionPane.showConfirmDialog(this, "文件修改后尚未存盘，要保存吗？");
            switch (select) {
                case JOptionPane.YES_OPTION:
                    flag = doSave();
                    break;
                case JOptionPane.NO_OPTION:
                    flag = true;
                    break;
                default:
                    flag = false;
                    break;
            }
        } else {
            flag = true;
        }
        if (flag == true) {
            changed = false;
            haveName = false;
            charSet = "GBK";
            setTitle("记事本 -- 未命名");
            text.setText(null);
        }
    }

    //调用打印对话框，给用户打印文档
    void doPrint() {
        try {
            //创建打印请求属性集
            PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet();
            //设置打印格式(自动)
            DocFlavor flavor = DocFlavor.BYTE_ARRAY.AUTOSENSE;
            //查找所有可用的打印服务
            PrintService printService[] = PrintServiceLookup.lookupPrintServices(flavor, pras);
            //定位默认打印机
            PrintService defaultService = PrintServiceLookup.lookupDefaultPrintService();
            PrintService service ;
            //显示打印对话框
            service = ServiceUI.printDialog(null, 100, 100, printService, defaultService, flavor, pras);
            if (service != null) {
                //创建打印作业
                DocPrintJob job = service.createPrintJob();
                //创建文档属性集
                DocAttributeSet das = new HashDocAttributeSet();
                //建立打印格式文件
                Doc doc = new SimpleDoc(text.getText().getBytes(), flavor, das);
                //进行文件的打印
                job.print(doc, pras);
            }
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "打印任务无法完成");
        }
    }

    //打开一个已经存在的文件
    void doOpen() {
        int select;
        boolean flag;
        File tmpfile = null;
        ExampleFileFilter filter;
        JFileChooser chooser;
        FileReader fr = null;
        if (changed) {
            select = JOptionPane.showConfirmDialog(this, "文件修改后尚未存盘，要保存吗？");
            switch (select) {
                case JOptionPane.YES_OPTION:
                    flag = doSave();
                    break;
                case JOptionPane.NO_OPTION:
                    flag = true;
                    break;
                default:
                    flag = false;
                    break;
            }
        } else {
            flag = true;
        }
        if (flag == true) {
            changed = false;
            filter = new ExampleFileFilter();
            filter.addExtension("txt");
            filter.setDescription("文本文件");
            if (file != null) {
                chooser = new JFileChooser(file.getPath());
            } else {
                chooser = new JFileChooser();
            }
            chooser.setFileFilter(filter);
            select = chooser.showOpenDialog(this);
            if (select == JFileChooser.APPROVE_OPTION) {
                tmpfile = chooser.getSelectedFile();
                try {
                    String enCode = this.getEncode(tmpfile);

                    StringBuffer content = new StringBuffer("");
                    fr = new FileReader(tmpfile, Charset.forName(enCode));
                    if ("UTF-8".equals(enCode) || "UTF-16BE".equals(enCode) || "UTF-16LE".equals(enCode)) {
                        fr.read();//提前读出
                    }
                    int read;
                    while ((read = fr.read()) != -1) {
                        content.append((char) read);
                    }
                    text.setText(content.toString());
                    text.setCaretPosition(0);//设置插入点位置
                    changed = false;
                    haveName = true;
                    file = tmpfile;//把所选择并打开的文件作为当前文件
                    charSet = enCode;
                    setTitle("记事本 -- " + file.getName());
                } catch (FileNotFoundException e) {
                    JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
                } catch (IOException e) {
                    JOptionPane.showMessageDialog(this, "无法读文件，请检查文件是否被锁定");
                }
            }
        }
    }

    //将用户选择的文本剪切到剪贴板
    void doCut() {
        text.cut();
    }

    //将用户选择的文本复制到剪贴板
    void doCopy() {
        text.copy();
    }

    //将剪贴板中的内容复制到文本区
    void doPaste() {
        text.paste();
    }

    //全选
    void doSelectAll() {
        text.selectAll();
    }

    //插入当前日期和时间
    void doDateTime() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm yyyy-MM-dd");
        text.append(sdf.format(new Date()));
    }

    //自动换行
    void doWrap() {
        if (wrapItem.getState()) {
            text.setLineWrap(true);
        } else {
            text.setLineWrap(false);
        }
    }

    //显示查找对话框
    void doFind() {
        FindDialog dialog = new FindDialog(text);

        dialog.setLocationRelativeTo(null);
        dialog.setTitle("查找");
        dialog.setSize(300, 120);
        dialog.setVisible(true);
    }

    //设置字体
    void doChangeFont() {
        if (myFontDialog == null) {
            myFontDialog = new FontDialog(this);
        }
        if (myFontDialog.showFontDialog() == FontDialog.OK) {
            text.setFont(myFontDialog.getFont());//获得对话框返回的字体并以它作为记事本字体
        }
    }

    //获得文件的字符编码
    private String getEncode(File file) throws FileNotFoundException, IOException {
        String enCode = "";
        FileInputStream fis = new FileInputStream(file);
        byte[] head = new byte[3];
        int read = fis.read(head, 0, 3);
        if (read == -1) {//如果什么都没读到，则说明没有BOM，属于ANSI
            enCode = "GB2312";
        } else if (head[0] == (byte) 0XFF && head[1] == (byte) 0XFE) {
            enCode = "UTF-16LE";
        } else if (head[0] == (byte) 0XFE && head[1] == (byte) 0XFF) {
            enCode = "UTF-16BE";
        } else if (head[0] == (byte) 0XEF && head[1] == (byte) 0XBB && head[2] == (byte) 0XBF) {
            enCode = "UTF-8";
        } else {
            enCode = "GB2312";
        }
        return enCode;
    }

    //关闭输出流
    void closeWriter(Writer writer) {
        if (writer != null) {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //关闭输入流
    void closeReader(Reader reader) {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //把对话框的编码类型转换成实际的Charset名称
    String getEncodeType(String name) {
        String encode = "";
        switch (name) {
            case "ANSI":
                encode = "GBK";
                break;
            case "Unicode":
                encode = "UTF-16LE";
                break;
            case "Unicode big endian":
                encode = "UTF-16BE";
                break;
            case "UTF-8":
                encode = "UTF-8";
                break;
            default:
                encode = "GBK";
        }
        return encode;
    }

    //定义监听器
    //定义一个监听器的实现类用以监听各菜单项事件
    class ActionListenerImpl implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            Object obj;
            obj = e.getSource();
            if (obj == exitItem)
                doExit();
            else if (obj == saveItem)
                doSave();
            else if (obj == saveasItem)
                doSaveAs();
            else if (obj == newItem)
                doNewFile();
            else if (obj == printItem)
                doPrint();
            else if (obj == openItem)
                doOpen();
            else if (obj == cutItem)
                doCut();
            else if (obj == copyItem)
                doCopy();
            else if (obj == pasteItem)
                doPaste();
            else if (obj == selectallItem)
                doSelectAll();
            else if (obj == dateItem)
                doDateTime();
            else if (obj == wrapItem)
                doWrap();
            else if (obj == findItem)
                doFind();
            else if (obj == fontItem)
                doChangeFont();
        }
    }
    //键盘监听器类
    class HandleKey extends KeyAdapter {
        public void keyPressed(KeyEvent e) {
            checkSelected();
        }
    }
    //鼠标监听器类
    class HandleMouse extends MouseAdapter {
        public void mouseReleased(MouseEvent e) {
            checkSelected();
        }
    }
}

import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
public class FontDialog extends JDialog {
    public static final int Cancle = 0;
    public static final int OK = 1;
    public static final String[] style = {"正常", "斜体", "粗体", "粗斜体"};
    public static final String[] size = {"8", "9", "10", "11", "12", "14", "16",
            "18", "20", "22", "24", "26", "28", "36", "48", "72"};
    private Font userFont = null;
    private int userSelect = Cancle;
    private JFrame parent = null;
    private JScrollPane nameSPane, styleSPane, sizeSPane;
    private JPanel panel[];
    private JLabel lblName, lblStyle, lblSize;
    private JTextField txtName, txtStyle, txtSize;
    private JList nameList, styleList, sizeList;
    private JButton btnOK, btnCancle;

    //定义一个动作监听器类
    class ActionlistenerImpl implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            int styleIndex = Font.PLAIN, fontSize;
            if (e.getSource() == btnOK) {
                if (txtStyle.getText().equals("正常"))
                    styleIndex = Font.PLAIN;
                if (txtStyle.getText().equals("斜体"))
                    styleIndex = Font.ITALIC;
                if (txtStyle.getText().equals("粗体"))
                    styleIndex = Font.BOLD;
                if (txtStyle.getText().equals("粗斜体"))
                    styleIndex = Font.BOLD | Font.ITALIC;
                fontSize = Integer.parseInt(txtSize.getText());
                userFont = new Font(txtName.getText(), styleIndex, fontSize);
                userSelect = OK;
                setVisible(false);
            } else {
                userSelect = Cancle;
                setVisible(false);
            }
        }
    }

    //创建一个列表监听器类
    class ListSelectionListenerImple implements ListSelectionListener {
        public void valueChanged(ListSelectionEvent e) {
            if (e.getSource() == nameList) {
                txtName.setText((String) nameList.getSelectedValue());
            }
            if (e.getSource() == styleList) {
                txtStyle.setText((String) styleList.getSelectedValue());
            }
            if (e.getSource() == sizeList) {
                txtSize.setText((String) sizeList.getSelectedValue());
            }
        }
    }

    //创建监听器对象
    ActionlistenerImpl listener = new ActionlistenerImpl();
    ListSelectionListenerImple listSelectionListener = new ListSelectionListenerImple();

    private void init() {
        setTitle("字体");
        Container container = this.getContentPane();
        BoxLayout box = new BoxLayout(container, BoxLayout.Y_AXIS);
        container.setLayout(box);
        panel = new JPanel[4];
        for (int i = 0; i < 3; i++) {
            panel[i] = new JPanel();
            panel[i].setLayout(new GridLayout(1, 3));
        }
        panel[3] = new JPanel();
        panel[3].setLayout(new FlowLayout());

        lblName = new JLabel("字体");
        lblStyle = new JLabel("字形");
        lblSize = new JLabel("大小");
        panel[0].add(lblName);
        panel[0].add(lblStyle);
        panel[0].add(lblSize);

        txtName = new JTextField("宋体");
        txtName.setColumns(5);
        txtName.setEditable(false);
        txtStyle = new JTextField("正常");
        txtStyle.setColumns(5);
        txtStyle.setEditable(false);
        txtSize = new JTextField("12");
        txtSize.setColumns(5);
        txtSize.setEditable(false);
        panel[1].add(txtName);
        panel[1].add(txtStyle);
        panel[1].add(txtSize);
        GraphicsEnvironment eq = GraphicsEnvironment.getLocalGraphicsEnvironment();
        String[] availableFonts = eq.getAvailableFontFamilyNames();
        nameList = new JList(availableFonts);
        nameList.addListSelectionListener(listSelectionListener);
        nameSPane = new JScrollPane(nameList);
        styleList = new JList(style);
        styleList.addListSelectionListener(listSelectionListener);
        styleSPane = new JScrollPane(styleList);
        sizeList = new JList(size);
        sizeList.addListSelectionListener(listSelectionListener);
        sizeSPane = new JScrollPane(sizeList);
        panel[2].add(nameSPane);
        panel[2].add(styleSPane);
        panel[2].add(sizeSPane);

        btnOK = new JButton("确定");
        btnOK.addActionListener(listener);
        btnCancle = new JButton("取消");
        btnCancle.addActionListener(listener);
        panel[3].add(btnOK);
        panel[3].add(btnCancle);
        for (int i = 0; i < 4; i++) {
            container.add(panel[i]);
        }

    }

    public FontDialog(JFrame owner) {
        super(owner, true);
        parent = owner;
        init();
    }

    public int showFontDialog() {
        setSize(300, 300);
        int x, y;
        if (parent != null) {
            x = parent.getX() + 30;
            y = parent.getY() + 30;
        } else {
            x = 150;
            y = 100;
        }
        setLocation(new Point(x, y));
        setVisible(true);
        return userSelect;
    }

    public Font getFont() {
        return userFont;
    }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class FindDialog extends JDialog {
    JPanel panel1, panel2;
    JTextArea text;
    JLabel label1;
    JTextField findEdit;
    JCheckBox checkBox;
    JRadioButton btnUp, btnDown;
    ButtonGroup dirBtnGroup;
    JButton btnOK, btnCancle;
    int start;//查找开始位置
    int curPosition;//原来光标的位置
    //定义一个动作监听器类
    class ActionlistenerImpl implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (e.getSource() == btnOK) {
                find();
            } else {
                dispose();
            }
        }
    }

    //创建监听器对象
    ActionlistenerImpl listener = new ActionlistenerImpl();

    private void init(JTextArea textArea) {
        Container container = this.getContentPane();

        text = textArea;
        curPosition = text.getCaretPosition();//初始光标的位置
        start = curPosition;//设置初始查找位置为初始光标位置
        panel1 = new JPanel();
        panel1.setLayout(new FlowLayout());
        panel2 = new JPanel();
        panel2.setLayout(new FlowLayout());
        label1 = new JLabel("查找内容");
        findEdit = new JTextField(12);
        btnOK = new JButton("查找下一个");
        btnOK.addActionListener(listener);
        panel1.add(label1);
        panel1.add(findEdit);
        panel1.add(btnOK);
        checkBox = new JCheckBox("区分大小写");
        checkBox.setSelected(true);
        btnUp = new JRadioButton("向上");
        btnDown = new JRadioButton("向下", true);
        dirBtnGroup = new ButtonGroup();
        dirBtnGroup.add(btnUp);
        dirBtnGroup.add(btnDown);
        btnCancle = new JButton("取消");
        btnCancle.addActionListener(listener);
        panel2.add(checkBox);
        panel2.add(btnUp);
        panel2.add(btnDown);
        panel2.add(btnCancle);
        container.setLayout(new FlowLayout());
        container.add(panel1);
        container.add(panel2);
    }

    public FindDialog(JTextArea text) {
        init(text);
    }

    public void find() {
        int index;
        start = text.getCaretPosition();
        String allText = text.getText();//记事本中的全部字符
        String searchText = findEdit.getText();
        if(checkBox.isSelected()==false) {//不区分大小写
            allText = allText.toLowerCase();
            searchText = searchText.toLowerCase();
        }
        if(btnDown.isSelected()) {//向下查找
            index = allText.indexOf(searchText, start);
            if (index < 0) {
                JOptionPane.showMessageDialog(this, "已查找全部文档");
                text.setCaretPosition(0);
            } else {
                text.select(index, index + searchText.length());
            }
        }else {//向上查找
            start--;
            index = allText.lastIndexOf(searchText, start);
            if (index < 0) {
                JOptionPane.showMessageDialog(this, "已查找全部文档");
                text.setCaretPosition(allText.length());
            } else {
                text.setCaretPosition(index+searchText.length());
                text.moveCaretPosition(index);
            }
        }
    }
}

import java.io.File;
import java.util.Hashtable;
import java.util.Enumeration;
import javax.swing.filechooser.*;
public class ExampleFileFilter extends FileFilter {
    private Hashtable filters = null;
    private String description = null;
    private String fullDescription = null;
    private boolean useExtensionsInDescription = true;
    public String toString(){
        return description;
    }
    public ExampleFileFilter() {
        this.filters = new Hashtable();
    }

    public boolean accept(File f) {
        if (f != null) {
            if (f.isDirectory()) {
                return true;
            }
            String extension = getExtension(f);
            if (extension != null && filters.get(getExtension(f)) != null) {
                return true;
            }
        }
        return false;
    }

    public String getExtension(File f) {
        if (f != null) {
            String filename = f.getName();
            int i = filename.lastIndexOf('.');
            if (i > 0 && i < filename.length() - 1) {
                return filename.substring(i + 1).toLowerCase();
            }
        }
        return null;
    }

    public void addExtension(String extension) {
        if (filters == null) {
            filters = new Hashtable(5);
        }
        filters.put(extension.toLowerCase(), this);
        fullDescription = null;
    }

    public String getDescription() {
        if (fullDescription == null) {
            if (isExtensionListInDescription()) {
                fullDescription = (description == null) ? "(" : description + " (";
                Enumeration extensions = filters.keys();
                if (extensions != null) {
                    fullDescription += "*." + (String) extensions.nextElement();
                    while (extensions.hasMoreElements()) {
                        fullDescription += ", *." + (String) extensions.nextElement();
                    }
                }
                fullDescription += ")";
            } else {
                fullDescription = description;
            }
        }
        return fullDescription;
    }

    public void setDescription(String description) {
        this.description = description;
        fullDescription = null;
    }

    public void setExtensionListInDescription(boolean b) {
        useExtensionsInDescription = b;
        fullDescription = null;
    }

    public boolean isExtensionListInDescription() {
        return useExtensionsInDescription;
    }
}

import java.io.File;
public class SaveType {
    private File file;//要保存的文件
    private String encode;//存储的类型
    private boolean isTxtFile;
    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        this.file = file;
    }

    public String getEncode() {
        return encode;
    }

    public void setEncode(String encode) {
        this.encode = encode;
    }

    public boolean isTxtFile() {
        return isTxtFile;
    }

    public void setTxtFile(boolean txtFile) {
        isTxtFile = txtFile;
    }
}

import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.io.File;

import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileFilter;

public class SaveDialog extends JDialog {
    private JFileChooser fileChooser;
    private JLabel lblName;
    private JComboBox<String> jbcName;
    private SaveType saveType;

    SaveDialog(FileFilter filter, String path, String charSet) {
        init(filter, path, charSet);
    }

    SaveDialog(FileFilter filter) {
        this(filter, null, "");
    }

    void init(FileFilter filter, String path, String charSet) {
        Container container = this.getContentPane();
        container.setLayout(null);
        if (path != null) {
            fileChooser = new JFileChooser(path);
        } else {
            fileChooser = new JFileChooser();
        }
        fileChooser.setSize(550, 400);
        fileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
        if (filter != null) {
            fileChooser.setFileFilter(filter);
        }
        lblName = new JLabel("编码(E)");
        lblName.setSize(60, 25);
        lblName.setLocation(150, 390);
        jbcName = new JComboBox<String>();
        jbcName.addItem("ANSI");
        jbcName.addItem("Unicode");
        jbcName.addItem("Unicode big endian");
        jbcName.addItem("UTF-8");
        jbcName.setSize(150, 25);
        jbcName.setLocation(210, 390);
        String encode = this.getCharset(charSet);
        // 反向选中下拉框
        jbcName.setSelectedItem(encode);
        fileChooser.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String option = e.getSource().toString();
                if (option.contains("APPROVE_OPTION")) {
                    File tempFile = fileChooser.getSelectedFile();//获取用户所选择的文件
                    if(tempFile.exists()) {//如果文件已经存在则对是否保存文件进行确认
                        if (JOptionPane.showConfirmDialog(SaveDialog.this, "文件已经存在，是否覆盖？",
                                "警告", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
                            generateSaveType();//生成SaveType
                            SaveDialog.this.dispose();
                        } else {
                            saveType = null;
                        }
                    }else {//如果文件不存在则直接生成SaveType
                        SaveDialog.this.generateSaveType();//
                        SaveDialog.this.dispose();
                    }
                } else if (option.contains("CANCEL_OPTION")) {
                    saveType = null;
                    SaveDialog.this.dispose();
                }
            }
        });

        container.add(fileChooser);
        container.add(lblName);
        container.add(lblName);
        container.add(jbcName);
        this.setModal(true);// 设置为模态对话框
        this.setSize(570, 470);
        this.setLocationRelativeTo(null);
        this.setTitle("另存为");
        this.setVisible(true);
    }

    private String getCharset(String name) {
        String encode = "";
        switch (name) {
            case "GBK":
                encode = "ANSI";
                break;
            case "UTF-16LE":
                encode = "Unicode";
                break;
            case "UTF-16BE":
                encode = "Unicode big endian";
                break;
            case "UTF-8":
                encode = "UTF-8";
                break;
            default:
                encode = "ANSI";
        }
        return encode;
    }

    public SaveType getSaveType() {
        return saveType;
    }

    protected void processWindowEvent(WindowEvent e) {
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
            saveType = null;
            this.dispose();
        }
    }

    private void generateSaveType() {
        saveType = new SaveType();
        if ("文本文档".equals(fileChooser.getFileFilter().toString())) {// 如果用户选择了文本文件
            saveType.setTxtFile(true);
        } else {
            saveType.setTxtFile(false);
        }
        saveType.setFile(fileChooser.getSelectedFile());
        saveType.setEncode((String) jbcName.getSelectedItem());
    }

}

public class NoteBook {
    public static void main(String[] args) {
        NoteBookFrame noteBookFrame = new NoteBookFrame();
        noteBookFrame.setTitle("记事本--未命名");
        noteBookFrame.setSize(400,300);
        noteBookFrame.setLocationRelativeTo(null);
        noteBookFrame.setVisible(true);
    }
}