C++博客-Thinking in zmllegtui.-随笔分类-Java Techhttp://www.cppblog.com/zmllegtui/category/8635.htmlStuff in my mind.zh-cnSun, 26 Oct 2008 09:05:24 GMTSun, 26 Oct 2008 09:05:24 GMT60面试或笔试题目要点（Java）http://www.cppblog.com/zmllegtui/archive/2008/10/26/65081.htmlzml_cnnkzml_cnnkSun, 26 Oct 2008 05:36:00 GMThttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65081.htmlhttp://www.cppblog.com/zmllegtui/comments/65081.htmlhttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65081.html#Feedback0http://www.cppblog.com/zmllegtui/comments/commentRss/65081.htmlhttp://www.cppblog.com/zmllegtui/services/trackbacks/65081.html2.字符串的操作：
写一个方法，实现字符串的反转，如：输入abc，输出cba
写一个方法，实现字符串的替换，如：输入bbbwlirbbb，输出bbbhhtccc。
……

  阅读全文

zml_cnnk 2008-10-26 13:36 发表评论
]]>== 与 equals 的区别（Java）http://www.cppblog.com/zmllegtui/archive/2008/10/26/65077.htmlzml_cnnkzml_cnnkSun, 26 Oct 2008 04:59:00 GMThttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65077.htmlhttp://www.cppblog.com/zmllegtui/comments/65077.htmlhttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65077.html#Feedback0http://www.cppblog.com/zmllegtui/comments/commentRss/65077.htmlhttp://www.cppblog.com/zmllegtui/services/trackbacks/65077.html      在比较字符型数据时，==比较的是内存中的地址,比较的是对象的句柄；而equals()比较的是地址内的内容,比较的是对象。由于JAVA中除基本数据类型外其它一切都是对象，而对象变量存储的都是引用，相当于C中的指针，所以在比较对象时如String，用==是比较两个变量是否指向同一个对象，而用equals才是比较两个String的内容是否相等。
      ==绝对比equals快。
      ==是java内置的，可以理解为"相同"。对于简单类型来说，a=3，b=3，我们可以说a和b相同，也可以说a和b相等，都没什么问题。.equals()是Object的方法，可以理解为"相等"。显然两个object相等并不意味着相同；但是需要注意的是，也并不意味着他们对应内存区域的所有字节都相等，比如（但不限于这个原因）他们内部可能还有自己的引用。所以，两个对象是否相等，只有这个对象自己才知道如何判断，java并不知道。所以就需要类自己提供一个equals方法。下面举例说明：

题目：
  Integer   i   =   new   Integer(42)  
  Long   l   =   new   Long(42)  
  Double   d   =   new   Double(42.0)  
  下面哪些返回true  
  1:   i==l  
  2:   i==d  
  3:   l==d  
  4:   i.equals(l)  
  5:   i.equals(d)  
  6:   l.equals(d)  
  7:   i.equals(42)  
答案：7；

编码验证：
public   class   Equivalence   {    
   public   static   void   main(String[]   args)   {  
      Integer   i   =   new   Integer(42)  
      Long   l   =   new   Long(42)  
      Double   d   =   new   Double(42.0)  
      System.out.println(i==l);  
      System.out.println(i==d);
      System.out.println(l==d);  
      System.out.println(i.equals(l) );   
      System.out.println(i.equals(d) );
      System.out.println(l.equals(d) );  
      System.out.println(i.equals(42));
  }  
} 

运行结果：
1-3：编译不通过；
4-6：false
7:true

原理解释：
1.   检查对象是否相等
关系运算符==和!=也适用于所有对象，但它们的含义通常会使初涉Java领域的人找不到北。下面是一个例子：
//:   Equivalence.java  
public   class   Equivalence   {  
   public   static   void   main(String[]   args)   {  
      Integer   n1   =   new   Integer(47);  
      Integer   n2   =   new   Integer(47);  
      System.out.println(n1   ==   n2);  
      System.out.println(n1   !=   n2);  
   }  
}   ///:~
      其中，表达式System.out.println(n1 == n2)可打印出内部的布尔比较结果。一般人都会认为输出结果肯定先是true，再是false，因为两个Integer对象都是相同的。但尽管对象的内容相同，句柄却是不同的，而==和!=比较的正好就是对象句柄。所以输出结果实际上先是false，再是true。这自然会使第一次接触的人感到惊奇。
      若想对比两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法equals()。但这个方法不适用于“主类型”，那些类型直接使用==和!=即可。下面举例说明如何使用：
//:   EqualsMethod.java 
public   class   EqualsMethod   {  
   public   static   void   main(String[]   args)   {  
      Integer   n1   =   new   Integer(47);  
      Integer   n2   =   new   Integer(47);  
      System.out.println(n1.equals(n2));  
   }  
}   ///:~  
正如我们预计的那样，此时得到的结果是true。但事情并未到此结束！假设您创建了自己的类，就象下面这样：
//:   EqualsMethod2.java 
class   Value   {  
   int   i;  
}
public   class   EqualsMethod2   {  
   public   static   void   main(String[]   args)   {  
      Value   v1   =   new   Value();  
      Value   v2   =   new   Value();  
      v1.i   =   v2.i   =   100;  
      System.out.println(v1.equals(v2));  
   }  
}   ///:~  
此时的结果又变回了false！这是由于equals()的默认行为是比较句柄。所以除非在自己的新类中改变了equals()，否则不可能表现出我们希望的行为。但要注意equals()的这种行为方式同时或许能够避免一些“灾难”性的事件。     
      大多数Java类库都实现了equals()，所以它实际比较的是对象的内容，而非它们的句柄。
      在java中内存分为“栈”和“堆”(Stack   and   Heap) ，基本数据类型存储在"栈"中，对象引用类型实际存储在"堆"中，在“栈”中只是保留引用内存的地址值，就好像知道你家门牌号码就可以找到你家。在Java中利用"=="比较变量时候，系统使用变量在stack(栈)中所存的值来作为对比的依据，基本数据类型（int   float   double   boolean）在stack中所存的值就是其內容值，而引用类型在stack中所存放的值是本身所指向Heap中对象的地址值，而不是原先所設定的值。

PS  
1：
      ==基本类型之间的比较包括int,short,reference等  
      equals()是对象之间的比较，缺省（Object中）的是对象引用的比较，但是可以重载。  
2：
      equals()和==在语义上是不同的，==是作为标识符嵌入到java语言的语法中，
      而equals()是作为一个类方法实现。java的指称语义，必须描述==，但是不用描述equals()方法。

zml_cnnk 2008-10-26 12:59 发表评论
]]>栈内存与堆内存（Java）http://www.cppblog.com/zmllegtui/archive/2008/10/26/65075.htmlzml_cnnkzml_cnnkSun, 26 Oct 2008 04:11:00 GMThttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65075.htmlhttp://www.cppblog.com/zmllegtui/comments/65075.htmlhttp://www.cppblog.com/zmllegtui/archive/2008/10/26/65075.html#Feedback0http://www.cppblog.com/zmllegtui/comments/commentRss/65075.htmlhttp://www.cppblog.com/zmllegtui/services/trackbacks/65075.html      Java把内存划分成两种：一种是栈内存，一种是堆内存。  
    
      在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。   

      堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。  引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
      
      具体的说：栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
 
      Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 

      栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3;
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b，它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

      String是一个特殊的包装类数据。可以用：
String str = new String("abc");
String str = "abc";
两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。

      比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一个对象的。
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的对象。每一次生成一个。 

      因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

      练习：
以下code生成几个String对象
   String a="abc";
   String b="abc";
   String c=new String("abc");
   String d=c.intern();

   String a="abc";                                    
   String b="abc";                                     
   String c=new String("abc");                
   String d=c.intern();                               这句是关键！！

如果仅仅是这样
   String c=new String("abc");                 
   String d=c.intern();             
c == d？结果是 false；因为引用变量c指向堆内存的地址；但是intern(); 却在栈中开辟了一块内存。

对于本题来讲：c.intern(); 执行时，在栈内存中发现存在对象“abc”，所以直接将指针指向“abc”，这样 a == d, b==d 结果为true;

zml_cnnk 2008-10-26 12:11 发表评论
]]>