如何在 Android 中更改 TextView 的 fontFamily

从 android 4.1 / 4.2 / 5.0 开始，以下 Roboto 字体系列可用：

android:fontFamily="sans-serif"           // roboto regular
android:fontFamily="sans-serif-light"     // roboto light
android:fontFamily="sans-serif-condensed" // roboto condensed
android:fontFamily="sans-serif-black"     // roboto black
android:fontFamily="sans-serif-thin"      // roboto thin (android 4.2)
android:fontFamily="sans-serif-medium"    // roboto medium (android 5.0)

https://i.stack.imgur.com/M2yxI.png

结合

android:textStyle="normal|bold|italic"

这 16 种变体是可能的：

常规机器人

机器人斜体

机器人粗体

Roboto 粗斜体

机器人灯

Roboto-Light 斜体

机器人薄

Roboto-Thin 斜体

机器人浓缩

Roboto-Condensed 斜体

Roboto-Condensed 粗体

Roboto-Condensed 粗斜体

机械黑

Roboto-黑色斜体

中型机器人

Roboto 中斜体

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>

---

从 Android-Studio 3.0 开始，更改字体系列非常容易

使用支持库 26，它将适用于运行 Android API 版本 16 及更高版本的设备

在 res 目录下创建一个文件夹 font。下载您想要的字体并将其粘贴到 font 文件夹中。结构应该如下所示

https://i.stack.imgur.com/eiChI.png

注意：从 Android 支持库 26.0 开始，您必须声明两组属性（ android: 和 app: ）以确保您的字体在运行 Api 26 或更低版本的设备上加载。

现在您可以使用更改布局中的字体

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"
app:fontFamily="@font/dancing_script"/>

以编程方式更改

 Typeface typeface = getResources().getFont(R.font.myfont);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
 textView.setTypeface(typeface);  

要使用 styles.xml 更改字体，请创建样式

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

并将此样式应用于 TextView

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    style="@style/Regular"/>

您还可以创建自己的字体系列

右键单击字体文件夹，然后转到新建 > 字体资源文件。将出现新建资源文件窗口。

- 输入文件名，然后单击确定。新字体资源 XML 在编辑器中打开。

例如，在此处编写您自己的字体系列

<font-family xmlns:android="http://schemas.android.com/apk/res/android">
    <font
        android:fontStyle="normal"
        android:fontWeight="400"
        android:font="@font/lobster_regular" />
    <font
        android:fontStyle="italic"
        android:fontWeight="400"
        android:font="@font/lobster_italic" />
</font-family>

这只是将特定 fontStyle 和 fontWeight 映射到将用于呈现该特定变体的字体资源。 fontStyle 的有效值是 normal 或 italic；并且 fontWeight 符合 CSS font-weight specification

1.要更改布局中的字体系列，您可以编写

 <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:fontFamily="@font/lobster"/>

2. 以编程方式更改

 Typeface typeface = getResources().getFont(R.font.lobster);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
 textView.setTypeface(typeface);  

更改整个 App 的字体在 AppTheme 添加这两行

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
     <item name="android:fontFamily">@font/your_font</item>
     <item name="fontFamily">@font/your_font</item>
  </style>

请参阅 Documentation、Android Custom Fonts Tutorial 了解更多信息

---

这是以编程方式设置字体的方法：

TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
            "fonts/epimodem.ttf");
tv.setTypeface(face);

将字体文件放在您的资产文件夹中。在我的例子中，我创建了一个名为 fonts 的子目录。

编辑：如果您想知道资产文件夹在哪里，请参阅 this question

---

我不得不在最近的一个项目中解析 /system/etc/fonts.xml。以下是 Lollipop 的当前字体系列：

╔════╦════════════════════════════╦═════════════════════════════╗
║    ║ FONT FAMILY                ║ TTF FILE                    ║
╠════╬════════════════════════════╬═════════════════════════════╣
║  1 ║ casual                     ║ ComingSoon.ttf              ║
║  2 ║ cursive                    ║ DancingScript-Regular.ttf   ║
║  3 ║ monospace                  ║ DroidSansMono.ttf           ║
║  4 ║ sans-serif                 ║ Roboto-Regular.ttf          ║
║  5 ║ sans-serif-black           ║ Roboto-Black.ttf            ║
║  6 ║ sans-serif-condensed       ║ RobotoCondensed-Regular.ttf ║
║  7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf   ║
║  8 ║ sans-serif-light           ║ Roboto-Light.ttf            ║
║  9 ║ sans-serif-medium          ║ Roboto-Medium.ttf           ║
║ 10 ║ sans-serif-smallcaps       ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin            ║ Roboto-Thin.ttf             ║
║ 12 ║ serif                      ║ NotoSerif-Regular.ttf       ║
║ 13 ║ serif-monospace            ║ CutiveMono.ttf              ║
╚════╩════════════════════════════╩═════════════════════════════╝

这是解析器（基于 FontListParser）：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.util.Xml;

/**
 * Helper class to get the current font families on an Android device.</p>
 * 
 * Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
 */
public final class FontListParser {

    private static final File FONTS_XML = new File("/system/etc/fonts.xml");

    private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");

    public static List<SystemFont> getSystemFonts() throws Exception {
        String fontsXml;
        if (FONTS_XML.exists()) {
            fontsXml = FONTS_XML.getAbsolutePath();
        } else if (SYSTEM_FONTS_XML.exists()) {
            fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
        } else {
            throw new RuntimeException("fonts.xml does not exist on this system");
        }
        Config parser = parse(new FileInputStream(fontsXml));
        List<SystemFont> fonts = new ArrayList<>();

        for (Family family : parser.families) {
            if (family.name != null) {
                Font font = null;
                for (Font f : family.fonts) {
                    font = f;
                    if (f.weight == 400) {
                        break;
                    }
                }
                SystemFont systemFont = new SystemFont(family.name, font.fontName);
                if (fonts.contains(systemFont)) {
                    continue;
                }
                fonts.add(new SystemFont(family.name, font.fontName));
            }
        }

        for (Alias alias : parser.aliases) {
            if (alias.name == null || alias.toName == null || alias.weight == 0) {
                continue;
            }
            for (Family family : parser.families) {
                if (family.name == null || !family.name.equals(alias.toName)) {
                    continue;
                }
                for (Font font : family.fonts) {
                    if (font.weight == alias.weight) {
                        fonts.add(new SystemFont(alias.name, font.fontName));
                        break;
                    }
                }
            }
        }

        if (fonts.isEmpty()) {
            throw new Exception("No system fonts found.");
        }

        Collections.sort(fonts, new Comparator<SystemFont>() {

            @Override
            public int compare(SystemFont font1, SystemFont font2) {
                return font1.name.compareToIgnoreCase(font2.name);
            }

        });

        return fonts;
    }

    public static List<SystemFont> safelyGetSystemFonts() {
        try {
            return getSystemFonts();
        } catch (Exception e) {
            String[][] defaultSystemFonts = {
                    {
                            "cursive", "DancingScript-Regular.ttf"
                    }, {
                            "monospace", "DroidSansMono.ttf"
                    }, {
                            "sans-serif", "Roboto-Regular.ttf"
                    }, {
                            "sans-serif-light", "Roboto-Light.ttf"
                    }, {
                            "sans-serif-medium", "Roboto-Medium.ttf"
                    }, {
                            "sans-serif-black", "Roboto-Black.ttf"
                    }, {
                            "sans-serif-condensed", "RobotoCondensed-Regular.ttf"
                    }, {
                            "sans-serif-thin", "Roboto-Thin.ttf"
                    }, {
                            "serif", "NotoSerif-Regular.ttf"
                    }
            };
            List<SystemFont> fonts = new ArrayList<>();
            for (String[] names : defaultSystemFonts) {
                File file = new File("/system/fonts", names[1]);
                if (file.exists()) {
                    fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
                }
            }
            return fonts;
        }
    }

    /* Parse fallback list (no names) */
    public static Config parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setInput(in, null);
            parser.nextTag();
            return readFamilies(parser);
        } finally {
            in.close();
        }
    }

    private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
        Alias alias = new Alias();
        alias.name = parser.getAttributeValue(null, "name");
        alias.toName = parser.getAttributeValue(null, "to");
        String weightStr = parser.getAttributeValue(null, "weight");
        if (weightStr == null) {
            alias.weight = 0;
        } else {
            alias.weight = Integer.parseInt(weightStr);
        }
        skip(parser); // alias tag is empty, ignore any contents and consume end tag
        return alias;
    }

    private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        Config config = new Config();
        parser.require(XmlPullParser.START_TAG, null, "familyset");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            if (parser.getName().equals("family")) {
                config.families.add(readFamily(parser));
            } else if (parser.getName().equals("alias")) {
                config.aliases.add(readAlias(parser));
            } else {
                skip(parser);
            }
        }
        return config;
    }

    private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        String name = parser.getAttributeValue(null, "name");
        String lang = parser.getAttributeValue(null, "lang");
        String variant = parser.getAttributeValue(null, "variant");
        List<Font> fonts = new ArrayList<Font>();
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String tag = parser.getName();
            if (tag.equals("font")) {
                String weightStr = parser.getAttributeValue(null, "weight");
                int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
                boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
                String filename = parser.nextText();
                String fullFilename = "/system/fonts/" + filename;
                fonts.add(new Font(fullFilename, weight, isItalic));
            } else {
                skip(parser);
            }
        }
        return new Family(name, fonts, lang, variant);
    }

    private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
        int depth = 1;
        while (depth > 0) {
            switch (parser.next()) {
            case XmlPullParser.START_TAG:
                depth++;
                break;
            case XmlPullParser.END_TAG:
                depth--;
                break;
            }
        }
    }

    private FontListParser() {

    }

    public static class Alias {

        public String name;

        public String toName;

        public int weight;
    }

    public static class Config {

        public List<Alias> aliases;

        public List<Family> families;

        Config() {
            families = new ArrayList<Family>();
            aliases = new ArrayList<Alias>();
        }

    }

    public static class Family {

        public List<Font> fonts;

        public String lang;

        public String name;

        public String variant;

        public Family(String name, List<Font> fonts, String lang, String variant) {
            this.name = name;
            this.fonts = fonts;
            this.lang = lang;
            this.variant = variant;
        }

    }

    public static class Font {

        public String fontName;

        public boolean isItalic;

        public int weight;

        Font(String fontName, int weight, boolean isItalic) {
            this.fontName = fontName;
            this.weight = weight;
            this.isItalic = isItalic;
        }

    }

    public static class SystemFont {

        public String name;

        public String path;

        public SystemFont(String name, String path) {
            this.name = name;
            this.path = path;
        }

    }
}

随意在您的项目中使用上述类。例如，您可以为用户提供一系列字体系列并根据他们的偏好设置字体。

一个不完整的小例子：

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
    items[i] = fonts.get(i).name;
}

new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        FontListParser.SystemFont selectedFont = fonts.get(which);
        // TODO: do something with the font
        Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
    }
}).show();

---

Android 不允许您从 XML 布局设置自定义字体。相反，您必须将特定字体文件捆绑在应用程序的资产文件夹中，并以编程方式进行设置。就像是：

TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);

请注意，您只能在调用 setContentView() 后运行此代码。此外，Android 仅支持某些字体，应采用 .ttf (TrueType) 或 .otf (OpenType) 格式。即使这样，某些字体也可能无法使用。

This 是一种绝对适用于 Android 的字体，您可以使用它来确认您的代码是否正常工作，以防您的字体文件不受 Android 支持。

Android O 更新：现在可以使用 XML in Android O，根据 Roger 的评论。

---

以编程方式设置 Roboto：

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));

---

如果你想要以编程方式，你可以使用

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

您可以在哪里使用 SANS_SERIF：

默认

DEFAULT_BOLD

等空间

无衬线字体

衬线体

您可以在哪里使用 ITALIC：

大胆的

加粗斜体

斜体

普通的

全部说明on Android Developers

---

Kotlin Code - Textview 从资源文件夹设置自定义字体

从 res -> font -> avenir_next_regular.ttf 设置自定义字体

textView!!.typeface = ResourcesCompat.getFont(context!!, R.font.avenir_next_regular)

---

与 android:typeface 相同。

内置字体有：

普通的

无

衬线

等宽

请参阅android:typeface。

---

一种简单的方法是在项目中添加所需的字体。

转到文件->新建->新建资源目录选择字体

这将在您的资源中创建一个新目录字体。

下载您的字体 (.ttf)。我同样使用 https://fonts.google.com

将其添加到您的字体文件夹，然后在 XML 中或以编程方式使用它们。

XML -

<TextView 
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>

以编程方式 -

 Typeface typeface = ResourcesCompat.getFont(this, R.font.your_font);
 textView.setTypeface(typeface); 

---

我认为我为时已晚，但也许这个解决方案对其他人有帮助。要使用自定义字体，请将字体文件放在字体目录中。

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

---

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

以编程方式轻松将字体设置为 res>字体目录中的任何 textview

---

我正在使用 Chris Jenx 的优秀库 Calligraphy，旨在让您在 Android 应用程序中使用自定义字体。试试看！

---

你想要的是不可能的。您必须需要在代码中设置 TypeFace。

在 XML 中，您可以做的是

android:typeface="sans" | "serif" | "monospace"

除此之外，你不能在 XML 中使用字体。 :)

对于 Arial，您需要在代码中设置字体。

---

管理字体的一种简单方法是通过资源声明它们，如下所示：

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>

<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>

<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

这是基于源代码 here 和 here

---

动态地，您可以使用这个在 xml 中设置类似于 android:fontFamily 的 fontfamily，

For Custom font:

 TextView tv = ((TextView) v.findViewById(R.id.select_item_title));
 Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf"); 
 tv.setTypeface(face);

For Default font:

 tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

这些是使用的默认字体系列列表，通过替换双引号字符串“sans-serif-medium”来使用其中的任何一个

FONT FAMILY                    TTF FILE                    

1  casual                      ComingSoon.ttf              
2  cursive                     DancingScript-Regular.ttf   
3  monospace                   DroidSansMono.ttf           
4  sans-serif                  Roboto-Regular.ttf          
5  sans-serif-black            Roboto-Black.ttf            
6  sans-serif-condensed        RobotoCondensed-Regular.ttf 
7  sans-serif-condensed-light  RobotoCondensed-Light.ttf   
8  sans-serif-light            Roboto-Light.ttf            
9  sans-serif-medium           Roboto-Medium.ttf           
10  sans-serif-smallcaps       CarroisGothicSC-Regular.ttf 
11  sans-serif-thin            Roboto-Thin.ttf             
12  serif                      NotoSerif-Regular.ttf       
13  serif-monospace            CutiveMono.ttf              

“mycustomfont.ttf”是 ttf 文件。 路径将在 src/assets/fonts/mycustomfont.ttf 中，您可以在此Default font family中参考更多关于默认字体的信息

---

如果您使用的是 Android Studio 3.5+，更改字体非常简单。在设计视图中选择文本小部件并在属性窗口中检查字体系列。值下拉列表包含所有可用的字体，您可以从中选择一种。如果您正在寻找 Google 字体，请单击更多字体选项。

https://i.stack.imgur.com/7E1xn.png

https://i.stack.imgur.com/xzUjM.png

---

您也可以通过在 res 目录下添加一个字体文件夹来做到这一点，如下所示。

https://i.stack.imgur.com/F4Dj3.png

https://i.stack.imgur.com/nEEb5.png

您可以从 https://www.1001fonts.com/ 中找到可用的字体，然后将 TTF 文件解压缩到此字体目录。

https://i.stack.imgur.com/qHX6l.png

最后，只需通过添加 android:fontFamily:"@font/urfontfilename" 来更改包含您的 textview 的 XML 文件

https://i.stack.imgur.com/FI9WW.png

---

通过一些试验和错误，我学到了以下内容。

在 *.xml 中，您可以将常用字体与以下功能结合起来，而不仅仅是字体：

 android:fontFamily="serif" 
 android:textStyle="italic"

有了这两种风格，在任何其他情况下都不需要使用字体。 fontfamily&textStyle 的组合范围更大。

---

android:fontFamily 的有效值在 /system/etc/system_fonts.xml(4.x) 或 /system/etc/fonts.xml(5.x) 中定义。但是设备制造商可能会对其进行修改，因此设置 fontFamily 值所使用的实际字体取决于指定设备的上述文件。

在 AOSP 中，Arial 字体是有效的，但必须使用“arial”而不是“Arial”来定义，例如 android:fontFamily="arial"。快速查看 Kitkat 的 system_fonts.xml

    <family>
    <nameset>
        <name>sans-serif</name>
        <name>arial</name>
        <name>helvetica</name>
        <name>tahoma</name>
        <name>verdana</name>
    </nameset>
    <fileset>
        <file>Roboto-Regular.ttf</file>
        <file>Roboto-Bold.ttf</file>
        <file>Roboto-Italic.ttf</file>
        <file>Roboto-BoldItalic.ttf</file>
    </fileset>
</family>

///////////////////////////////////////// //////////////////////

在布局中定义“字体”有三个相关的 xml 属性——android:fontFamily、android:typeface 和 android:textStyle。 “fontFamily”和“textStyle”或“typeface”和“textStyle”的组合可以用来改变文本中字体的外观，单独使用也是如此。 TextView.java 中的代码片段如下：

    private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
    Typeface tf = null;
    if (familyName != null) {
        tf = Typeface.create(familyName, styleIndex);
        if (tf != null) {
            setTypeface(tf);
            return;
        }
    }
    switch (typefaceIndex) {
        case SANS:
            tf = Typeface.SANS_SERIF;
            break;

        case SERIF:
            tf = Typeface.SERIF;
            break;

        case MONOSPACE:
            tf = Typeface.MONOSPACE;
            break;
    }
    setTypeface(tf, styleIndex);
}


    public void setTypeface(Typeface tf, int style) {
    if (style > 0) {
        if (tf == null) {
            tf = Typeface.defaultFromStyle(style);
        } else {
            tf = Typeface.create(tf, style);
        }

        setTypeface(tf);
        // now compute what (if any) algorithmic styling is needed
        int typefaceStyle = tf != null ? tf.getStyle() : 0;
        int need = style & ~typefaceStyle;
        mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
        mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
    } else {
        mTextPaint.setFakeBoldText(false);
        mTextPaint.setTextSkewX(0);
        setTypeface(tf);
    }
}

从代码中我们可以看到：

如果设置了“fontFamily”，则“字体”将被忽略。 “字体”具有标准和有限的有效值。实际上，这些值是“normal”“sans”“serif”和“monospace”，它们可以在 system_fonts.xml(4.x) 或 fonts.xml(5.x) 中找到。实际上“normal”和“sans”都是系统的默认字体。 “fontFamily”可用于设置内置字体的所有字体，而“typeface”仅提供“sans-serif”“serif”和“monospace”（世界三大类字体类型）的典型字体.当只设置“textStyle”时，我们实际上设置了默认字体和指定样式。有效值为“正常”“粗体”“斜体”和“粗体|斜体”。

---

尝试这个：

TextView textview = (TextView) findViewById(R.id.textview);
Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);

---

要通过程序设置字体，请编写...

 TextView tv7 = new TextView(this);
 tv7.setText(" TIME ");    
 tv7.setTypeface(Typeface.create("sans-serif-condensed",Typeface.BOLD));
 tv7.setTextSize(12);
 tbrow.addView(tv7);

名称“sans-serif-condensed”是从 fonts.xml 文件中引用的，该文件应该在 app--> res--> values 文件夹中创建，并且其中包含字体。

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>

希望这很清楚！

---

这是一种在某些情况下可以使用的更简单的方法。原理是在你的xml布局中添加一个不可见的TextVview，并在java代码中获取它的typeFace。

xml文件中的布局：

<TextView
    android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
    android:layout_width="0dp"
    android:layout_height="0dp"
    android:fontFamily="sans-serif-thin"
    android:id="@+id/textViewDescription"/>

和java代码：

myText.setTypeface(textViewSelectedDescription.getTypeface());

它对我有用（例如在 TextSwitcher 中）。

---

<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>

---

如果您想在很多地方使用相同字体系列的 TextView，请扩展 TextView 类并像这样设置您的字体：-

public class ProximaNovaTextView extends TextView {
    public ProximaNovaTextView(Context context) {
        super(context);
        applyCustomFont(context);
    }
    public ProximaNovaTextView(Context context, AttributeSet attrs) {
        super(context, attrs);

        applyCustomFont(context);
    }
    public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
       super(context, attrs, defStyle);
       applyCustomFont(context);
    } 
    private void applyCustomFont(Context context) {
        Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
        setTypeface(customFont);
    }
}

然后在 XML 中为 TextView 使用这个自定义类，如下所示：-

<com.myapp.customview.ProximaNovaTextView
android:id="@+id/feed_list_item_name_tv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textSize="14sp"
/>

---

我只想提一下，Android 字体的地狱即将结束，因为今年在 Google IO 上我们终于得到了这个 -> https://developer.android.com/preview/features/working-with-fonts.html

现在有一个新的资源类型字体，您可以将所有应用程序字体放在 res/fonts 文件夹中，然后使用 R.font.my_custom_font 访问，就像您可以访问字符串 res 值、可绘制 res 值等一样。您甚至有机会创建 font-face xml 文件，该文件将设置您的自定义字体（关于斜体、粗体和下划线 attr）。

阅读上面的链接以获取更多信息。让我们看看支持。

---

您还可以使用 setTextAppearance 更改标准字体（需要 API 16），请参阅 https://stackoverflow.com/a/36301508/2914140：

<style name="styleA">
    <item name="android:fontFamily">sans-serif</item>
    <item name="android:textStyle">bold</item>
    <item name="android:textColor">?android:attr/textColorPrimary</item>
</style>
<style name="styleB">
    <item name="android:fontFamily">sans-serif-light</item>
    <item name="android:textStyle">normal</item>
    <item name="android:textColor">?android:attr/textColorTertiary</item>
</style>


if(condition){
    TextViewCompat.setTextAppearance(textView, R.style.styleA);
} else {
    TextViewCompat.setTextAppearance(textView,R.style.styleB);
}

---

新的字体资源允许使用直接设置 font

android:fontFamily="@font/my_font_in_font_folder"

---

您可以像这样定义自定义 FontFamily：

/res/font/usual.xml：

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:tools="http://schemas.android.com/tools"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    tools:ignore="UnusedAttribute">
    <font
        android:fontStyle="normal"
        android:fontWeight="200"
        android:font="@font/usual_regular"
        app:fontStyle="normal"
        app:fontWeight="200"
        app:font="@font/usual_regular" />

    <font
        android:fontStyle="italic"
        android:fontWeight="200"
        android:font="@font/usual_regular_italic"
        app:fontStyle="italic"
        app:fontWeight="200"
        app:font="@font/usual_regular_italic" />

    <font
        android:fontStyle="normal"
        android:fontWeight="600"
        android:font="@font/usual_bold"
        app:fontStyle="normal"
        app:fontWeight="600"
        app:font="@font/usual_bold" />

    <font
        android:fontStyle="italic"
        android:fontWeight="600"
        android:font="@font/usual_bold_italic"
        app:fontStyle="italic"
        app:fontWeight="600"
        app:font="@font/usual_bold_italic" />
</font-family>

现在你可以做

android:fontFamily="@font/usual"

假设您的其他 font 资源也在那里，带有小写字母和 _。

---

您像这样在 res/layout/value/style.xml 中设置样式：

<style name="boldText">
    <item name="android:textStyle">bold|italic</item>
    <item name="android:textColor">#FFFFFF</item>
</style>

并在 main.xml 文件中使用此样式：

style="@style/boldText"

---