如何在Java Swing中实现标准Caret光标行为？

要满足你提到的5个高级文本选择需求，核心是自定义Caret实现类，继承DefaultCaret并扩展鼠标事件处理逻辑，同时利用Java的BreakIterator工具类精准判断单词、段落的边界。

自定义AdvancedCaret实现 #

以下是完整的自定义Caret代码，包含所有需求的实现：

import javax.swing.text.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import java.text.BreakIterator;

public class AdvancedCaret extends DefaultCaret {
    private int clickCount = 0;
    private long lastClickTime = 0;
    // 双击/三击的时间间隔（毫秒），可根据需求调整
    private static final int CLICK_INTERVAL = 500;

    @Override
    protected void mousePressed(MouseEvent e) {
        JTextComponent component = getComponent();
        if (component == null || !component.isEnabled() || !component.isEditable()) {
            super.mousePressed(e);
            return;
        }

        // 统计连续点击次数
        long currentTime = System.currentTimeMillis();
        clickCount = (currentTime - lastClickTime <= CLICK_INTERVAL) ? clickCount + 1 : 1;
        lastClickTime = currentTime;

        int pos = component.viewToModel(e.getPoint());

        // 三击选中整个段落
        if (clickCount == 3) {
            selectParagraph(component, pos);
            e.consume();
            return;
        }
        // 双击后Shift点击，扩展选择到目标单词末尾
        else if (clickCount == 2 && e.isShiftDown()) {
            moveCaretPosition(getWordEnd(component, pos));
            e.consume();
            return;
        }
        // Shift点击单个位置，扩展选择到目标单词末尾
        else if (clickCount == 1 && e.isShiftDown()) {
            moveCaretPosition(getWordEnd(component, pos));
            e.consume();
            return;
        }

        super.mousePressed(e);
    }

    @Override
    protected void mouseDragged(MouseEvent e) {
        JTextComponent component = getComponent();
        if (component == null || !component.isEnabled() || !component.isEditable()) {
            super.mouseDragged(e);
            return;
        }

        int currentPos = component.viewToModel(e.getPoint());
        int originalPos = getDot();

        // 单次点击后拖动，按单词扩展选择范围
        if (clickCount == 1) {
            setDot(getNearestWordBoundary(component, originalPos, currentPos));
            e.consume();
            return;
        }
        // 双击后拖动，按段落扩展选择范围
        else if (clickCount == 2) {
            setDot(getNearestParagraphBoundary(component, originalPos, currentPos));
            e.consume();
            return;
        }

        super.mouseDragged(e);
    }

    @Override
    protected void mouseReleased(MouseEvent e) {
        JTextComponent component = getComponent();
        if (component == null || !component.isEnabled() || !component.isEditable()) {
            super.mouseReleased(e);
            return;
        }

        // 三击选中段落后，Shift点击扩展到目标段落
        if (clickCount == 3 && e.isShiftDown()) {
            int pos = component.viewToModel(e.getPoint());
            Document doc = component.getDocument();
            try {
                String text = doc.getText(0, doc.getLength());
                BreakIterator paraIterator = BreakIterator.getParagraphInstance();
                paraIterator.setText(text);
                int targetParaEnd = paraIterator.following(pos);
                if (targetParaEnd == BreakIterator.DONE) {
                    targetParaEnd = doc.getLength();
                }
                // 跳过段落末尾的空白字符
                while (targetParaEnd > 0 && Character.isWhitespace(text.charAt(targetParaEnd - 1))) {
                    targetParaEnd--;
                }
                moveCaretPosition(targetParaEnd);
                e.consume();
                return;
            } catch (BadLocationException ex) {
                ex.printStackTrace();
            }
        }

        super.mouseReleased(e);
    }

    // 获取指定位置的单词结束边界
    private int getWordEnd(JTextComponent component, int pos) {
        Document doc = component.getDocument();
        try {
            String text = doc.getText(0, doc.getLength());
            BreakIterator wordIterator = BreakIterator.getWordInstance();
            wordIterator.setText(text);
            int end = wordIterator.following(pos);
            // 跳过单词后的空白字符，确保选中完整单词
            while (end < text.length() && Character.isWhitespace(text.charAt(end))) {
                end = wordIterator.following(end);
            }
            return Math.min(end, doc.getLength());
        } catch (BadLocationException ex) {
            ex.printStackTrace();
            return pos;
        }
    }

    // 获取指定位置的单词起始边界
    private int getWordStart(JTextComponent component, int pos) {
        Document doc = component.getDocument();
        try {
            String text = doc.getText(0, doc.getLength());
            BreakIterator wordIterator = BreakIterator.getWordInstance();
            wordIterator.setText(text);
            int start = wordIterator.preceding(pos);
            if (start == BreakIterator.DONE) start = 0;
            // 跳过单词前的空白字符
            while (start > 0 && Character.isWhitespace(text.charAt(start - 1))) {
                start = wordIterator.preceding(start - 1);
            }
            return start;
        } catch (BadLocationException ex) {
            ex.printStackTrace();
            return pos;
        }
    }

    // 获取拖动时最近的单词边界（向前/向后）
    private int getNearestWordBoundary(JTextComponent component, int originalPos, int currentPos) {
        return currentPos > originalPos ? getWordEnd(component, currentPos) : getWordStart(component, currentPos);
    }

    // 选中指定位置所在的整个段落
    private void selectParagraph(JTextComponent component, int pos) {
        Document doc = component.getDocument();
        try {
            String text = doc.getText(0, doc.getLength());
            BreakIterator paraIterator = BreakIterator.getParagraphInstance();
            paraIterator.setText(text);
            int start = paraIterator.preceding(pos);
            int end = paraIterator.following(pos);
            if (start == BreakIterator.DONE) start = 0;
            if (end == BreakIterator.DONE) end = doc.getLength();
            // 跳过段落首尾的空白字符
            while (start < end && Character.isWhitespace(text.charAt(start))) start++;
            while (end > start && Character.isWhitespace(text.charAt(end - 1))) end--;
            setDot(start);
            moveCaretPosition(end);
        } catch (BadLocationException ex) {
            ex.printStackTrace();
        }
    }

    // 获取拖动时最近的段落边界（向前/向后）
    private int getNearestParagraphBoundary(JTextComponent component, int originalPos, int currentPos) {
        Document doc = component.getDocument();
        try {
            String text = doc.getText(0, doc.getLength());
            BreakIterator paraIterator = BreakIterator.getParagraphInstance();
            paraIterator.setText(text);
            if (currentPos > originalPos) {
                int end = paraIterator.following(currentPos);
                return end == BreakIterator.DONE ? doc.getLength() : end;
            } else {
                int start = paraIterator.preceding(currentPos);
                return start == BreakIterator.DONE ? 0 : start;
            }
        } catch (BadLocationException ex) {
            ex.printStackTrace();
            return currentPos;
        }
    }
}

使用方法 #

在你的Swing文本组件（如JTextArea、JTextField、JEditorPane）中设置这个自定义Caret即可：

// 示例：给JTextArea添加高级选择功能
JTextArea textArea = new JTextArea("The clock has been wound too tight.\n\nAnother paragraph here.");
textArea.setCaret(new AdvancedCaret());
// 其他组件同理
JTextField textField = new JTextField();
textField.setCaret(new AdvancedCaret());

功能说明 #

1. Shift+点击扩展到整词：无论是否双击过单词，按住Shift点击任意位置，选择范围都会扩展到该位置所在单词的末尾。
2. 点击拖动按词扩展：单次点击后拖动鼠标，选择范围会自动按单词边界扩展，而非精确到鼠标位置。
3. 三击选中段落：连续三击文本，会选中当前位置所在的整个段落（基于BreakIterator的段落规则，适配多语言）。
4. 三击后Shift点击扩展到整段落：三击选中段落后，按住Shift点击另一段落，选择范围会扩展至包含目标段落的全部内容。
5. 双击拖动按段落扩展：双击文本后拖动鼠标，选择范围会先选中当前段落，之后拖动时按段落边界扩展。

注意事项 #

• CLICK_INTERVAL常量可调整，适配不同用户的点击速度习惯。
• 段落判断基于Java的BreakIterator.getParagraphInstance()，会自动适配不同语言的段落规则，若需要自定义段落分隔逻辑（比如以两个换行符为段落分隔），可修改selectParagraph和getNearestParagraphBoundary方法中的逻辑。
• 空白字符的处理逻辑可根据需求调整，比如是否保留段落首尾的空白。

内容的提问来源于stack exchange，提问作者MiguelMunoz