Question

我不知道如何使TextView上的特定文本变为BOLD。

就像这样

txtResult.setText(id+" "+name);

我希望输出如下：

1111 neil

id和name是我从数据库中检索到值的变量，我希望id为粗体，但只有id所以{ {1}}不会受到影响，我不知道该怎么做。

Answer 1

虽然您可以使用Html.fromHtml()，但您可以使用SpannableStringBuilder更原生的方法，此post可能很有用。

SpannableStringBuilder str = new SpannableStringBuilder("Your awesome text");
str.setSpan(new android.text.style.StyleSpan(android.graphics.Typeface.BOLD), INT_START, INT_END, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView tv=new TextView(context);
tv.setText(str);

Answer 2

只需在HTML中构建您的String并进行设置：

String sourceString = "<b>" + id + "</b> " + name; 
mytextview.setText(Html.fromHtml(sourceString));

Answer 3

首先：您不必担心使用Raghav Sood's answer中的慢性能代码。

第二：使用Kotlin时，您不需要编写w3bshark's answer提供的扩展功能。

Finnaly：您需要做的就是使用Google提供的Kotlin android-ktx library：

// Suppose id = 1111 and name = neil (just what you want). 
val s = SpannableStringBuilder()
          .bold { append(id) } 
          .append(name)
txtResult.setText(s)

产生： 1111 neil

<强>更新

因为我认为它可以帮助其他人以及证明你可以走多远这里有更多的用例。

当您需要显示包含蓝色和斜体的某些部分的文本时：

val myCustomizedString = SpannableStringBuilder()
    .color(blueColor, { append("A blue text ") })
    .append("showing that ")
    .italic{ append("it is painless") }

当您需要以粗体和斜体显示文本时：

    bold { italic { append("Bold and italic") } }

简而言之，bold，append，color和italic是SpannableStringBuilder的扩展函数。您可以在official documentation中看到其他扩展功能，您可以从中考虑其他可能性。

Answer 4

我认为所选择的答案并没有提供令人满意的结果。我写了自己的函数，需要2个字符串;全文和要加粗的文本部分。

它返回一个带有＆＃39; textToBold＆＃39;的SpannableStringBuilder。来自＆＃39; text＆＃39;粗体显示。

我发现能够将子字符串加粗而不将其包含在有用的标记中。

    /**
     * Makes a substring of a string bold.
     * @param text          Full text
     * @param textToBold    Text you want to make bold
     * @return              String with bold substring
     */

    public static SpannableStringBuilder makeSectionOfTextBold(String text, String textToBold){

        SpannableStringBuilder builder=new SpannableStringBuilder();

        if(textToBold.length() > 0 && !textToBold.trim().equals("")){

            //for counting start/end indexes
            String testText = text.toLowerCase(Locale.US);
            String testTextToBold = textToBold.toLowerCase(Locale.US);
            int startingIndex = testText.indexOf(testTextToBold);
            int endingIndex = startingIndex + testTextToBold.length();
            //for counting start/end indexes

            if(startingIndex < 0 || endingIndex <0){
                return builder.append(text);
            }
            else if(startingIndex >= 0 && endingIndex >=0){

                builder.append(text);
                builder.setSpan(new StyleSpan(Typeface.BOLD), startingIndex, endingIndex, 0);
            }
        }else{
            return builder.append(text);
        }

        return builder;
  }

Answer 5

正如wtsang02所说，使用HTML是一种昂贵的开销。只需使用本机解决方案。如果您不必修改字符串，只需使用SpannableString，而不是SpannableStringBuilder。

String boldText = "id";
String normalText = "name";
SpannableString str = new SpannableString(boldText + normalText);
str.setSpan(new StyleSpan(Typeface.BOLD), 0, boldText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(str);

Answer 6

如果您想使用XML中的字符串，您可以执行以下操作：

的strings.xml

<string name="test">
     <![CDATA[
 <b>bold!</b> normal
    ]]>
</string>

代码：

textView.setText(Html.fromHtml(getString(R.string.test)));

Answer 7

如果您想将多个文本设为粗体，这是更好的解决方案。我改进了Eitan的代码。谢谢Eitan。

utf-8

Answer 8

简单地关闭指定的文本，例如<b>"your text here:"</b>

<string name="headquarters">"<b>"Headquarters:"</b>" Mooresville, North Carolina, U.S.</string>

结果： 总部：美国北卡罗来纳州穆尔斯维尔

Answer 9

根据@ mladj0ni的回答，我得到了下面的代码。问题是，如果你使用 String.format ，它会删除html标记，所以你必须转义strings.xml中的括号符号：

<强>的strings.xml：

<string name="welcome_messages">Hello, %1$s! You have <b>%2$d new messages</b>.</string>

<强> code.java：

String unspanned = String.format(Locale.US, "%s%s", getResources().getString(R.string. welcome_messages), 99);

Spanned spanned;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
    spanned = Html.fromHtml(unspanned, Html.FROM_HTML_MODE_LEGACY);
} else {
    spanned = Html.fromHtml(unspanned);
}

textView.setText(spanned);

它比SpannableStringBuilder更简单。至于性能，如果你只显示一个字符串，那么用户将不会注意到额外的毫秒来解析它。

请参阅文档here。

Answer 10

在list / recycler中搜索char时生成字符串spannable的第一个char

r a vi和ajay

此前突出显示如下但我希望如下所示

ravi a nd ajay OR ravi和 a jay

为此我搜索了单词长度，如果它等于1，我将主字符串分成单词并计算单词开始位置然后我用char开始搜索单词。

 public static SpannableString colorString(int color, String text, String... wordsToColor) {
    SpannableString coloredString = new SpannableString(text);

    for (String word : wordsToColor) {

        Log.e("tokentoken", "-wrd len-" + word.length());
        if (word.length() !=1) {
            int startColorIndex = text.toLowerCase().indexOf(word.toLowerCase());
            int endColorIndex = startColorIndex + word.length();
            try {
                coloredString.setSpan(new ForegroundColorSpan(color), startColorIndex, endColorIndex,
                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

            } catch (Exception e) {
                e.getMessage();
            }
        } else {
            int start = 0;

            for (String token : text.split("[\u00A0 \n]")) {
                if (token.length() > 0) {
                    start = text.indexOf(token, start);
                   // Log.e("tokentoken", "-token-" + token + "   --start--" + start);
                    char x = token.toLowerCase().charAt(0);
                    char w = word.toLowerCase().charAt(0);
                   // Log.e("tokentoken", "-w-" + w + "   --x--" + x);

                    if (x == w) {
                        // int startColorIndex = text.toLowerCase().indexOf(word.toLowerCase());
                        int endColorIndex = start + word.length();
                        try {
                            coloredString.setSpan(new ForegroundColorSpan(color), start, endColorIndex,
                                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

                        } catch (Exception e) {
                            e.getMessage();
                        }
                    }
                }
            }

        }

    }

    return coloredString;
}

Answer 11

我来这里是为了提供更新的解决方案，因为我对现有答案不满意。我需要一些适用于翻译文本的内容，并且没有使用Html.fromHtml()的性能影响。如果你正在使用Kotlin，这里有一个扩展功能，可以轻松地将文本的多个部分设置为粗体。这与Markdown类似，如果需要，可以扩展为支持其他Markdown标记。

val yourString = "**This** is your **string**.".makePartialTextsBold()
val anotherString = getString(R.string.something).makePartialTextsBold()

/**
 * This function requires that the parts of the string that need
 * to be bolded are wrapped in ** and ** tags
 */
fun String.makePartialTextsBold(): SpannableStringBuilder {
    var copy = this
    return SpannableStringBuilder().apply {
        var setSpan = true
        var next: String
        do {
            setSpan = !setSpan
            next = if (length == 0) copy.substringBefore("**", "") else copy.substringBefore("**")
            val start = length
            append(next)
            if (setSpan) {
                setSpan(StyleSpan(Typeface.BOLD), start, length,
                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
            }
            copy = copy.removePrefix(next).removePrefix("**")
        } while (copy.isNotEmpty())
    }
}

Answer 12

wtsang02 答案是最好的解决方法，因为Html.fromHtml（“”）已被弃用。在这里，我将针对那些动态将第一个单词加粗的人（无论句子的大小如何）有问题，对其进行一点增强。

首先让我们创建一个方法来获取第一个单词：

 private String getFirstWord(String input){

    for(int i = 0; i < input.length(); i++){

        if(input.charAt(i) == ' '){

            return input.substring(0, i);
        }
    }

    return input;
}

现在，假设您有一个很长的字符串，如下所示：

String sentence = "friendsAwesomeName@gmail.com want's to be your friend!"

您希望您的句子像 yourAwesomeName@gmail.com 一样，希望成为您的朋友！您要做的就是-获取firstWord并获取其长度以使firstWord变为粗体，如下所示：

String myFirstWord = getFirstWord(sentence);
int start = 0; // bold will start at index 0
int end = myFirstWord.length(); // and will finish at whatever the length of your first word

现在只需遵循 wtsang02的步骤，如下所示：

SpannableStringBuilder fancySentence = new SpannableStringBuilder(sentence);
fancySentence.setSpan(new android.text.style.StyleSpan(Typeface.BOLD), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(fancySentence);

就是这样！现在，您应该可以将长/短句子中任意大小的单词加粗。希望它能对某人有所帮助，祝您编程愉快：）

Answer 13

您可以在构建器中单独添加两个字符串，其中一个是spannedString，另一个是常规字符串。这样您就不必计算索引。

 document.getElementById('7d').addEventListener("click", function () {
    addkibanaCards(devices, prefix, '24h', 'quick');
 });

Answer 14

您的字符串资源

<resources>
   <string name="your_string_resource_name">This is normal text<![CDATA[<b> but this is bold </b>]]> and <![CDATA[<u> but this is underline text</u>]]></string>
</resources>

您的Java类

yourtextView.setText(getString(R.string.your_string_resource_name));

Answer 15

找到了一种方法来处理多种语言的本地化，这很无聊，但是可以用，假设我们想要这样：

英语：

没有注册付款

西班牙语：

没有干草 pagos registrados

您必须创建3个字符串

英语：

<string name="start_string">There are no</string>
<string name="middle_string">payments</string>
<string name="end_string">registered.</string>
<string name="string_format" translatable="false">%1$s %2$s %3$s</string>

西班牙语：

<string name="start_string">No hay</string>
<string name="middle_string">pagos</string>
<string name="end_string">registrados</string>

现在您可以执行以下操作：

val startSpanPosition = getString(R.string.start_string).length
val endSpanPosition = startSpanPosition + getString(R.string.middle_string).length
val mySpannableString = SpannableStringBuilder(String.format(getString(R.string.string_format),
        getString(R.string.start_string), getString(R.string.middle_string))), getString(R.string.end_string)))

mySpannableString.setSpan(StyleSpan(Typeface.BOLD), spanStartPosition, endSpanPosition, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

Answer 16

我为TextView和EditText的设置部分文字粗体创建了一个静态方法

public static void boldPartOfText(View mView, String contentData, int startIndex, int endIndex){
        if(!contentData.isEmpty() && contentData.length() > endIndex) {
            final SpannableStringBuilder sb = new SpannableStringBuilder(contentData);

            final StyleSpan bss = new StyleSpan(Typeface.BOLD); // Span to make text bold
            final StyleSpan iss = new StyleSpan(Typeface.NORMAL); //Span to make text normal
            sb.setSpan(iss, 0, startIndex, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
            sb.setSpan(bss, startIndex, endIndex, Spannable.SPAN_INCLUSIVE_INCLUSIVE); // make first 4 characters Bold
            sb.setSpan(iss,endIndex, contentData.length()-1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);

            if(mView instanceof TextView)
               ((TextView) mView).setText(sb);
            else if(mView instanceof EditText)
               ((EditText) mView).setText(sb);

        }
    }

另一个更自定义的代码

  /*typeFaceStyle can be passed as 

    Typeface.NORMAL = 0;
    Typeface.BOLD = 1;
    Typeface.ITALIC = 2;
    Typeface.BOLD_ITALIC = 3;*/

    public static void boldPartOfText(View mView, String contentData, int startIndex, int endIndex,int typeFaceStyle){
        if(!contentData.isEmpty() && contentData.length() > endIndex) {
            final SpannableStringBuilder sb = new SpannableStringBuilder(contentData);

            final StyleSpan bss = new StyleSpan(typeFaceStyle); // Span to make text bold
            final StyleSpan iss = new StyleSpan(Typeface.NORMAL); //Span to make text italic
            sb.setSpan(iss, 0, startIndex, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
            sb.setSpan(bss, startIndex, endIndex, Spannable.SPAN_INCLUSIVE_INCLUSIVE); // make first 4 characters Bold
            sb.setSpan(iss,endIndex,contentData.length()-1,Spanned.SPAN_INCLUSIVE_INCLUSIVE);

            if(mView instanceof TextView)
                ((TextView) mView).setText(sb);
            else if(mView instanceof EditText)
                ((EditText) mView).setText(sb);
        }
    }

Answer 17

public static Spanned getBoldString(String textNotBoldFirst, String textToBold, String textNotBoldLast) {
    String resultant = null;

    resultant = textNotBoldFirst + " " + "<b>" + textToBold + "</b>" + " " + textNotBoldLast;

    return Html.fromHtml(resultant);

}

试试这个。它绝对可以帮助

Answer 18

您可以使用此代码将部分文本设置为粗体。对于html粗体标记之间的任何内容，都会使其变为粗体。

String myText = "make this <b>bold</b> and <b>this</b> too";
textView.setText(makeSpannable(myText, "<b>(.+?)</b>", "<b>", "</b>"));

public SpannableStringBuilder makeSpannable(String text, String regex, String startTag, String endTag) {

            StringBuffer sb = new StringBuffer();
            SpannableStringBuilder spannable = new SpannableStringBuilder();

            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(text);
            while (matcher.find()) {
                sb.setLength(0);
                String group = matcher.group();
                String spanText = group.substring(startTag.length(), group.length() - endTag.length());
                matcher.appendReplacement(sb, spanText);

                spannable.append(sb.toString());
                int start = spannable.length() - spanText.length();

                spannable.setSpan(new android.text.style.StyleSpan(android.graphics.Typeface.BOLD), start, spannable.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
            sb.setLength(0);
            matcher.appendTail(sb);
            spannable.append(sb.toString());
            return spannable;
        }

Answer 19

如果粗体文本的位置是固定的（例如：如果是在textView的开头），则使用具有相同背景的两个不同的textView。然后你可以将另一个textView的textStyle设为粗体。

与单个textView相比，这需要两倍的内存，但速度会提高。

Answer 20

以下是带有大小写检查的动态字符串值的完整解决方案。

/**
 * Makes a portion of String formatted in BOLD.
 *
 * @param completeString       String from which a portion needs to be extracted and formatted.<br> eg. I am BOLD.
 * @param targetStringToFormat Target String value to format. <br>eg. BOLD
 * @param matchCase Match by target character case or not. If true, BOLD != bold
 * @return A string with a portion formatted in BOLD. <br> I am <b>BOLD</b>.
 */
public static SpannableStringBuilder formatAStringPortionInBold(String completeString, String targetStringToFormat, boolean matchCase) {
    //Null complete string return empty
    if (TextUtils.isEmpty(completeString)) {
        return new SpannableStringBuilder("");
    }

    SpannableStringBuilder str = new SpannableStringBuilder(completeString);
    int start_index = 0;

    //if matchCase is true, match exact string
    if (matchCase) {
        if (TextUtils.isEmpty(targetStringToFormat) || !completeString.contains(targetStringToFormat)) {
            return str;
        }

        start_index = str.toString().indexOf(targetStringToFormat);
    } else {
        //else find in lower cases
        if (TextUtils.isEmpty(targetStringToFormat) || !completeString.toLowerCase().contains(targetStringToFormat.toLowerCase())) {
            return str;
        }

        start_index = str.toString().toLowerCase().indexOf(targetStringToFormat.toLowerCase());
    }

    int end_index = start_index + targetStringToFormat.length();
    str.setSpan(new StyleSpan(BOLD), start_index, end_index, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    return str;
}

EG。 completeString =＆＃34;我是BOLD＆＃34;

CASE I 如果*targetStringToFormat* = "bold"和*matchCase* = true

返回＆＃34;我是BOLD＆＃34; （因为大胆！= BOLD）

CASE II 如果*targetStringToFormat* = "bold"和*matchCase* = false

返回＆＃34;我 BOLD ＆＃34;

申请：

myTextView.setText(formatAStringPortionInBold("I am BOLD", "bold", false))

希望有所帮助！

Answer 21

这是我为此使用的Kotlin扩展功能

/**
 * Sets the specified Typeface Style on the first instance of the specified substring(s)
 * @param one or more [Pair] of [String] and [Typeface] style (e.g. BOLD, ITALIC, etc.)
 */
fun TextView.setSubstringTypeface(vararg textsToStyle: Pair<String, Int>) {
    val spannableString = SpannableString(this.text)
    for (textToStyle in textsToStyle) {
        val startIndex = this.text.toString().indexOf(textToStyle.first)
        val endIndex = startIndex + textToStyle.first.length

        if (startIndex >= 0) {
            spannableString.setSpan(
                StyleSpan(textToStyle.second),
                startIndex,
                endIndex,
                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
            )
        }
    }
    this.setText(spannableString, TextView.BufferType.SPANNABLE)
}

用法：

text_view.setSubstringTypeface(
    Pair(
        "something bold",
        Typeface.BOLD
    )
)

。

text_view.setSubstringTypeface(
    Pair(
        "something bold",
        Typeface.BOLD
    ),
    Pair(
        "something italic",
        Typeface.ITALIC
    )
)

Answer 22

如果您使用的是Kotlin，则使用core-ktx变得更加容易，因为它为此提供了domain-specific-language (DSL)：

val string: SpannedString = buildSpannedString {
    bold {
        append("1111")
    }
    append("neil)     
}

它提供的更多选项是：

append("Hello There")
bold {
    append("bold")
    italic {
        append("bold and italic")
        underline {
            append("then some text with underline")
        }
    }
}

最后，您可以执行以下操作：

textView.text = string

Answer 23

如果有人正在使用数据绑定。我们可以这样定义绑定适配器

@BindingAdapter("html")
fun setHtml(view: TextView, html: String) {
    view.setText(HtmlCompat.fromHtml(html, HtmlCompat.FROM_HTML_MODE_LEGACY))
}

然后我们可以在TextView上使用它

app:html="@{@string/bold_text}"

粗体字为

<string name="bold_text"><![CDATA[Part of text is <b>bold</b>]]></string>

Answer 24

我使用此代码将特定的单词加粗...

    Spanned string = Html.fromHtml("Normal string <b>BOLD STRING</b>");
    textView.setText(string);

Answer 25

只需将其添加到您的标签中

dangerouslySetInnerHTML={{__html: "<p>Your html text here.<p>"}}

Answer 26

这是我如何使用正则表达式和 Kotlin

val BOLD_SPAN = StyleSpan(Typeface.BOLD)

    fun TextView.boldMatches(regexString: String) {
        this.applyStyleSpanToMatches(regexString, BOLD_SPAN)
    }
    

fun TextView.applyStyleSpanToMatches(regexString: String, span: StyleSpan){
        this.text = this.text.toString().applyStyleSpanToMatches(regexString, span)
        }

        fun String.applyStyleSpanToMatches(regexString: String, span: StyleSpan): Spannable {
            val result = SpannableString.valueOf(this)
            if(regexString.isEmpty()) return result
            val pattern = try{
                Pattern.compile(regexString)
            } catch (e: PatternSyntaxException){
                return result
            }
            val matcher = pattern.matcher(result)
            while (matcher.find()) {
                val start = matcher.start()
                val end = matcher.end()
                result.setSpan(span, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
            }
            return result
        }

使用问题它可以这样应用：

txtResult.boldMatches(id)

Answer 27

简单示例

在您的strings.xml中

<string name="str_privacy_policy">This is our Privacy Policy.</string>

如果要专门将“隐私权政策”设置为粗体，请将字符串放在粗体标记之间。

<string name="str_privacy_policy">This is our <b>Privacy Policy.</b></string>

结果应该是

这是我们的隐私权政策

如何在TextView BOLD上制作特定文本

27 个答案: