package Object.hashCode;
/*
* set集合是通过比较hashCode判断对象是否相同的，hashCode相同时，再用equals 比较是否相等，
* equals比较的是对象的内容，==比较的是对象的引用，详见附件
*/
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add(new Student(1, "zhangsan"));
hs.add(new Student(2, "lisi"));
hs.add(new Student(3, "wangwu"));
hs.add(new Student(1, "zhangsan"));
Iterator it = hs.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
class Student {
int num;
String name;
Student(int num, String name) {
this.num = num;
this.name = name;
}
public String toString() {
return num + ":" + name;
}
public int hashCode() {
return num * name.hashCode();
//return 1;
}
public boolean equals(Object o) {
Student s = (Student) o;
return num == s.num && name.equals(s.name);
}
}
package Object.hashCode;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Stringhash {
public static void main(String[] args) {
String s1 = new String("zhaoxudong");
String s2 = new String("zhaoxudong");
System.out.println(s1 == s2);// false 引用不相等
System.out.println(s1.equals(s2));// true
System.out.println(s1.hashCode());// s1.hashcode()等于s2.hashcode()
System.out.println(s2.hashCode());
Set hashset = new HashSet();
hashset.add(s1);
hashset.add(s2); // 加不进去
Iterator it = hashset.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
String s3 = "ying";
String s4 = "ying";
System.out.println(s3 == s4);// true 引用相等
}
}
package Object.string;
public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = "Monday";
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
}
}
/**
java中equals和==的区别
值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
==比较的是2个对象的地址，而equals比较的是2个对象的内容。
显然，当equals为true时，==不一定为true；
*/
package Object.string;
public class TestString2 {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
if (s1.equals(s2))
System.out.println("s1 equals s2");
else
System.out.println("s1 not equals s2");
}
}
/**
原来，程序在运行的时候会创建一个字符串缓冲池
当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会
在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被
放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1
将 s2 引用 s1 所引用的对象"Monday"
第二段程序中，使用了 new 操作符，他明白的告诉程序：
"我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创
建在内存中。他们的值相同，但是位置不同，一个在池中游泳
*/
package Object.string;
public class TestString3 {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
s2 = s2.intern();
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
if (s1.equals(s2))
System.out.println("s1 equals s2");
else
System.out.println("s1 not equals s2");
}
}
package Object.integer;
public class TestInteger2 {
//在jdk1.5以上的版本中，基本类型和封装类能自动转化，与String类型的对象和字符串常量类似。
public static void main(String args[]) {
Integer i1 = 123;
Integer i2 = 123;
int i = 123;
Integer i3 = new Integer(123);
Integer i4 = new Integer(123);
System.out.println("------------------注意------------------------");
System.out.println("i == i2 = " + (i == i2));//true
System.out.println("i1.equals(i) = " + (i1.equals(i)));
System.out.println();
System.out.println("i == i4 = " + (i == i4));//true
System.out.println("i4.equals(i) = " + (i4.equals(i)));
System.out.println();
System.out.println("i1 == i2 = " + (i1 == i2));//t
System.out.println("i1.equals(i2) = " + (i1.equals(i2)));
System.out.println();
System.out.println("i3 == i4 = " + (i3 == i4));
System.out.println("i3.equals(i4) = " + (i3.equals(i4)));
System.out.println();
System.out.println("i2 == i4 = " + (i2 == i4));
System.out.println("i2.equals(i4) = " + (i2.equals(i4)));
}
}