TextView BOLD에서 특정 텍스트를 만드는 방법

TextView BOLD에서 특정 텍스트를 만드는 방법

TextView의 특정 텍스트를 굵은 글씨로 만드는 방법을 모릅니다.

이런식으로

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

출력을 다음과 같이 했으면 합니다.

1111 닐

id그리고.name데이터베이스에서 값을 검색한 변수입니다. 그리고 저는 다음을 만들기를 원합니다.id대담하게도, 그러나 오직id그래서.name영향을 주지 않을 겁니다 어떻게 해야 할지 모르겠어요

HTML로 문자열을 작성하고 설정하면 됩니다.

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

Html()에서 html.from Html을 사용할 수 있지만 SpannableStringBuilder라는 보다 네이티브한 접근 방식을 사용할 수 있지만 이 게시물은 유용할 수 있습니다.

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);

첫째: 라그하브 수드의 답변에서 나온 느린 성능 코드를 사용하는 것에 대해 걱정할 필요가 없습니다.

둘째: 코틀린 사용 시 w3bshark의 답변에서 제공하는 확장 기능을 작성할 필요가 없습니다.

피날리:Google의 Kotlin 안드로이드-ktx 라이브러리를 사용하기만 하면 됩니다(자세한 정보와 프로젝트에 포함하는 방법은 여기를 참조하십시오).

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

생산품 : 1111 닐

---

업데이트:

다른 사람에게 도움을 줄 수 있을 뿐만 아니라 어디까지 사용할 수 있는지 보여줄 수 있다고 생각하기 때문입니다.

• 일부 부분이 있는 텍스트를 파란색과 기울임꼴로 표시해야 할 경우:

  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. 공식 문서에서 다른 가능성을 생각할 수 있는 또 다른 확장 기능을 볼 수 있습니다.

저는 선택한 답변이 만족스러운 결과를 가져오지 못했다고 생각했습니다.2개의 문자열이 필요한 함수를 직접 작성했습니다.전체 텍스트와 굵게 만들 텍스트 부분.

'text'를 굵은 글씨로 표시한 'textToBold'를 가진 SpannableStringBuilder를 반환합니다.

저는 서브스트링을 태그로 포장하지 않고 굵게 만드는 능력이 유용하다고 생각합니다.

    /**
     * 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;
  }

wtsang02가 말했듯이 HTML을 사용하는 것은 비용이 많이 드는 오버헤드입니다.기본 솔루션을 사용하면 됩니다.문자열을 수정할 필요가 없다면 SpannableStringBuilder가 아니라 SpannableString만 사용하면 됩니다.

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);

XML의 문자열을 사용하려는 경우 다음과 같은 작업을 수행할 수 있습니다.

strings.xml ("CDATA" 부분이 중요합니다. 그렇지 않으면 작동하지 않습니다.)

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

레이아웃 파일

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView" android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:layout_gravity="center" />

</FrameLayout>

코드를

textView.text = HtmlCompat.fromHtml(getString(R.string.test), HtmlCompat.FROM_HTML_MODE_LEGACY)

예를 들어 이렇게 지정된 텍스트를 닫기만 하면 됩니다.<b>"your text here:"</b>

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

결과: 본사: 미국 노스캐롤라이나주 무어스빌

코틀린을 사용한다면 사용하기가 더욱 쉬워집니다.core-ktx, 도메인 특정 언어(DSL)를 제공하기 때문에 다음과 같습니다.

val string: SpannedString = buildSpannedString {
    bold {
        append("foo")
    }
    append("bar")     
}

추가 옵션은 다음과 같습니다.

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

마지막으로 다음 작업을 수행할 수 있습니다.

textView.text = string

@mladj0ni님의 답변을 토대로 아래 코드를 받아 작업했습니다.String을 사용하면 문제가 있었습니다.형식은 html 마크업을 제거하므로 strings.xml의 괄호 기호를 피해야 합니다.

strings.xml:

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

코드.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);

Spannable StringBuilder보다 간단합니다.성능의 경우, 문자열을 하나만 표시하는 경우 사용자는 해당 문자열을 구문 분석하는 데 추가적인 밀리초를 인식하지 못합니다.

여기에 있는 설명서를 참조하십시오.

여러 텍스트를 굵은 글씨로 만들고 싶다면 다음과 같은 방법이 더 좋습니다.에이탄의 코드를 향상시켰습니다.고마워요 에이탄.

public static SpannableStringBuilder makeSectionOfTextBold(String text, String... textToBold) {
    SpannableStringBuilder builder = new SpannableStringBuilder(text);

    for (String textItem :
            textToBold) {
        if (textItem.length() > 0 && !textItem.trim().equals("")) {
            //for counting start/end indexes
            String testText = text.toLowerCase(Locale.US);
            String testTextToBold = textItem.toLowerCase(Locale.US);
            int startingIndex = testText.indexOf(testTextToBold);
            int endingIndex = startingIndex + testTextToBold.length();

            if (startingIndex >= 0 && endingIndex >= 0) {
                builder.setSpan(new StyleSpan(Typeface.BOLD), startingIndex, endingIndex, 0);
            }
        }
    }

    return builder;
}

이 코드를 사용하여 텍스트의 일부를 굵게 설정할 수 있습니다.굵은 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;
        }

html.fromHtml("")이 현재 더 이상 사용되지 않으므로 wtsang02 답변이 가장 좋습니다.여기서는 문장의 크기에 상관없이 첫 단어를 동적으로 굵게 만드는 데 문제가 있는 사람들을 위해 그것을 약간 강화하려고 합니다.

먼저 첫 단어를 얻을 수 있는 방법을 만들어 보겠습니다.

 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 이 당신의 친구가 되기를 원하는 것과 같길 원합니다!당신이 해야 할 일은 첫 단어를 얻고 첫 단어를 대담하게 만들 수 있는 여유를 얻는 것입니다. 다음과 같은 것입니다.

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);

그것으로 끝!이제 긴 문장/짧은 문장의 크기에 상관없이 단어를 굵게 표현할 수 있어야 합니다.

이 코드가 가장 쉬운 해결책 아닌가요?

<string name="string">Please provide your <b>Name</b> properly</string>

이 끈은 원하는 대로 사용하세요 :)

결과는 다음과 같습니다.

이름을 제대로 입력하십시오.

저는 기존의 답변에 만족하지 못했기 때문에, 좀 더 최신의 해결책을 제공하기 위해 여기에 왔습니다.번역된 텍스트에 적합하고 사용하는 성능이 없는 것이 필요했습니다.Html.fromHtml(). 코틀린을 사용하는 경우 텍스트의 여러 부분을 굵게 설정하는 확장 기능이 있습니다.이 기능은 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())
    }
}

케이스 체크가 포함된 동적 String 값에 대한 완벽한 솔루션은 다음과 같습니다.

/**
 * 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;
}

예: completeString = "I am BOLD"

CASE I if*targetStringToFormat* = "bold"그리고.*matchCase* = true

"I am BOLD" (since bold!= BOLD)를 반환합니다.

CASE II 만약*targetStringToFormat* = "bold"그리고.*matchCase* = false

"I am BOLD"를 반환합니다.

적용 방법:

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

도움이 되기를 바랍니다!

이 코드를 사용해서 특정 단어를...

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

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

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

    return Html.fromHtml(resultant);

}

이거 먹어봐요.확실히 도움이 될 수 있습니다.

다음과 같은 Charlist/Recycler를 검색하는 동안 문자열의 첫 번째 Char를 spannable로 만듭니다.

라비와 재이

예전에 이렇게 강조했었는데 아래와 같이 되고 싶었습니다.

ravi와 jay or ravi 와 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;
}

빌드에서 두 문자열을 별도로 추가할 수 있으며, 그 중 하나는 spannedString이고 다른 하나는 일반 문자열입니다.이렇게 하면 지수를 계산할 필요가 없습니다.

val instructionPress = resources?.getString(R.string.settings_press)

val okText = resources?.getString(R.string.ok)
val spannableString = SpannableString(okText)

val spannableBuilder = SpannableStringBuilder()
spannableBuilder.append(instructionPress)
spannableBuilder.append(spannableString, StyleSpan(Typeface.BOLD), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

instructionText.setText(spannableBuilder,TextView.BufferType.SPANNABLE)

이것은 내가 이것에 사용하는 코틀린 확장 기능입니다.

/**
 * 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.text="something bold"
text_view.setSubstringTypeface(
    Pair(
        "something bold",
        Typeface.BOLD
    )
)

.

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

굵은 텍스트의 위치가 고정되어 있는 경우(ex: 텍스트 보기 시작 부분에 있는 경우), 배경이 같은 두 개의 다른 텍스트 보기를 사용합니다.그러면 다른 텍스트 보기의 텍스트 스타일을 굵게 만들 수 있습니다.

이렇게 하려면 단일 텍스트 보기에 비해 두 배의 메모리가 필요하지만 속도는 증가합니다.

여러 언어로 현지화를 처리하고 싶을 경우 방법을 찾았습니다. 실행하는 것은 지루하지만 효과는 있습니다. 우리가 원하는 것은 다음과 같습니다.

영어로:

결제가등록되어있지않습니다

스페인어:

건초 파고 등록기 금지

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)

문자열 리소스

<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> 

당신의 자바 수업

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

텍스트 보기 및 텍스트 편집을 위해 텍스트의 일부를 굵게 설정하기 위한 정적 메서드를 만들었습니다.

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);
        }
    }

데이터 바인딩을 사용하는 경우.바인딩 어댑터는 다음과 같이 정의할 수 있습니다.

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

그러면 TextView에서 사용할 수 있습니다.

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

여기서 bold_text는

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

간단한 예제

in you 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>

결과는

이는 당사의 개인 정보 보호 정책입니다.

일반적인 표현과 코틀린을 사용해서 하는 방법은 이렇습니다.

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)

Kotlin과 문자열 리소스를 사용하는 경우 간단한 솔루션은 다음과 같습니다.

문자열 만들기strings.xml, 를 합니다.<b> </b>원하는 부분을 과감히 하다

<string name="my_message"> This is a very <b>important</b> message! </string>

코틀린 코드에서는 그렇게 해야 합니다.

textView.setText(R.string.my_message)

그게 다예요!

---

중요한 노트!

속성 구문을 사용하면 작동하지 않습니다.

textView.text = resources.getString(R.string.my_message)

도움이 되길 바랍니다!

코틀린에서.

굵게 만들 하위 문자열을 선언합니다.

val phone = "+45xxxxxx"

원하는 색과 굵은 태그로 문자열을 감싸고 다른 문자열에 저장합니다.

val phoneText = "<font color=#757B7F><b>${phone}</b></font>"

마지막으로 이 하위 문자열을 상위 문자열과 연결합니다.

val wholeString = requireActivity().resources.getString(R.string.loginwith)+" "+phoneText

태그에 이 내용을 추가하기만 하면 됩니다.

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

언급URL : https://stackoverflow.com/questions/14371092/how-to-make-a-specific-text-on-textview-bold