Comment utiliser la programmation d'agents Unicode en Java

Accès séquentiel

L'accès séquentiel est une opération de base pour le traitement des chaînes dans le langage Java. Dans le cadre de cette approche, chaque caractère de la chaîne d'entrée est accessible séquentiellement du début à la fin, ou parfois de la fin au début. Cette section présente sept exemples techniques de création d'un tableau de points de code de 32 bits à partir d'une chaîne à l'aide de méthodes d'accès séquentiel et estime leur temps de traitement.

Exemple 1-1 : Benchmark (aucune paire de substitution prise en charge)

Listing 1 Affectation d'une valeur de type char 16 bits directement à 32 bits Valeurs de points de code, ne prenant pas du tout en compte les paires de substitution :

Listing 1. Aucune paire de substitution prise en charge

int[] toCodePointArray(String str) { // Example 1-1      int len = str.length();          // the length of str      int[] acp = new int[len];        // an array of code points       for (int i = 0, j = 0; i <p>Bien que cet exemple ne le fasse pas prend en charge les paires de substitution, mais il fournit une référence de temps de traitement à comparer aux exemples d'accès séquentiel ultérieurs. </p><p><strong>Exemple 1-2 : Utilisation de isSurrogatePair()</strong></p><p>Listing 2 Utilisez isSurrogatePair() pour calculer le nombre total de paires de substitution. Après le comptage, il alloue suffisamment de mémoire pour qu'un tableau de bits de code stocke la valeur. Il entre ensuite dans une boucle d'accès séquentiel, en utilisant isHighSurrogate() et isLowSurrogate() pour déterminer si chaque caractère de paire de substitution est un substitut haut ou bas. Lorsqu'il trouve un substitut élevé suivi d'un substitut faible, il utilise toCodePoint() pour convertir la paire de substituts en une valeur de point de code et incrémente la valeur d'index actuelle de 2. Sinon, il attribue la valeur du type char directement à une valeur de point de code et incrémente la valeur d'index actuelle de 1. Le traitement de cet exemple prend 1,38 fois plus de temps que celui de l'exemple 1-1. </p><p><strong>Listing 2. Support limité</strong></p><pre class="brush:php;toolbar:false">int[] toCodePointArray(String str) { // Example 1-2      int len = str.length();          // the length of str      int[] acp;                       // an array of code points      int surrogatePairCount = 0;      // the count of surrogate pairs       for (int i = 1; i <p>L'approche de la mise à jour des logiciels dans le Listing 2 est enfantine. Il est fastidieux et nécessite des modifications importantes, ce qui rend le logiciel résultant fragile et difficile à modifier à l'avenir. Plus précisément, ces problèmes sont : </p><p>◆Le nombre de points de code doit être calculé pour allouer suffisamment de mémoire</p><p>◆Il est difficile d'obtenir les points de code corrects pour un index donné dans une chaîne Valeur </p><p>◆Il est difficile de déplacer correctement l'index actuel pour la prochaine étape de traitement </p><p> Un algorithme amélioré apparaît dans l'exemple suivant. </p><p><strong>Exemple : Prise en charge de base</strong></p><p>Java 1.5 fournit les méthodes codePointCount(), codePointAt() et offsetByCodePoints() pour gérer l'exemple 1, respectivement. 2 questions sur 3. Le listing 3 utilise ces méthodes pour améliorer la lisibilité de cet algorithme : </p><p><strong>Listing 3. Support de base</strong></p><pre class="brush:php;toolbar:false">int[] toCodePointArray(String str) { // Example 1-3      int len = str.length();          // the length of str      int[] acp = new int[str.codePointCount(0, len)];       for (int i = 0, j = 0; i <p>Cependant, le traitement du listing 3 Cela prend 2,8 fois plus de temps que le listing 1. </p><p><strong>Exemple 1-4 : Utilisation de codePointBefore()</strong></p><p>Lorsque offsetByCodePoints() reçoit un nombre négatif comme deuxième paramètre, il peut calculer un décalage absolu depuis le début de la chaîne. Ensuite, codePointBefore() peut renvoyer la valeur du point de code avant un index spécifié. Ces méthodes sont utilisées pour parcourir la chaîne de la fin au début dans le listing 4 : </p><p><strong>Listing 4. Prise en charge de base en utilisant codePointBefore() Le temps de traitement de cet exemple - 2,72 fois plus long que celui de l'exemple 1-1 - est légèrement plus rapide que l'exemple 1-3. En règle générale, lorsque vous comparez des valeurs nulles au lieu de valeurs non nulles, la taille du code dans la JVM est plus petite, ce qui améliore parfois les performances. Cependant, cette petite amélioration ne vaut peut-être pas la peine de sacrifier la lisibilité. </strong></p><p>Exemple 1 à 5 : Utilisation de charCount()</p><p><strong>Les exemples 1 à 3 et 1 à 4 fournissent une prise en charge de base des paires de substitution. Ils ne nécessitent aucune variable temporaire et constituent des méthodes de codage robustes. Pour accélérer le temps de traitement, utiliser charCount() au lieu de offsetByCodePoints() est efficace, mais nécessite une variable temporaire pour contenir la valeur du point de code, comme indiqué dans le listing 5 : </strong></p><p> Listing 5 . Grâce à la prise en charge optimisée de charCount()</p><p></p><pre class="brush:php;toolbar:false">int[] toCodePointArray(String str) { // Example 1-4      int len = str.length();          // the length of str      int[] acp = new int[str.codePointCount(0, len)];      int j = acp.length;              // an index for acp       for (int i = len; i > 0; i = str.offsetByCodePoints(i, -1)) {          acp[--j] = str.codePointBefore(i);      }      return acp;  }

Le temps de traitement du listing 5 est réduit à 1,68 fois plus long que celui de l'exemple 1-1.

Exemple 1-6 : Accéder à un tableau de caractères

Listing 6 Accéder directement à un tableau de caractères tout en utilisant l'optimisation présentée dans l'exemple 1-5 Tableau de type char :

Listing 6. Prise en charge optimisée de l'utilisation d'un tableau de caractères

int[] toCodePointArray(String str) { // Example 1-5      int len = str.length();          // the length of str      int[] acp = new int[str.codePointCount(0, len)];      int j = 0;                       // an index for acp       for (int i = 0, cp; i <strong>char le tableau est copié à partir d'une chaîne à l'aide de toCharArray( ) est venu. Les performances sont améliorées car l'accès direct à la baie est plus rapide que l'accès indirect via une méthode. Le temps de traitement est 1,51 fois plus long que celui de l'exemple 1-1. Cependant, lorsqu'il est appelé, toCharArray() nécessite une certaine surcharge pour créer un nouveau tableau et copier les données dans le tableau. Les méthodes pratiques fournies par la classe String ne peuvent pas non plus être utilisées. Cependant, cet algorithme est utile lorsqu’il s’agit de grandes quantités de données. </strong><p>Exemple 1 à 7 : Un algorithme orienté objet </p><p><strong>L'algorithme orienté objet de cet exemple utilise la classe CharBuffer, comme indiqué dans Listing 7 : </strong></p><p>Listing 7. Algorithme orienté objet utilisant CharSequence</p><p></p><pre class="brush:php;toolbar:false">int[] toCodePointArray(String str) { // Example 1-6      char[] ach = str.toCharArray();  // a char array copied from str      int len = ach.length;            // the length of ach      int[] acp = new int[Character.codePointCount(ach, 0, len)];      int j = 0;                       // an index for acp       for (int i = 0, cp; i <strong>Contrairement à l'exemple précédent, le Listing 7 ne nécessite pas d'index pour conserver l’emplacement actuel pour un accès séquentiel. Au lieu de cela, CharBuffer suit en interne la position actuelle. La classe Character fournit les méthodes statiques codePointCount() et codePointAt(), qui gèrent les CharBuffers via l'interface CharSequence. CharBuffer définit toujours la position actuelle en tête de CharSequence. Par conséquent, lorsque codePointAt() est appelé, le deuxième paramètre est toujours défini sur 0. Le temps de traitement est 2,15 fois plus long que celui de l'exemple 1-1. </strong><h3 id="yisu3h-to77">处理时间比较</h3><p>这些顺序访问示例的计时测试使用了一个包含 10,000 个代理对和 10,000 个非代理对的样例字符串。码位数组从这个字符串创建 10,000 次。测试环境包括：</p><p>◆OS：Microsoft Windows® XP Professional SP2</p><p>◆Java：IBM Java 1.5 SR7</p><p>◆CPU：Intel® Core 2 Duo CPU T8300 @ 2.40GHz</p><p>◆Memory：2.97GB RAM</p><p>表 1 展示了示例 1-1 到 1-7 的绝对和相对处理时间以及关联的 API：</p><p><strong>表 1. 顺序访问示例的处理时间和 API</strong></p><p><img src="https://img.php.cn/upload/article/000/000/164/168337700010075.gif" alt="Comment utiliser la programmation dagents Unicode en Java"></p><h3 id="yisu3h-to88">随机访问</h3><p>随机访问是直接访问一个字符串中的任意位置。当字符串被访问时，索引值基于 16 位 char 类型的单位。但是，如果一个字符串使用 32 位码位，那么它不能使用一个基于 32 位码位的单位的索引访问。必须使用 offsetByCodePoints() 来将码位的索引转换为 char 类型的索引。如果算法设计很糟糕，这会导致很差的性能，因为 offsetByCodePoints() 总是通过使用第二个参数从第一个参数计算字符串的内部。在这个小节中，我将比较三个示例，它们通过使用一个短单位来分割一个长字符串。</p><p><strong>示例 2-1：基准测试（不支持代理对）</strong></p><p>清单 8 展示如何使用一个宽度单位来分割一个字符串。这个基准测试留作后用，不支持代理对。</p><p><strong>清单 8. 不支持代理对</strong></p><pre class="brush:php;toolbar:false">String[] sliceString(String str, int width) { // Example 2-1      // It must be that "str != null && width > 0".      List<string> slices = new ArrayList<string>();      int len = str.length();       // (1) the length of str      int sliceLimit = len - width; // (2) Do not slice beyond here.      int pos = 0;                  // the current position per char type       while (pos <p>sliceLimit 变量对分割位置有所限制，以避免在剩余的字符串不足以分割当前宽度单位时抛出一个 IndexOutOfBoundsException 实例。这种算法在当前位置超出 sliceLimit 时从 while 循环中跳出后再处理最后的分割。</p>
<p><strong>示例 2-2：使用一个码位索引</strong></p>
<p>清单 9 展示了如何使用一个码位索引来随机访问一个字符串：</p>
<p><strong>清单 9. 糟糕的性能</strong></p>
<pre class="brush:php;toolbar:false">String[] sliceString(String str, int width) { // Example 2-2      // It must be that "str != null && width > 0".      List<string> slices = new ArrayList<string>();      int len = str.codePointCount(0, str.length()); // (1) code point count [Modified]      int sliceLimit = len - width; // (2) Do not slice beyond here.      int pos = 0;                  // the current position per code point       while (pos <p>清单 9 修改了 清单 8 中的几行。首先，在 Line (1) 中，length() 被 codePointCount() 替代。其次，在 Lines (3)、(4) 和 (6) 中，char 类型的索引通过 offsetByCodePoints() 用码位索引替代。</p>
<p>基本的算法流与 示例 2-1 中的看起来几乎一样。但处理时间根据字符串长度与示例 2-1 的比率同比增加，因为 offsetByCodePoints() 总是从字符串头到指定索引计算字符串内部。</p>
<p><strong>示例 2-3：减少的处理时间</strong></p>
<p>可以使用清单 10 中展示的方法来避免 示例 2-2 的性能问题：</p>
<p><strong>清单 10. 改进的性能</strong></p>
<pre class="brush:php;toolbar:false">String[] sliceString(String str, int width) { // Example 2-3      // It must be that "str != null && width > 0".      List<string> slices = new ArrayList<string>();      int len = str.length(); // (1) the length of str      int sliceLimit          // (2) Do not slice beyond here. [Modified]              = (len >= width * 2 || str.codePointCount(0, len) > width)              ? str.offsetByCodePoints(len, -width) : 0;      int pos = 0;            // the current position per char type       while (pos <p>首先，在 Line (2) 中，（清单 9 中的）表达式 len-width 被 offsetByCodePoints(len,-width) 替代。但是，当 width 的值大于码位的数量时，这会抛出一个 IndexOutOfBoundsException 实例。必须考虑边界条件以避免异常，使用一个带有 try/catch 异常处理程序的子句将是另一个解决方案。如果表达式 len>width*2 为 true，则可以安全地调用 offsetByCodePoints()，因为即使所有码位都被转换为代理对，码位的数量仍会超过 width 的值。或者，如果 codePointCount(0,len)>width 为 true，也可以安全地调用 offsetByCodePoints()。如果是其他情况，sliceLimit 必须设置为 0。</p>
<p>在 Line (4) 中，清单 9 中的表达式 pos + width 必须在 while 循环中使用 offsetByCodePoints(pos,width) 替换。需要计算的量位于 width 的值中，因为第一个参数指定当 width 的值。接下来，在 Line (5) 中，表达式 pos+=width 必须使用表达式 pos=end 替换。这避免两次调用 offsetByCodePoints() 来计算相同的索引。源代码可以被进一步修改以最小化处理时间。</p>
<h3 id="yisu3h-to116">处理时间比较</h3>
<p>图 1 和图 2 展示了示例 2-1、2-2 和 2-3 的处理时间。样例字符串包含相同数量的代理对和非代理对。当字符串的长度和 width 的值被更改时，样例字符串被切割 10,000 次。</p>
<p><img src="https://img.php.cn/upload/article/000/000/164/168337700040575.png" alt="Comment utiliser la programmation dagents Unicode en Java"></p>
<p><strong>图 1. 一个分段的常量宽度</strong></p>
<p><img src="https://img.php.cn/upload/article/000/000/164/168337700041405.png" alt="Comment utiliser la programmation dagents Unicode en Java"></p>
<p><strong>图 2. 分段的常量计数</strong></p>
<p>示例 2-1 和 2-3 按照长度比例增加了它们的处理时间，但 示例 2-2 按照长度的平方比例增加了处理时间。当字符串长度和 width 的值增加而分段的数量固定时，示例 2-1 拥有一个常量处理时间，而示例 2-2 和 2-3 以 width 的值为比例增加了它们的处理时间。</p>
<h3 id="yisu3h-to127">信息 API</h3>
<p>大多数处理代理的信息 API 拥有两种名称相同的方法。一种接收 16 位 char 类型参数，另一种接收 32 为码位参数。表 2 展示了每个 API 的返回值。第三列针对 U+53F1，第 4 列针对 U+20B9F，最后一列针对 U+D842（即高代理），而 U+20B9F 被转换为 U+D842 加上 U+DF9F 的代理对。如果程序不能处理代理对，则值 U+D842 而不是 U+20B9F 将导致意想不到的结果（在表 2 中以粗斜体表示）。</p>
<p><strong>表 2. 用于代理的信息 API</strong></p>
<p><img src="https://img.php.cn/upload/article/000/000/164/168337700086359.gif" alt="Comment utiliser la programmation dagents Unicode en Java"></p>
<h3 id="yisu3h-to133">其他 API</h3>
<p>本小节介绍前面的小节中没有讨论的代理对相关 API。表 3 展示所有这些剩余的 API。所有代理对 API 都包含在表 1、2 和 3 中。</p>
<p><strong>表 3. 其他代理 API</strong></p>
<p><img src="https://img.php.cn/upload/article/000/000/164/168337700025390.gif" alt="Comment utiliser la programmation dagents Unicode en Java"></p>
<p>清单 11 展示了从一个码位创建一个字符串的 5 种方法。用于测试的码位是 U+53F1 和 U+20B9F，它们在一个字符串中重复了 100 亿次。清单 11 中的注释部分显示了处理时间：</p>
<p><strong>清单 11. 从一个码位创建一个字符串的 5 种方法</strong></p>
<pre class="brush:php;toolbar:false">int cp = 0x20b9f; // CJK Ideograph Extension B  String str1 = new String(new int[]{cp}, 0, 1);    // processing time: 206ms  String str2 = new String(Character.toChars(cp));                  //  187ms  String str3 = String.valueOf(Character.toChars(cp));              //  195ms  String str4 = new StringBuilder().appendCodePoint(cp).toString(); //  269ms  String str5 = String.format("%c", cp);                            // 3781ms

str1、str2、str3 和 str4 的处理时间没有明显不同。相反，创建 str5 花费的时间要长得多，因为它使用 String.format()，该方法支持基于本地和格式化信息的灵活输出。str5 方法应该只用于程序的末尾来输出文本。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!