答题送分活动一

我们在学习Java基础时，有些知识点是我们没有注意到的，例如：
举例一：
FileInputStream(String filePath)
FileInputStream(File file)
第一个构造的源码其实也是将filePath封装成File对象

举例二：
ByteArrayStream这个流中的close()方法写不写都是无所谓了，源码中这个方法也是没有方法体的

举例三：
有个集合中存储的数据类型是字符串，我们一般都写一个比较器去对这些字符串进行比较字符串长度之类的，但是有些人想为什么不去重写String中compareTo方法？
在API中我发现String是final修饰的，根本就无法去继承，更谈不上重写了。

举例四：
观察集合中contains方法源码，其实底层调用的equals方法


举例五：
Properties是Map体系的，但是Properties却不是泛型类。

其他的，等你们来写...

这些细枝末节的东西我们可能没去注意到，但是理解了这些东西，有助于我们的学习更加深入。

答题规则：
       写出你在学习中观察源码或者API之后发现的一些跟上面举例类似有趣东西，分享给我们，回帖比较好的有技术分送哦！
       还有强调一点不要有水贴，否则"关小屋"。

本人技术有限，以上例子若是有错误，你们可以向我提出qq：2905090240
活动还会继续，敬请期待...

System.out.println(char[] chs)输出结果为字符数组中的所有字符，而不是数组的地址。通过源码，发现，其底层是：OutputStream中的write(int a)，所以结果是所有字符。

还没看到这里，==再说。

逗号操作符；

1. public class Test {
   
2.        
   
3.         public void method() {
   
4.                 for(int i=0, j=i+2; i<10; i++, j=j*2) {
   
5.                         System.out.println("i = " + i + " j = " + j);
   
6.                 }
   
7.         }
   
8. }

复制代码

for循环中，“，”后面的语句会独立执行。
     

java规定私有的东西不能被外界访问，要真想访问也有一道后门那就是通过暴力反射强暴它一把！
就要调用setAccessable方法，将其改为true。

感觉都好厉害，我这个新手0基础的怎搞，何时才能赶上

我就来说说基本类型包装类的valueOf吧，下面用Integer为例：

1. 
   
2.                 /*1*///true
   
3.                 Integer i1 = Integer.valueOf(1);
   
4.                 Integer i2 = Integer.valueOf(1);
   
5.                 System.out.println(i1==i2);
   
6.                
   
7.                 /*2*///false
   
8.                 i1 = new Integer(1);
   
9.                 i2 = new Integer(1);
   
10.                 System.out.println(i1==i2);
    
11.                
    
12.                 /*3*///false
    
13.                 i1 = new Integer(1);
    
14.                 i2 = Integer.valueOf(1);
    
15.                 System.out.println(i1==i2);
    
16.                
    
17.                 //了解过自动拆箱和装箱的同学都知道 Integer i = 1 其实就等同于 Integer i = Integer.valueOf(1);所以只有这三种

复制代码

其实我是查阅了源码才有根本上的理解的，如下：

1. public static Integer valueOf(int i) {
   
2.         if (i >= IntegerCache.low && i <= IntegerCache.high)
   
3.             return IntegerCache.cache[i + (-IntegerCache.low)];
   
4.         return new Integer(i);
   
5.     }

复制代码

上面是Integer类里面valueOf的源码，Interger类中有一个内部内为IntegerCache意思就是缓存嘛，我们先不说它源码，只看cache;

1. private static class IntegerCache {
   
2.         static final int low = -128;
   
3.         static final int high;
   
4.         static final Integer cache[];
   
5.         ......
   
6.     }

复制代码

代码的意思是显而易见的cache是Integer类型的数组，cache本身就是缓存的意思，所以valueOf就是在指定范围内返回cache缓存中的值，超出范围则new一个，若当1存在于缓存cache中，上文的3个结果也就明了了IntegerCache.low==-128我们都知道了，下面我去深究下IntegerCache.high到底有多大，源码附上：

1. static {
   
2.     // high value may be configured by property
   
3.     int h = 127;-------------------------------------------------------------------1
   
4.     String integerCacheHighPropValue =
   
5.         sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
   
6.     if (integerCacheHighPropValue != null) {
   
7.         try {
   
8.             int i = parseInt(integerCacheHighPropValue);
   
9.             i = Math.max(i, 127);
   
10.             // Maximum array size is Integer.MAX_VALUE
    
11.             h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    
12.         } catch( NumberFormatException nfe) {
    
13.             // If the property cannot be parsed into an int, ignore it.
    
14.         }
    
15.     }
    
16.     high = h;-----------------------------------------------------------------------2
    
17. 
    
18.     cache = new Integer[(high - low) + 1];
    
19.     int j = low;
    
20.     for(int k = 0; k < cache.length; k++)
    
21.         cache[k] = new Integer(j++);
    
22. 
    
23.     // range [-128, 127] must be interned (JLS7 5.1.7)
    
24.     assert IntegerCache.high >= 127;
    
25. }

复制代码

这是IntegerCache中的静态代码块，在类加载的时候执行一次，我们直接看---1和---2处，中间代码不管，整个结构就只是给high赋值，循环建立从low到high大小的cache缓存数组，很简单吧，下面再看看1---2中间部分，我用注释的方式写出：

1. String integerCacheHighPropValue =
   
2.     sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");//读取javaInteger缓存最大值配置，默认127
   
3. if (integerCacheHighPropValue != null) {
   
4.     try {
   
5.         int i = parseInt(integerCacheHighPropValue);
   
6.         i = Math.max(i, 127); //若自行配制的最大值小于127，就取127
   
7.         // Maximum array size is Integer.MAX_VALUE
   
8.         h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
   
9.         //这是Integer前面定义的常量public static final int MAX_VALUE = 0x7fffffff;
   
10.         //若自行配制的最大值上限还是有限制的最大为：Integer.MAX_VALUE - (-low) -1
    
11.     } catch( NumberFormatException nfe) {
    
12.         // If the property cannot be parsed into an int, ignore it.
    
13.     }
    
14. }
    
15. assert IntegerCache.high >= 127; //断言函数，自行百度

复制代码

最后：-D可以设置java.lang.Integer.IntegerCache.high
谢阅

terator对集合类中的任何一个实现类，都可以返回一个Iterator对象。就和循环一样，好处是可以适用于任何一个类，而且比直接用index访问快一点。

Integer m = 128                                        Integer m = 127;
Integer n = 128;                                        Integer n = 127;
m==n?false,两个对象                                m==n?true,指向了同一个
当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟空间。

1. for(int x=10;x>1;;)
   
2. int x=15

复制代码

正确

1. for(int x=10;x>1;;)
   
2. x=15

复制代码

错误，循环中的变量在括号外无效

1. double x=10
   
2. while(x!=9.00)
   
3. {
   
4. x-=0.01
   
5. }

复制代码

死循环，浮点数比较，精确到具体的二进制位，各个二进制位相等才算相等，浮点数表示的是近似值，不能用于比较

1. // private方法都隐式地被指定为final的，但是当你覆盖一个private方法时，却能顺利通过编译：
   
2.     class Father {
   
3.         void Method1() {}
   
4.         final void Method2() {}
   
5.         private void Method3() {} // 相当于 private final void method3() {}
   
6.     }
   
7.    
   
8.     class Son extends Father {
   
9.         void Method1() {} // 通过。正常覆盖
   
10.         void Method2() {} // 报错。无法覆盖被final修饰的方法
    
11.         void Method3() {} // 通过。
    
12.         /*  其实，父类中的private方法对子类是不可见的，
    
13.             子类中的Method3()并没有覆盖父类中的方法而是一个新的方法，
    
14.             只不过恰好与父类中的private方法同名。
    
15.         
    
16.             之前我还不太理解为什么在覆盖时，子类方法的权限不能比父类方法的小，
    
17.             理解上述例子之后才知道原因所在。
    
18.         */
    
19.     }

复制代码

最近发现的JDK7的新功能：

1. // 可以在数值字面值中使用下划线，如：
   
2. int i = 1_000_000;
   
3. double d = 9.000_001;
   
4. // 以上都是合法的代码，编译器会自行忽略掉下划线
   
5. //还有，Java终于支持字面值的二进制表示了：
   
6. int bi = 0b101;// 我都想不通，这么简单实用的功能，C语言不支持，JAVA到了第7版才支持

复制代码

1. package pack;
   
2. class Demo implements Runnable{
   
3.         public void run(){
   
4.                 for(int x=0; x<60; x++){
   
5.                         System.out.println(Thread.currentThread().getName()+" :"+x);
   
6.                         // Thread.yield();
   
7.                 }
   
8.         }
   
9. }
   
10. class joinDemo{
    
11.         public static void main(String[] args)throws InterruptedException{
    
12.                 Demo d=new Demo();
    
13.                 Thread t1=new Thread(d);
    
14.                 Thread t2=new Thread(d);
    
15.                 t1.start();
    
16.                 t1.join();
    
17.                 t2.start();
    
18.         }
    
19. }

复制代码

join:当t2线程执行到了t1线程的join方法时，t2就会等待，等t1线程都执行完，t2才会执行。
join可以用来临时加入线程。
发小了个小现象。就是要插入的线程必须放在其他线程的上面并且后面要跟的是join。这样才能正确的打印完你要插入的线程。
不知道我说的对不对。不过挺有意思的。

菜鸟一个，完全看不懂

1. short a = 1;
   
2. a = a + 1；//报错
   
3. a += 1; // 通过

复制代码

a += 1之所以通过是因为使用复合赋值运算符时编译器已自动强转

邓士林 发表于 2015-2-6 11:05
还是说说==和equals，因为今天我才明白。
【==是比较对象的时候比较内存，equals底层也是用==实现】这句话 ...

我觉得这个问题只要理解了常量池的问题就不难理解了吧。栈和堆里的东西最终还是指向常量池的，只是堆里的东西是两次创建的不同String，在堆里的的地址不同，但都是指向常量池的同一个字符串常量

水水更健康!~别蜂窝啊.

try catch finally 语句中如果try中有return 而finally中也有的话，try中的是执行不到的。

qiuyuhuaihua 发表于 2015-2-6 22:57
Java 中的参数传递 值传递？or 引用传递？

Java中都是引用传递的，只有地址值被传递了