皮皮网

1.【Java必修课】判断String是否包含子串的四种方法及性能对比
2.java中indexOf();的使用。
3.java 中ArrayList集合用indexof方法返回元素的索引 如果元素是重复的 应该返回哪个索引？
4.java indexOf()
5.java中怎么判断一个字符串中包含某个字符或字符串
6.java 中如何使用INDEX OF()

【Java必修课】判断String是否包含子串的四种方法及性能对比

       判断一个字符串是否包含某个特定子串是常见的场景，比如判断一篇文章是否包含敏感词汇、判断日志是否有ERROR信息等。本文将介绍四种方法并进行性能测试。

       在String的函数中，提供了indexOf（subStr）方法，java 画图工具源码返回子串subStr第一次出现的位置，如果不存在则返回-1。例子如下：

       最直观判断的方法是contains（subStr），返回类型为boolean，如果包含返回true，不包含则返回false。例子如下：

       实际上，String的contains方法是通过调用indexOf方法来判断的，源码如下：

       通过强大的正则匹配来判断，虽然有点杀鸡用牛刀的感觉，但也不是ssm分页源码下载不能用，例子如下：

       Apache的commons-lang3提供许多开箱即用的功能，StringUtils就提供了许多与字符串相关的功能，例子如下：

       我们使用JMH工具来对四种方法进行性能测试，Maven引入代码如下：

       测试代码如下：

       测试结果如下：

       最快的就是indexOf方法，其次是contains方法，二者应该没有实际区别，contains是调用indexOf来实现的。Apache的免费java商城源码StringUtils为第三方库，相对慢一些。最慢的是使用了正则的Pattern的方法，这不难理解，正则引擎的匹配是比较耗性能的。

       本文介绍了判断一个字符串是否包含某个特定子串的四种方法，并通过性能测试进行了对比。其中性能最好的是String的indexOf方法和contains方法，建议使用contains方法，mysql读写分离源码性能好，跟indexOf相比，更直观，更不容易犯错。毕竟让每个人时刻记住返回-1代表不存在也不是一件容易的事。

       但是，使用indexOf和contains方法都需要注意做判空处理，这时StringUtils的网页post网页源码优势就体现出来了。

       总结，四种方法如下：

       indexOf（subStr）：返回子串第一次出现的位置，不存在返回-1。

       contains（subStr）：返回true或false，是否包含。

       Pattern匹配：使用正则匹配，相对耗性能。

       StringUtils.contains：Apache库提供，相对慢。

       性能测试结果显示，indexOf和contains方法最佳，建议使用contains方法。Apache库的StringUtils方法相对慢，正则匹配方法最慢。在使用方法时，注意处理空值问题。希望本文能帮助你更好地理解和使用这些方法。

java中indexOf();的使用。

       è§£é‡Šå†™åœ¨æ³¨é‡Šé‡Œé¢ï¼š

public class Finallypractice {

           public static void main(String[] args) {

               ArrayList<String> a = new ArrayList<String>();

               a.add(0, "zero");

               a.add(1, "one");

               a.add(2, "two");

               a.add(3, "three");

               printAl(a); // æ­¤æ—¶a的元素是：zero one two three

               if (a.contains("three")) {

                   a.add("four"); // æ­¤æ—¶a的元素是：zero one two three four

               }

               // remove(int index):移除此列表中指定位置上的元素(a中的索引为2的元素是：two)

               a.remove(2);

               printAl(a); // æ­¤æ—¶a的元素是：zero, one, three, fours

               // indexOf: è¿”回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1

               if (a.indexOf("four") != 4) {

                   a.add(4, "4.2"); // æ­¤æ—¶a的元素是：zero one three four 4.2

                   System.out.println(a.indexOf("four")); // æ­¤åˆ—表中首次出现four的索引是3(从0开始)

               }

               printAl(a);

               if (a.contains("two")) {

                   a.add("2.2");

               }

               printAl(a);

           }

           public static void printAl(ArrayList<String> al) {

               for (String element : al) {

                   System.out.print(element + " ");

               }

               System.out.println(" ");

           }

       }

java 中ArrayList集合用indexof方法返回元素的索引 如果元素是重复的 应该返回哪个索引？

       以下是indexOf的源代码,可以看出, 是从0往后找,找到就返回

        /

**

        * Returns the index of the first occurrence of the specified element

        * in this list, or -1 if this list does not contain the element.

        * More formally, returns the lowest index <tt>i</tt> such that

        * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,

        * or -1 if there is no such index.

        */

        public int indexOf(Object o) {

        if (o == null) {

        for (int i = 0; i < size; i++)

        if (elementData[i]==null)

        return i;

        } else {

        for (int i = 0; i < size; i++)

        if (o.equals(elementData[i]))

        return i;

        }

        return -1;

        }

java indexOf()

       å‘µå‘µ,我就爱凑热闹,我给个更好的解决方法

       åŒ¿åæ˜¯æ€•åˆ«äººç¬‘话我抢分~好方法不能独自享用

       //: IndexTest.java

       public class IndexTest {

        public static void main(String[] args) {

        String test = "@@@";

        char c = '@';

        int index = 0;

        int count =0;

        //单个字符串搜索

        while((index=nextIndex(test,c,index))>-1){

        System.out.print(index+" ");

        ++index;

        ++count;

        }

        System.out.println("\n共找到匹配 '"+c+"' 的地方 "+count+" 处.");

        index=0;

        count=0;

        String test2 = "abcabdabecdbdedfdecef";

        String str = "de";

        //字符串搜索

        while((index=nextIndex(test2,str,index))>-1){

        System.out.print(index+" ");

        index+=str.length();//

        ++count;

        }

        System.out.println("\n共找到匹配 '"+str+"' 的地方 "+count+" 处.");

        }

        //一个字符

        public static int nextIndex(String src,char search,int preIndex){

        return src.indexOf(search,preIndex);

        }

        //一个字符串

        public static int nextIndex(String src,String search,int preIndex){

        return src.indexOf(search,preIndex);

        }

       }

java中怎么判断一个字符串中包含某个字符或字符串

       在Java中，要检查一个字符串是否包含特定的字符或子串，你可以使用`indexOf()`方法。这个方法会在字符串中查找指定子串，并返回第一次出现的位置。如果找到，返回的值将不为-1，否则返回-1。以下是一个简单的示例：

       在Java编程中，如果你想判断一个字符串是否包含某个字符或字符串，你可以使用`String`类的`indexOf()`方法。例如，如果你有一个字符串`String str = "ABC_";`，你可以这样进行检查：

       java

       public static void main(String[] args) {

        String str = "ABC_";

        if (str.indexOf("ABC") != -1) {

        这表明字符串`str`中包含了子串"ABC"，系统会输出"包含"。

        } else {

       如果`indexOf()`返回-1，那么字符串`str`中不包含"ABC"，系统会输出"不包含"。

        }

       }

       通过这种方式，你可以轻松地在Java程序中实现字符串的包含检查。

java 中如何使用INDEX OF()

       public class Test{

        public static void main(String[] args){

        String s = "Hello World!";

        // 1. indexOf(int ch)

        System.out.println("s.indexOf('o')=" + s.indexOf('o')); //返回 4

        //2. indexOf(int ch, int fromIndex)

        System.out.println("s.indexOf('o',6)=" + s.indexOf('o',6)); //返回7

        //3. indexOf(String str)

        System.out.println("s.indexOf(\"llo\")=" + s.indexOf("llo")); //返回 2

        //4. indexOf(String str, int fromIndex)

        System.out.println("s.indexOf(\"llo\", 5)=" + s.indexOf("llo", 5)); //返回 -1

        }

       }

       å…·ä½“indexOf的定义，请参考API文档。 满意请采纳。