java乱炖

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

ArrayList<String> arrayList = new ArrayList<String>(10);

System.out.println(arrayList.size());

大家猜，打印结果会是什么？会是10吗？

答案：0

因为，new ArrayList<String>(10)，只是告诉jvm分配10个Stirng的空间出来，arrayList 不是null而已。此时的arrayList 无任何内容！

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

为什么说JDK中处理String的indexOf()方法效率低，建议不要使用？今天探了个究竟。

上源码！

static int indexOf(char[] source, int sourceOffset, int sourceCount,

            char[] target, int targetOffset, int targetCount,

            int fromIndex) {

        if (fromIndex >= sourceCount) {

            return (targetCount == 0 ? sourceCount : -1);

        }

        if (fromIndex < 0) {

            fromIndex = 0;

        }

        if (targetCount == 0) {

            return fromIndex;

        }

        char first = target[targetOffset];

        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {

            /* Look for first character. */

            if (source[i] != first) {

                while (++i <= max && source[i] != first);

            }

            /* Found first character, now look at the rest of v2 */

            if (i <= max) {

                int j = i + 1;

                int end = j + targetCount - 1;

                for (int k = targetOffset + 1; j < end && source[j]

                        == target[k]; j++, k++);

                if (j == end) {

                    /* Found whole string. */

                    return i - sourceOffset;

                }

            }

        }

        return -1;

    }

真整齐啊！

上来就看到了两个for循环。问题必然出在这里！和KMP算法不同，这明显是简单粗暴的loop index。为什么没采用复杂度为O(m+n)的KMP算法？估计时间问题吧。

以后注意尽量避免indexOf()方法。

顺便窥探了下subString()方法的实现：

上源码！

public String substring(int beginIndex) {

        if (beginIndex < 0) {

            throw new StringIndexOutOfBoundsException(beginIndex);

        }

        int subLen = value.length - beginIndex;

        if (subLen < 0) {

            throw new StringIndexOutOfBoundsException(subLen);

        }

        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);

    }

public String(char value[], int offset, int count) {

        if (offset < 0) {

            throw new StringIndexOutOfBoundsException(offset);

        }

        if (count < 0) {

            throw new StringIndexOutOfBoundsException(count);

        }

        // Note: offset or count might be near -1>>>1.

        if (offset > value.length - count) {

            throw new StringIndexOutOfBoundsException(offset + count);

        }

        this.value = Arrays.copyOfRange(value, offset, offset+count);

    }

怪不得效率较高，原来用到了Arrays.copyOfRange()方法。

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

一道非常老的面试题：

从字符串str1中找出子字符串str2出现的次数。比如：

String str1 = "sgiccomcocmcomomameadjcomfjecomcomcomcijr";

String str2 = "com";

自己想到的方法如下：

//暴力匹配

//KMP算法

//subString

//split

//RegEx(may be the best)

这其中，RegEx（正则匹配）的效率是最高的（个人理解）。而且实现起来也很简单，如下：

String str1 = "sgiccomcocmcomomameadjcomfjecomcomcomcijr";

String str2 = "com";

int times = 0;

Pattern pattern = Pattern.compile(str2);

Matcher matcher = pattern.matcher(str1);

while (matcher.find()) {

        times++;

        System.out.println(matcher.group());

    }

System.out.println(times);

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

7/30

刚刚正在探索KMP算法，然后有经验的同事过来看看究竟。不过扯出了另外一个话题，正则的效率不一定高！用他的话说，java代码需要JVM进行解释，那正则表达式也是需要解释器的（可以这么理解），所以效率很可能会低的。

另外，String类中也存在matches()方法，遂对该方法和Pattern中的matches()进行了对比。

代码如下：

public static void main(String[] args){

        String string = "ddenfj#@fe_dw.comw";

        int count = 100000;

        long before = System.currentTimeMillis();

        Runtime runtime = Runtime.getRuntime();

        long r1 = runtime.totalMemory();

        for (int i = 0; i < count; i++) {

            string.matches("^([\\.a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\\.[a-zA-Z0-9_-]{2,3}){1,2})$");

        }

        long r2 = runtime.totalMemory();

        long end = System.currentTimeMillis();

        System.out.println("the memory of match() in String is = " + (r2-r1)/1024);

        System.out.println("the time of match() in String is = " + (end-before));

        //Pattern

        Pattern pattern = Pattern.compile("^([\\.a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\\.[a-zA-Z0-9_-]{2,3}){1,2})$");

        before = System.currentTimeMillis();

        r1 = runtime.totalMemory();

        for (int i = 0; i < count; i++) {

            pattern.matcher(string).matches();

        }

        r2 = runtime.totalMemory();

        end = System.currentTimeMillis();

        System.out.println("the memory of match() in Pattern is = " + (r2-r1)/1024);

        System.out.println("the time of match() in Pattern is = " + (end-before));

    }

在count=100000的情况下，发现结果如下：

the memory of match() in String is = 92416

the time of match() in String is = 327

the memory of match() in Pattern is = 0

the time of match() in Pattern is = 26

结果让我吃惊！String类中的matches()方法相对于Pattern类中的matches()方法，简直不能用！

究其原因：String类中的matches()方法调用了Pattern.matches(regex, this)，而该方法的实现如下：

public static boolean matches(String regex, CharSequence input) {

        Pattern p = Pattern.compile(regex);

        Matcher m = p.matcher(input);

        return m.matches();

    }

强调部分的重复执行会占用大量内存。

而且该方法的解释中：If a pattern is to be used multiple times, compiling it once and reusing it will be more efficient than invoking this method each time.

总之，String类中的matches()方法不要使用！

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

今天同事问了个问题：不同版本的jar包，能同时存在吗？如果能的话，应该加载的哪个？

做了个实验，把poi-3.10-beta2.jar和poi-3.10-FINAL.jar（我把名称改为chris.jar）放在lib文件夹下，编译没错，证明可以共存。

但是使用哪个jar包呢？最新的。怎么区分最新的？根据版本号？

最后证明编译器仍然使用chris.jar下的class文件。

结论：当不同版本的jar包共存时，编译器将根据class的时间以及META-INF下的信息区分哪个jar包是最新的，并加载之。

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

巴特西

java乱炖

最新文章

热门文章