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


251

TextView의 특정 텍스트를 BOLD로 만드는 방법을 모르겠습니다.

이것처럼

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

출력이 다음과 같기를 원합니다.

1111

id그리고 name나는 데이터베이스에서 값을 검색 한 변수가 있고, 내가 만들고 싶어 id굵게, 그러나 단지 id이 때문에 name영향을받지 않습니다, 나는이 작업을 수행하는 방법을 모르겠어요.



4 가지 방법-TextView의 굵은 글씨체 -확실히 도움이됩니다.
c49

답변:


379

HTML로 문자열을 작성하고 설정하십시오.

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

5
fromHtml (sourceString)은 API 24에서 더 이상 사용되지 않으므로 다음 코드를 사용해야합니다. Spanned durationSpanned; if (android.os.Build.VERSION.SDK_INT> = android.os.Build.VERSION_CODES.N) {durationSpanned = Html.fromHtml (durationFormatted, Html.FROM_HTML_MODE_LEGACY); } else {durationSpanned = Html.fromHtml (durationFormatted); }
Mladen Rakonjac

2
앱을 현지화하는 경우 작동하는 유일한 옵션입니다.
howettl

좋은 해결책이지만 그것이 작동하지 않는다는 것을 알았습니다. @ wtsang02 솔루션이 더 최적입니다
Omar Boshra

<String.format을 사용하는 경우 여기 에서 설명하는 것처럼 대괄호를 이스케이프하지 않는 한 작동하지 않습니다 .
Yusuf X

5
Html.fromHtml()더 이상 사용되지 않습니다
누군가 어딘가에

384

Html.fromHtml () 을 사용할 수 있지만 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);

이 답변이 작동하지 않으면 확장 가능한 문자열로 텍스트를 다음과 같이 추가하십시오. mSpannable.append (yourremainingtext);
Gowtham Kumar

10
사전 지식이없는 Google 사용자의 경우 : INT_START / INT_END는 굵게 시작하고 끝나는 위치입니다.
스포트라이트

2
소스 문자열을 변경하지 않고 일부 마크 업 만 적용하면 SpannableString 클래스를 사용하는 것이 좋습니다.
Buckstabue

26
사본을 현지화 해야하는 경우 완전히 중단됩니다. INT_START 및 INT_END는 지역에 따라 위치가 다릅니다.
howettl

4
의심스러운 경우 코드가 수행하는 작업을 이해하십시오. int start는 스팬의 시작 색인 인 사용자가 정의한 숫자입니다. start는 0, string은 () .size ()를 end로 시도하십시오.
wtsang02

84

첫째 : Raghav Sood의 답변 에서 성능이 느린 코드를 사용하는 것에 대해 걱정할 필요가 없습니다 .

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

Finnaly : Google 의 Kotlin android-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, coloritalic확장 기능에 있습니다 SpannableStringBuilder. 공식 문서 에서 다른 가능성을 생각할 수있는 다른 확장 기능을 볼 수 있습니다 .


이것은 훌륭하지만 모두 문자열과 관련된 모든 대답은 번역을 고려해야한다고 생각합니다. 문장의 단어는 일부 언어에서 완전히 다르게 정렬되고 구조화 될 수 있으므로 이와 같이 추가하는 것이 특정 상황에서 항상 적용되는 것은 아닙니다. 또한 XML의 수량 문자열과 같은 항목에는 적합하지 않습니다.
에드워드 반락

1
@CoolMind Android KTX를 사용할 수 없습니다. github.com/android/android-ktx에서 버그보고, 기능 제안 또는 해당 라이브러리에 기여하는 방법에 대한 정보를 찾을 수 있습니다. 따라서 여전히 유효한 참조입니다. 라이브러리에 대한 자세한 정보와 프로젝트에서 라이브러리를 사용하는 방법을 포함하도록 답변을 업데이트했습니다.
Filipe Brito

1
이 사람에게이 현대적인 솔루션과 리소스에 대한 메달을주세요 !! 감사!!!
Sjd

37

선택한 답변이 만족스러운 결과를 제공하지 못한다고 생각했습니다. 나는 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;
  }

코드에서 이것을 사용하는 방법의 예를 제공 할 수 있습니까?
Micro

2
@MicroR 두 개의 문자열을 전달해야합니다. 두 번째 문자열은 첫 번째 문자열에 포함 된 텍스트 섹션이어야합니다. 예 : makeSectionOfTextBold ( "이것은 훌륭한 텍스트입니다.", "great").
레온

1
if (textToBold! = null &&! textToBold.isEmpty ())로 if 문을 변경해야합니다.
Arda Kara

2
이 함수는 부분 문자열이 전체 텍스트에서 여러 번 발생할 수 있다고 예상하지 않습니다. 예를 들어 "My username is name"에서 두 번째 "name"을 굵게 표시 할 수 없습니다.
Jadamec

1
그런 다음이 메소드는 실제로 makeAllBold (text, textToBold)로 이름을 지정해야합니다.
wtsang02

29

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

23

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)

이것은 나를 위해 작동합니다 <string name="test"><b>text bold</b> other text</string>. 내가 글을 쓰면 작동하지 않습니다<![CDATA[
sara

@sara Q와 함께 Pixel 2에서 다시 테스트되었습니다. 여기에서 Kotlin과의 작동 방식을 업데이트했습니다. 다시 시도하십시오.
안드로이드 개발자

사용자 정의 글꼴을 사용하는 경우이 방법이 적합합니다. 창조자에게 Kudus.
Raghul Sugathan

13

예를 들어 다음과 같이 지정된 텍스트를 닫으십시오. <b>"your text here:"</b>

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

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


문자열이 xml에서 사용되는 경우에만 작동합니다. 이 문자열을 프로그래밍 방식으로 호출하면 html 인코딩이 제거됩니다.
Starwave

11

Kotlin을 사용 하는 경우이를 수행하기위한 DSL (Domain-Specific-language)core-ktx제공 하므로을 사용하면 훨씬 쉽게 수행 할 수 있습니다.

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

10

여러 텍스트를 굵게 표시하려면 더 나은 해결책이 있습니다. Eitan의 코드를 개선했습니다. 고마워 Eitan.

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

8

@ mladj0ni의 답변을 바탕으로 아래 코드가 작동합니다. 문제는 String.format 을 사용 하면 html 태그를 제거하므로 strings.xml에서 대괄호 기호를 이스케이프해야한다는 것입니다.

strings.xml :

<string name="welcome_messages">Hello, %1$s! You have &lt;b>%2$d new messages&lt;/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보다 간단합니다. 성능과 관련하여 문자열을 하나만 표시하면 구문 분석에 추가 밀리 초가 표시되지 않습니다.

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


& lt; b> ... & lt; / b>
감사합니다

4

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

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

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

    return Html.fromHtml(resultant);

}

이 시도. 확실히 도움이 될 수 있습니다


3

다음과 같이 list / recycler에서 char을 검색하는 동안 문자열의 첫 번째 문자를 확장 가능하게 만듭니다.

R a vi와 ajay

이전에 이와 같이 강조했지만 아래에 있고 싶었습니다.

라비 차 아제 또는 라비와 제이

이를 위해 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;
}

3

기존 답변에 만족하지 않았기 때문에 최신 솔루션을 제공하기 위해 여기에 왔습니다. 번역 된 텍스트에 작동하고 성능을 발휘하지 못하는 무언가가 필요했습니다 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())
    }
}

3

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

그리고 그게 다야! 이제 긴 문장이나 짧은 문장에서 어떤 크기의 단어라도 굵게 표시 할 수 있습니다. 그것이 누군가에게 도움이되기를 바랍니다, 행복한 코딩 :)


3

이것이 내가 사용하는 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.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
    )
)

2

빌더에서 두 문자열을 별도로 추가 할 수 있습니다. 하나는 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)

2

굵은 텍스트의 위치가 고정되어있는 경우 (예 : textView의 시작 부분 인 경우) 동일한 배경을 가진 두 개의 다른 textView를 사용하십시오. 그런 다음 다른 textView의 textStyle을 굵게 표시 할 수 있습니다.

단일 textView에 비해 두 배의 메모리가 필요하지만 속도는 증가합니다.


1

에 대한 정적 메서드를 만들었습니다 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);
        }
    }

1

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

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

"setHtml"함수는 어디에 작성합니까?
안드로이드 개발자

developer.android.com/topic/libraries/data-binding/… 주석이있는 한 기본적으로 모든 클래스입니다.
logcat

오, 이건 너무 이상해 감사합니다. 이 주제를 처음 접하는 사람들을위한 훌륭한 튜토리얼 / 샘플에 대해 알고 있습니까?
안드로이드 개발자

나는 튜토리얼을 모른다. 그냥 구글 "android BindingAdapter"
logcat

1

여러 언어로 현지화를 처리하려는 경우를 대비 한 방법을 찾았지만 지루하지만 작동하지만 다음과 같이 가정 해 봅시다.

영어로:

등록 된 지불 이 없습니다

스페인어:

어떤 건초 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)

1

문자열 리소스

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

0

다음은 대소 문자를 확인하는 동적 문자열 값에 대한 완벽한 솔루션입니다.

/**
 * 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 = "나는 BOLD"

CASE I 의 경우 *targetStringToFormat* = "bold"*matchCase* = true

"I am BOLD"를 반환합니다 (굵게! = BOLD이므로)

CASE II 의 경우 *targetStringToFormat* = "bold"*matchCase* = false

"나는 BOLD "를 반환합니다.

신청하기 :

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

희망이 도움이됩니다!

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.