indexOf（String.indexOf 方法）

indexOf（String.indexOf 方法）

字符串的IndexOf()方法搜索在该字符串上是否出现了作为參数传递的字符串,假设找到字符串,则返回字符的起始位置 (0表示第一个字符,1表示第二个字符依此类推)假设说没有找到则返回 -1

返回 String 对象内第一次出现子字符串的字符位置。

[code=csharp]public indexOf(value:String, [startIndex:Number]) : Number[/code]

搜索字符串，并返回在调用字符串内 startIndex 位置上或之后找到的 value 的第一个匹配项的位置。此索引从零開始，这意味着字符串中的第一个字符被视为位于索引 0 而不是索引 1 处。假设未找到 value，该方法会返回 -1。

參数value:String - 一个字符串；要搜索的子字符串。

startIndex:Number [可选] - 一个整数，指定搜索的開始索引。

返回Number - 指定子字符串的第一个匹配项的位置，或 -1。

--------------------------------------------------------------------------------------------------------------------------------------------------

indexOf 方法 

返回 String 对象内第一次出现子字符串的字符位置。

strObj.indexOf(subString[, startIndex])

參数 

strObj

必选项。String 对象或文字。

subString 

必选项。要在 String 对象中查找的子字符串。

starIndex 

可选项。该整数值指出在 String 对象内開始查找的索引。假设省略，则从字符串的開始处查找。

说明 

indexOf 方法返回一个整数值，指出 String 对象内子字符串的開始位置。假设没有找到子字符串，则返回 -1。

假设 startindex 是负数，则 startindex 被当作零。假设它比最大的字符位置索引还大，则它被当作最大的可能索引。

从左向右运行查找。否则，该方法与 lastIndexOf 同样。

演示样例 

以下的演示样例说明了 indexOf 方法的使用方法。

function IndexDemo(str2){
var str1 = "BABEBIBOBUBABEBIBOBU"
var s = str1.indexOf(str2);
return(s);
}

实例:

我获得一个字符串a为 "1,18,33"

假设写成 a indexOf("1") 好象查不出来 更重要的是 18和1前面都有个1所以成立的条件不准确 请问应该怎么写啊

indexOf这样用

string test = "1,18,33";
if (test.IndexOf("1") > -1)
{
     Response.Write("存在");
}
else
{
     Response.Write("不存在");
}

可是假设说仅仅有1符合要求，而18中的1不符合要求，那不能用IndexOf来做，这样

using System.Text.RegularExpressions;
string test = "1,18,33";
if (Regex .IsMatch(test, @"\b1\b"))
{
     Response.Write("存在");
}
else
{
     Response.Write("不存在");
}

凝视:

\b 在正则中匹配一个单词边界

写了一个方法

//src　源字符串
//tar　待比較字符串
private bool CheckString(string src, string tar)
{
     string temp = Regex.Replace(tar, @"[.$^{\[(|)*+?\\]", "");
     if (temp.Length < tar.Length)
         return false;
     if (Regex.IsMatch(src, @"\b" + tar + @"\b"))
         return true;
     return false;
}

String是不变类，用String改动字符串会新建一个String对象，假设频繁的改动，将会产生非常多的String对象，开销非常大.因此java提供了一个StringBuffer类，这个类在改动字符串方面的效率比String高了非常多。

在java中有3个类来负责字符的操作。

1.Character 是进行单个字符操作的，

2.String 对一串字符进行操作。不可变类。

3.StringBuffer 也是对一串字符进行操作，可是可变类。

[java] view
plaincopy

  1. public class UsingStringBuffer {
  2. /**
  3. * 查找匹配字符串
  4. */
  5. public static void testFindStr() {
  6. StringBuffer sb = new StringBuffer();
  7. sb.append("This is a StringBuffer");
  8. // 返回子字符串在字符串中最先出现的位置，假设不存在，返回负数
  9. System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is"));
  10. // 给indexOf方法设置參数，指定匹配的起始位置
  11. System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is", 3));
  12. // 返回子字符串在字符串中最后出现的位置，假设不存在，返回负数
  13. System.out.println("sb.lastIndexOf(\"is\") = " + sb.lastIndexOf("is"));
  14. // 给lastIndexOf方法设置參数，指定匹配的结束位置
  15. System.out.println("sb.lastIndexOf(\"is\", 1) = "
  16. + sb.lastIndexOf("is", 1));
  17. }
  18. /**
  19. * 截取字符串
  20. */
  21. public static void testSubStr() {
  22. StringBuffer sb = new StringBuffer();
  23. sb.append("This is a StringBuffer");
  24. // 默认的终止位置为字符串的末尾
  25. System.out.print("sb.substring(4)=" + sb.substring(4));
  26. // substring方法截取字符串，能够指定截取的起始位置和终止位置
  27. System.out.print("sb.substring(4,9)=" + sb.substring(4, 9));
  28. }
  29. /**
  30. * 获取字符串中某个位置的字符
  31. */
  32. public static void testCharAtStr() {
  33. StringBuffer sb = new StringBuffer("This is a StringBuffer");
  34. System.out.println(sb.charAt(sb.length() - 1));
  35. }
  36. /**
  37. * 加入各种类型的数据到字符串的尾部
  38. */
  39. public static void testAppend() {
  40. StringBuffer sb = new StringBuffer("This is a StringBuffer!");
  41. sb.append(1.23f);
  42. System.out.println(sb.toString());
  43. }
  44. /**
  45. * 删除字符串中的数据
  46. */
  47. public static void testDelete() {
  48. StringBuffer sb = new StringBuffer("This is a StringBuffer!");
  49. sb.delete(0, 5);
  50. sb.deleteCharAt(sb.length() - 1);
  51. System.out.println(sb.toString());
  52. }
  53. /**
  54. * 向字符串中插入各种类型的数据
  55. */
  56. public static void testInsert() {
  57. StringBuffer sb = new StringBuffer("This is a StringBuffer!");
  58. // 可以在指定位置插入字符、字符数组、字符串以及各种数字和布尔值
  59. sb.insert(2, ‘W‘);
  60. sb.insert(3, new char[] { ‘A‘, ‘B‘, ‘C‘ });
  61. sb.insert(8, "abc");
  62. sb.insert(2, 3);
  63. sb.insert(3, 2.3f);
  64. sb.insert(6, 3.75d);
  65. sb.insert(5, 9843L);
  66. sb.insert(2, true);
  67. System.out.println("testInsert: " + sb.toString());
  68. }
  69. /**
  70. * 替换字符串中的某些字符
  71. */
  72. public static void testReplace() {
  73. StringBuffer sb = new StringBuffer("This is a StringBuffer!");
  74. // 将字符串中某段字符替换成还有一个字符串
  75. sb.replace(10, sb.length(), "Integer");
  76. System.out.println("testReplace: " + sb.toString());
  77. }
  78. /**
  79. * 将字符串倒序
  80. */
  81. public static void reverseStr() {
  82. StringBuffer sb = new StringBuffer("This is a StringBuffer!");
  83. System.out.println(sb.reverse()); // reverse方法将字符串倒序
  84. }
  85. }

小结：

StringBuffer不是不变类，在改动字符串内容时，不会创建新的对象，因此，它比String类更适合改动字符串。

StringBuffer类没有提供同String一样的toCharArray方法

StringBuffer类的replace方法同String类的replace方法不同,它的replace方法有三个參数,第一个參数指定被替换子串的起始位置，第二个參数指定被替换子串的终止位置，第三个參数指定新子串

时间： 2024-11-08 12:06:18

indexOf（String.indexOf 方法）的相关文章

String.IndexOf String.IndexOf String.Substring

String.IndexOf String.IndexOf 方法 (Char, Int32, Int32)报告指定字符在此实例中的第一个匹配项的索引.搜索从指定字符位置开始,并检查指定数量的字符位置.String.IndexOf(value, startIndex, count) 参数value:要查找的 Unicode 字符. startIndex:搜索起始位置. count:要检查的字符位置数.返回值(Int32):如果找到该字符,则为 value 的索引位置:否则如果未找到,则为 -1.

c# String.IndexOf 方法 string查找字符串

c# String.IndexOf 方法 (value, [startIndex], [count]) 报告指定字符在此实例中的第一个匹配项的索引.搜索从指定字符位置开始,并检查指定数量的字符位置. 参数 value 要查找的 Unicode 字符. 对 value 的搜索区分大小写. startIndex(Int32) 可选项,搜索起始位置.不设置则从0开始. count(Int32) 可选项,要检查的字符位数. 返回值 如果找到该字符,则为 value 的索引位置:否则如果未找到,则为 -1

String.indexOf()的使用方法

String.indexOf()的用途: 返回此字符串中第一个出现的指定的子字符串,如果没有找到则返回-1 源码如下: /** * Returns the index within this string of the first occurrence of the * specified substring. * * <p>The returned index is the smallest value <i>k</i> for which: * <blockq

Java中字符串indexof() 的使用方法

Java中字符串中子串的查找共有四种方法(indexof()) indexOf 方法返回一个整数值,指出 String 对象内子字符串的开始位置.如果没有找到子字符串,则返回-1.如果 startindex 是负数,则 startindex 被当作零.如果它比最大的字符位置索引还大,则它被当作最大的可能索引. Java中字符串中子串的查找共有四种方法,如下:1.int indexOf(String str) :返回第一次出现的指定子字符串在此字符串中的索引. 2.int indexOf(Stri

字符串查找String.IndexOf

String.indexOf的模拟实现,没想象中有多么高深的查找算法,就是最普通的遍历查找 思路:先找到第一个相同的字符,然后依次比较后面的字符,若都相等则表示查找成功 /** * 查找字符串pattern在str中第一次出现的位置 * @param str * @param pattern * @return */ public int firstIndexOf(String str, String pattern) { for (int i = 0; i < (str.length() -

java.lang.String.indexOf()用法

java.lang.String.indexOf(char ch) 方法返回字符ch在指定字符串中第一次出现的下标索引位置 如果字符ch在指定的字符串中找不到,则返回-1 示例: import java.lang.*; public class StringDemo { public static void main(String[] args) { String str = "This is tanglc's cnblog"; // returns the index of char

字符串中判断存在的几种模式和效率(string.contains、string.IndexOf、Regex.Match)

通常情况下,我们判断一个字符串中是否存在某值常常会用string.contains,其实判断一个字符串中存在某值的方法有很多种,最常用的就是前述所说的string.contains,相对来说比较常用的还有string.IndexOf和Regex.Match.直接上代码,后面在说些什么吧,通常情况下功能的实现最重要,作者的话,只对有心者有效. using System; using System.Collections.Generic; using System.Linq; using Syste

java中String.indexOf()用法

查找指定字符或字符串在字符串中第一次出现地方的索引,未找到的情况返回 -1. 例如 String.indexOf(String str) String str1="012345"; String str2="23"; System.out.println( str1.indexOf(str2) ); 输出结果:2. 重载方法有 String.indexOf(String str,int index) 从index的地方开始找,返回第一次出现的索引 String st

JavaScript服务器端高级编程（Array.indexOf()和lastIndexOf()方法）

语法格式: array.indexOf(searchElement[, fromIndex]); array.lastIndexOf(searchElement[, fromIndex]); 功能:返回某个指定的元素值在数组中首次出现的位置.该方法将从头到尾地检索数组,看它是否含有元素searchElement.开始检索的位置在数组的fromIndex处或数组的开头(没有指定fromIndex时).如果找到一个相匹配的元素,则返回此元素的第一次出现的位置.如果没有找到,则返回-1. 注意:las