java中equals和==的区别

值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。

==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。

equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

==比较的是2个对象的地址，而equals比较的是2个对象的内容。

显然，当equals为true时，==不一定为true；

一、Str ing中的equals和==

1、

public class TestString {

public static void main(String[] args) {

String s1 = "Monday";

String s2 = "Monday";

}

上面这段程序中，到底有几个对象呢？

来检测一下吧，稍微改动一下程序

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");

}

编译并运行程序，输出：s1 == s2

说明：s1 与s2 引用同一个Str ing 对象-- "Monday"!

再稍微改动一下程序，会有更奇怪的发现：

public class TestString {

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 用new操作符创建

程序输出：

s1 != s2

s1 equals s2

说明：s1 s2分别引用了两个"Monday"Str ing对象

3. 字符串缓冲池

原来，程序在运行的时候会创建一个字符串缓冲池

当使用s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会

在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被

放到了池中，所以在s2被创建的时候，程序找到了具有相同值的s1

将s2 引用s1 所引用的对象"Monday"

第二段程序中，使用了new操作符，他明白的告诉程序：

"我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创

建在内存中。他们的值相同，但是位置不同，一个在池中游泳

一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？

再次更改程序：

public class TestString {

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");

}

这次加入：s2 = s2.intern();

程序输出：

s1 == s2

s1 equals s2

原来，（https://www.360docs.net/doc/2015876806.html,ng.String的intern()方法

"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：

检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。

）

更好的办法：

把所有的String都intern()到缓冲池去吧

最好在用到new的时候就进行这个操作

String s2 = new String("Monday").intern();

然后就可以用==比较两个字符串的值了

二、简单数据类型和封装类中的equals和==

Java为每一个简单数据类型提供了一个封装类，每个基本数据类型可以封装成对象类型。

除int（Integer）和char（Char acter），其余类型首字母大写即成封装类类型名。double (Double),

float(Float),long(Long), short(Short),byte(Byte),boolean(Boolean).

以int和Integer为例说明

Java中int和Integer区别如下：

1.int是基本的数据类型,默认值可以为0；

2.Integer是int的封装类,默认值为null；

3.int和Integer都可以表示某一个数值；

4.int和Integer不能够互用，因为他们两种不同的数据类型；

int a1=1;

int a2=1;

Integer b1 =new Integer (1);

Integer b2 =new Integer (1);

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

a1==a2 这个是成立的,很简单,都知道

a1==b1 这个是不成立的.表达式的值为false ,它们是不同的数据类型（在jdk1.5以上版本中为true）

b1==b2 这个也是不成立的.表达式的值为false,虽然是相同的数据类型,但是它们是两个对象,==比较的是2个对象的地址,它们的地址是不相等的,内容相等都是1;

b1.equals(b2)==true 这个是成立的,表达式的值为true. 相同数据类型,两个对象,地址不同,内容相同, quals比较的是2个对象的内容,所以成立。

(a.equals(b),因为equals比较的是两个对象，所以a,b都不能为基本数据类型，否则会出编译错误。)（在jdk1.5以上版本中，b可以为基本数据类型，a不可以）

同理,其它的封装类和基本类型也是这样的.

java中equals和==的区别

==比较的是2个对象的地址，而equals比较的是2个对象的内容。

在jdk1.5以上的版本中，基本类型和封装类能自动转化，与Str ing类型的对象和字符串常量类似。

Integer i1 = 123;

Integer i2 = 123;

int i = 123;

Integer i3 = new Integer(123);

Integer i4 = new Integer(123);

System.out.println("i1 == i2 = "+(i1 == i2));

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)));

System.out.println();

System.out.println("i == i2 = "+(i == i2));

System.out.println("i1.equals(i) = "+(i1.equals(i)));

System.out.println();

System.out.println("i == i4 = "+(i == i4));

System.out.println("i4.equals(i) = "+(i4.equals(i)));

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

i1 == i2 = true

i1.equals(i2) = true

i3 == i4 = false

i3.equals(i4) = true

i2 == i4 = false

i2.equals(i4) = true

i == i2 = true

i1.equals(i) = true

i == i4 = true

i4.equals(i) = true

三、其他类怎么使用equals和==

API里的类大部分都重写了equals方法，没有重写的一般是自己写的类，

如果是你自己定义的一个类，比较自定义类用equals和==是一样的，都是比较句柄地址，

因为自定义的类是继承于object，而object中的equals就是用==来实现的，你可以看源码。

四、java里equals和hashCode之间什么关系

只是为了维护hashCode 方法的常规协定,才要求用equals比较的两个对象的hashCode相同.

equals()和hashCode()都来自https://www.360docs.net/doc/2015876806.html,ng.Object.你当然可以重写.

比如a.equals(b).仅当a的内存地址相等时,才返回true.当然如String等类已经对这个方法进行了重写,比较的就不再是内存地址了.

hashCode()的值也是与内存地址相关的.所以仅当内存地址相等时,hashCode才相等.

同样很多类也重写了这个方法,还是以String为例:

public int hashCode() {

int h = hash;

if (h == 0) {

int off = offset;

char val[] = value;

int len = count;

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

h = 31*h + val[off++];

}

hash = h;

}

return h;

}

就不在与内存地址相关了.这样做是为了保证用equals比较返回为true的两个对象,他们的hashCode是相同的.

所以一般重写equals的时候都会重写hashCode().

当然,这个相当于一个约定,一个协议.你不这么做并不会错.

五、hashCode

在一般的应用中你不需要了解hashcode的用法，但当你用到hashmap，hashset等集合类时要注意下hashcode。

你想通过一个object的key来拿hashmap的value，hashmap的工作方法是，

通过你传入的object的hashcode在内存中找地址，

当找到这个地址后再通过equals方法来比较这个地址中的内容是否和你原来放进去的一样，一样就取出value。

所以这里要匹配2部分，hashcode和equals

但假如说你new一个object作为key去拿value是永远得不到结果的，

因为每次new一个object，这个object的hashcode是永远不同的，所以我们要重写hashcode，

你可以令你的hashcode是object中的一个恒量，这样永远可以通过你的object的hashcode来找到key的地址，然后你要重写你的equals方法，使内存中的内容也相等。。。

基数词与序数词的区别和用法(细整理)电子教案

英语中基数词与序数词的区别和用法一、数词的分类 1. 基数词表示数目的词称为基数词。其形式如下： A．从1——10 one，two，three，four，five，six，seven，eight，nine，ten． B．从11——19 eleven，twelve，thirteen，fourteen，fifteen，sixteen，seventeen，eighteen，nineteen 这里除eleven，twelve，thirteen，fifteen，eighteen为特殊形式外，fourteen，sixteen，seventeen，nineteen都是由其个位数形式后添加后缀-teen构成。 C．从21——99 整数几十中除twenty，thirty, forty，fifty，eighty为特殊形式外，sixty，seventy，ninety都是其个位数形式后添加后缀-ty构成。表示几十几时，在几十和个位基数词形式之间添加连字符“-” 21 twenty-one 76 seventy-six D．百位数个数基数词形式加“hundred”，表示几百，在几十几与百位间加上and． 101 a hundred and one 320 three hundred and twenty 648 six hundred and forty-eight E．千位数以上从数字的右端向左端数起，每三位数加一个逗号“，”。从右开始，第一个“，”前的数字后添加thousand，第二个“，”前面的数字后添加million，第三个“，”前的数字后添加billion。然后一节一节分别表示，两个逗号之间最大的数为百位数形式。 2,648 two thousand six hundred and forty-eight 16,250,064 sixteen million two hundred and fifty thousand sixty-four 5,237,166,234 five billion，two hundred and thirty-seven million，one hundred and sixty-six thousand，two hundred and thirty-four F．基数词在表示确切的数字时，不能使用百、千、百万、十亿的复数形式；但是，当基数词表示不确切数字，如成百、成千上万，三三两两时，基数词则以复数形式出现。 There are hundreds of people in the hall．大厅里有数以百计的人。 Thousands and thousands of people come to visit the Museum of Qin Terracotta Warriors and Horses every day．每天有成千上万的人来参观秦兵马涌博物馆。 They went to the theatre in twos and threes．他们三三两两地来到了剧院。

hashCode与equals的区别与联系(经典)

hashCode与equals的区别与联系(经典) 一、equals方法的作用1、默认情况（没有覆盖equals 方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。2 、要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。没有覆盖equals方法代码如下：[java] view plaincopy//学生类public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; https://www.360docs.net/doc/2015876806.html, = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { https://www.360docs.net/doc/2015876806.html, = name; } } 测试代码如下：[java] view plaincopyimport java.util.HashSet; import java.util.LinkedList; import java.util.Set; public class EqualsTest { public static void main(String[]

Java中关于==和equal的区别+以及equals()方法重写

Java中关于==和equal的区别以及equals()方法重写例子i: string1="aaa"; string2="aaa"; String string3=new String("aaa"); String string4=new String("aaa"); string1==string2 // true; . string1.equals(string2);//true; string3==string4;//false 因为用new创建了2个对象,所以是两个不同的内存地址 string3.equals(string4);//true 而String类的是不可改变的,所以会指向同一个内存地址,所以返回为true equals()是object的方法,所以只是适合对象,不适合于基本类型,equals()默认是用"=="比较两个对象的内存地址,如果想要比较两个对象的内容,要重写equals()方法才可...而==可以比较两个基本类型,也可以是对象... String的equals()方法重写: public boolean equals(Object object){ if( this==anObject) {return true;} if(anObject instancdOf String) {String anotherString =(String)anObject; int n= count; if(n==anotherString.count) { char V1[]=value; char V2[]=anotherString.value; int i=offset; int j=anotherString.offset; while(n--!=0) { if (v1[i++]!=V2[j++] return false;} return true;} }

Junit4教程_比较详细比较了junit3与junit4_例子很全面也很实用

JUnit4概述 JUnit4是JUnit框架有史以来的最大改进，其主要目标便是利用Java5的Annotation特性简化测试用例的编写。先简单解释一下什么是Annotation，这个单词一般是翻译成元数据。元数据是什么？元数据就是描述数据的数据。也就是说，这个东西在Java里面可以用来和public、static等关键字一样来修饰类名、方法名、变量名。修饰的作用描述这个数据是做什么用的，差不多和public 描述这个数据是公有的一样。想具体了解可以看Core Java2。废话不多说了，直接进入正题。我们先看一下在JUnit 3中我们是怎样写一个单元测试的。比如下面一个类： public class AddOperation { public int add(int x,int y){ return x+y; } } 我们要测试add这个方法，我们写单元测试得这么写： import junit.framework.TestCase; import static org.junit.Assert.*; public class AddOperationTest extends TestCase{ public void setUp() throws Exception { } public void tearDown() throws Exception { } public void testAdd() { System.out.println(\"add\"); int x = 0; int y = 0; AddOperation instance = new AddOperation(); int expResult = 0; int result = instance.add(x, y); assertEquals(expResult, result); } } 可以看到上面的类使用了JDK5中的静态导入，这个相对来说就很简单，只要在import关键字后面加上static关键字，就可以把后面的类的static的变量和方法导入到这个类中，调用的时候和调用自己的方法没有任何区别。

Java常用类和方法面试题+答案

2015年12月20日18:25:21 Java常用类和方法重点总结作者：数据分析玩家 1、简述Java中内存分配的问题 1>凡是new（）出来的东西，都是在堆中进行分配的 2>局部变量【数据类型+变量名】都是在栈中进行分配的 3>静态变量【static】和字符串常量【“String”】都是在数据区进行分配的 4>方法【代码】都是在代码区进行存放的 2、简述Java中Object类的地位 1>Java中所有的类【自己定义的类以及Sun公司提供的类】都默认自动继承了Object类 2>Java中所有的类都从Object类中继承了toString()方法、hashCode()方法和equals()等方法 3、简述Object类中toString()方法的注意事项 1>toString()方法的返回值是一个字符串 2>toString()方法返回的是类的名字和该对象的哈希码组成的一个字符串，即toString()方法返回的是该对象的字符串表示形式 3>在Java中System.out.println(类对象名)实际输出的是该对象的toString()方法返回的字符串，即括号中的内容等价于类对象名.toString(),toString方法的好处是在碰到

println方法的时候会被自动调用，不用显示的写出来 4>建议所有的子类都重写从Object类中继承过来toString 方法，否则toString方法的返回值没有什么实际含义 4、简述Object类中equals()方法的注意事项 1>equals方法的返回值为true或false 2>Object类中equals方法只有在两个对象是同一块内存区域时，即不但内容相同、地址还必须相同时才返回true，否则即便内容相同、如果地址不同只会返回false 3>重写Object类中的equals方法目的在于：保证只要两个对象的内容相同，equals方法就返回true 5、简述Object类中hashCode()方法的注意事项 1>哈希码原本指的是内存空间地址的十六进制表示形式 2>hashCode()方法返回的是该对象的哈希码、即该对象的真实内存地址的十六进制表示形式，但是重写完hashCode()方法之后，返回的不再是该对象真实内存地址的十六进制表示形式 6、学习Java中toString方法、equals方法、hashCode方法共同的一个注意事项在Java中，凡是动态分配的内存都是没有名字的，而是将其地址赋给一个指针变量【引用】，用指针变量去代表这个事物，所以引用和动态分配的内存有本质上的区别，但是在学习Java中的toString方法、equals方法和hashCode方

如果重写了对象的equals()方法,需要考虑什么

如果重写了对象的equals()方法，需要考虑什么 1、用ibatis的原因 2、jdbc、hibernate、ibatis的区别 3、ibatis 的核心配置文件 4、ibatis的核心类 1、在myeclipse加入hibernate环境的全过程是什么? 2、hibernate的核心配置文件是什么及其作用? 3、hibernate的核心类是什么，它们的相互关系是什么?重要的方法是什么? 4、关联: 5、hibernate中的one-to-many或many-to-one中常用的方式是什么? 6、Criteria 的 1、JDBC如何做事务处理？ 2、写出几个在Jdbc中常用的接口 3、简述你对Statement,PreparedStatement,CallableStatement 的理解 4、Java中访问数据库的步骤？ 5、JDBC中的核心类及其作用是什么? 6、执行存储过程用那一个类，如何操作输出参数?(操作) 8、可能会让 1.列举出10个JAVA语言的优势 2.列举出JAVA中10个面向对象编程的术语 3.列举出JAVA中6个比较常用的包 4.JAVA中的标识符有什么作用和特点 5.JAVA中的关键字有什么特点,列举出至少20个关键字 6.JAVA中数据类型如何分类？ 7.JAVA中运算符的分类及举例 8.super,th 1、java中有几种类型的流？JDK为每种类型的流提供了一些抽

象类以供继承，请说出他们分别是哪些类？2、启动一个线程是用run()还是start()? 3、线程的基本概念、线程的基本状态以及状态之间的关系4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什 1. super()与this()的区别？ 2. 作用域public,protected,private,以及不写时的区别？ 3. 编程输出如下图形。 4. JAVA的事件委托机制和垃圾回收机制 5. 在JAVA中，如何跳出当前的多重嵌套循环？ 6. 什么是java序列化，如何实现java 序列化？(写一个实例) 7. 一

java中equals和==的区别

java中equals和==的区别值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。 ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。 equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。 ==比较的是2个对象的地址，而equals比较的是2个对象的内容。显然，当equals为true时，==不一定为true；一、Str ing中的equals和== 1、 public class TestString { public static void main(String[] args) { String s1 = "Monday"; String s2 = "Monday"; } } 上面这段程序中，到底有几个对象呢？来检测一下吧，稍微改动一下程序 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"); } } 编译并运行程序，输出：s1 == s2 说明：s1 与s2 引用同一个Str ing 对象-- "Monday"! 2. 再稍微改动一下程序，会有更奇怪的发现： public class TestString { 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))

Java中equals和==的区别

Java中equals和==的区别 1、java中equals和==的区别值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。 2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。 3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。 4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。 ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同除了String和封装器，equals()和“==”没什么区别但String和封装器重写了equals()，所以在这里面，equals()指比较字符串或封装对象对应的原始值是否相等，"=="是比较两个对象是否为同一个对象

==是判断两个对象是否是同一个对象 equals是进行值的判断 String a = new String("aaa"); String b = new String("a"); b += "aa"; 则 a==b //错误 a.equals(b)//正确 equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等。 ==用于比较引用和比较基本数据类型时具有不同的功能：比较基本数据类型，如果两个值相同，则结果为true 而在比较引用时，如果引用指向内存中的同一对象，结果为true Eg:s1 = new String("sony"); //创建的是字符串对象 s1.equals("sony"); //返回 trues1 == "sony" //返回false //如果 s1 = "sony"; s1 == "sony" //返回true

java 各个Map的区别

java各个Map的区别 ConcurrentHashMap 支持检索的完全并发和更新的所期望可调整并发的哈希表。（线程安全）此类遵守与Hashtable相同的功能规范，并且包括对应于Hashtable的每个方法的方法版本。不过，尽管所有操作都是线程安全的，但检索操作不必锁定，并且不支持以某种防止所有访问的方式锁定整个表。此类可以通过程序完全与Hashtable进行互操作，这取决于其线程安全，而与其同步细节无关。检索操作（包括get）通常不会受阻塞，因此，可能与更新操作交迭（包括put和remove）。检索会影响最近完成的更新操作的结果。对于一些聚合操作，比如putAll和clear，并发检索可能只影响某些条目的插入和移除。类似地，在创建迭代器/枚举时或自此之后，Iterators和Enumerations返回在某一时间点上影响哈希表状态的元素。它们不会抛出 ConcurrentModificationException。不过，迭代器被设计成每次仅由一个线程使用。这允许通过可选的concurrencyLevel构造方法参数（默认值为16）来引导更新操作之间的并发，该参数用作内部调整大小的一个提示。表是在内部进行分区的，试图允许指示无争用并发更新的数量。因为哈希表中的位置基本上是随意的，所以实际的并发将各不相同。理想情况下，应该选择一个尽可能多地容纳并发修改该表的线程的值。使用一个比所需要的值高很多的值可能会浪费空间和时间，而使用一个显然低很多的值可能导致线程争用。对数量级估计过高或估计过低通常都会带来非常显著的影响。当仅有一个线程将执行修改操作，而其他所有线程都只是执行读取操作时，才认为某个值是合适的。此外，重新调整此类或其他任何种类哈希表的大小都是一个相对较慢的操作，因此，在可能的时候，提供构造方法中期望表大小的估计值是一个好主意。（开始构造函数到时候必须考虑到他们的容量和因子）对于经常迭代时更重要此类及其视图和迭代器实现了Map和Iterator接口的所有可选方法。此类与Hashtable相似，但与HashMap不同，它“不”允许将null用作键或值。

JAVA中字符串比较equals()和equalsIgnoreCase()的区别

1、使用equals( )方法比较两个字符串是否相等。它具有如下的一般形式： boolean equals(Object str) 这里str是一个用来与调用字符串（String）对象做比较的字符串（String）对象。如果两个字符串具有相同的字符和长度，它返回true，否则返回false。这种比较是区分大小写的。 2、为了执行忽略大小写的比较，可以调用equalsIgnoreCase( )方法。当比较两个字符串时，它会认为A-Z和a-z是一样的。其一般形式如下：boolean equalsIgnoreCase(String str) 这里，str是一个用来与调用字符串（String）对象做比较的字符串（String）对象。如果两个字符串具有相同的字符和长度，它也返回true，否则返回false。下面的例子说明了equals( )和equalsIgnoreCase( )方法： // Demonstrate equals() and equalsIgnoreCase(). class equalsDemo { public static void main(String args[]) { String s1 = "Hello"; String s2 = "Hello"; String s3 = "Good-bye"; String s4 = "HELLO";

System.out.println(s1 + " equals " + s2 + " -> " + s1.equals(s2)); System.out.println(s1 + " equals " + s3 + " -> " + s1.equals(s3)); System.out.println(s1 + " equals " + s4 + " -> " + s1.equals(s4)); System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " + s1.equalsIgnoreCase(s4)); } } 该程序的输出如下所示： Hello equals Hello -> true Hello equals Good-bye -> false Hello equals HELLO -> false Hello equalsIgnoreCase HELLO -> true

java中char与String的区别

package action; /** * 探讨java中的char与String * Administrator 李榜明 */ public class TestJava2 { public static void main(String[] args) { /** * 字符char */ /** * 字符变量赋值 */ char c1=65; //65是ASCCII值，计算机自动将ASCCII值为65所对应的字符'A'付给变量c1 char c2='A'; System.out.println("c1="+c1);//输出 'A' System.out.println("c2="+c2);//输出 'B' System.out.println("**********"); /** * 整型转换为字符类型 */ int a=68; char c3; //c2=a;//编译出错，整型转换为字符类型，需要强制转换，正确形式如下： c3=(char) a; System.out.println("c3="+c3);//输出 'D' System.out.println("**********");

* 字符类型转换为整型 */ char c4='C'; int b=c4;//小类型自动转换, System.out.println("b="+b);//输出 67 System.out.println("**********"); /** * 字符运算 */ char c5='A'; char c6='B'; int c=c5+c6;//自动转换为整型65 66再相加 System.out.println("c5+c6="+c);//输出 131 System.out.println("**********"); char c7='A'; int d='C'+c7;//道理同上 System.out.println("'C'+c7="+d);//输出 132 System.out.println("**********"); int d0=20; int d1='C'+d0;//'C'转换为整型之后再加d0；道理同上 System.out.println("'C'+d0="+d1);//输出 87 System.out.println("**********"); int a1='C'+20;//道理同上 System.out.println("'C'+20="+a1);//输出 87 System.out.println("**********"); /** * 字符转换为字符串 String

java中equals方法和“==”的比较

java中equals方法和“==”的比较 equals 方法是https://www.360docs.net/doc/2015876806.html,ng.Object 类的方法。有两种用法说明：（1）对于字符串变量来说，使用“= =”和“equals()”方法比较字符串时，其比较方法不同。 “= =”比较两个变量本身的值，即两个对象在内存中的首地址。 “equals()”比较字符串中所包含的内容是否相同。比如： String s1,s2,s3 = "abc", s4 ="abc" ; s1 = new String("abc"); s2 = new String("abc"); 那么： s1= =s2 是false // 两个变量的内存地址不一样，也就是说它们指向的对象不一样，故不相等。 s1.equals(s2) 是true //两个变量的所包含的内容是abc，故相等。注意（1）：如果：StringBuffer s1 = new StringBuffer("a"); StringBuffer s2 = new StringBuffer("a"); 结果：s1.equals(s2) //是false 解释：StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类，而Object类中的equals方法是用来比较“地址”的，所以等于false.

注意（2）：对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符串常量所生成的变量，其中所存放的内存地址是相等的，所以s3= =s4是true（即使没有s3=s4这样一个赋值语句）（2）对于非字符串变量来说，"= ="和"equals"方法的作用是相同的都是用来比较其对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。比如： class A { A obj1 = new A(); A obj2 = new A(); } 那么：obj1==obj2是false obj1.equals(obj2)是false 但是如加上这样一句：obj1=obj2; 那么obj1==obj2 是true obj1.equals(obj2) 是true 总之：equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较其指向的对象是否相同的。== 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以是true。关于equals与==的区别从以下几个方面来说：（1）如果是基本类型比较，那么只能用==来比较，不能用equals 比如： public class TestEquals { public static void main(String[] args) { int a = 3; int b = 4; int c = 3; System.out.println(a == b);//结果是false System.out.println(a == c);//结果是true

==和equals的区别

在讲 == 和 equals 的区别前我们需要确认一下 Java 中的数据类型。在Java中有基本数据类型和引用数据类型两种。 1、8种基本数据类型：四种整数类型(byte、short、int、long) 两种浮点数类型(float、double) 一种字符类型(char) 一种布尔类型(boolean) 2、引用数据类型：除了上面我们说的 8 种基本数据类型外，其他在Java中出现的类型都是引用数据类型。如我们自己写了一个Dog类，而在上面说的8种基本数据类型中不包括Dog类型，所以Dog 类型是隶属于引用数据类型的。 ==的理解：要理解 == 我们学要从两个方面来理解：（1） == 两边为 8 种基本数据类型时：当 == 两边为8种基本数据类型时， == 判断的是两边变量中存放的内容是否相等。例：public class Test { public static void main(String[] args) { int a = 10; int b = 10; if (a == b) { System.out.println("变量a和变量b中的值相等"); } } } 上面的例子的运行结果是在控制台中输出"变量a和变量b中的值相等" 我们可以看出当== 两边为8种基本数据类型时比较的时内容换句话说就是比较变量的值。（2） == 两边为引用数据类型时：当 == 两边为引用数据类型时，== 判断的是引用数据类型的对象的内存地址是否一样，如果 == 比较的内存地址一样表示 == 两边是同一个对象，否则 == 两边不是同一个对象。例： public class Test { public static void main(String[] args) { //在8中数据类型中没有String类型所以String是属于引用数据类型的 String str1 = new String("abc");

==和equals有什么区别

== 和 equals有什么区别？在Java中比较两个数据是否相等有两种方式：一种是使用 == 进行比较；另外一种是使用equals进行比较。 == 可以比较基本数据类型也可以比较引用数据类型。在比较基本数据类型的时候比较的是变量中的值是否相等，而比较引用数据类型的时候比较的是两个对象的地址是否相等（也就是看是否指向的是否为同一个对象），请看如下的示例代码。基本数据类型：引用数据类型：此处对Student的比较可能第一感觉是true，为什么会有这样的错觉呢?因为我们使用现实生活中的眼光去观察这段代码发现名字和年龄都一样了，但是实际上从我们学过的

Java程序上来看是false，因为我们new了两个对象，那么肯定会在堆内存中的分配两个不同的空间，而s1、s2分别存储的是这两个对象的空间地址，所以肯定不一样了，请看下面的示意图：看到这里很多同学感觉恍然大悟，哦……我懂了！于是就立马尝试使用equals方法进行比较，equals方法是Object类中定义的一个公共的示例方法，因此所有的对象都可以访问，立即测试：看到上面的结果，瞬间就不开心了，为什么equals比较结果还是false呢？其实这个时候我们应该这样想，上面比较的这句代码首相回到Student中去找equals方法，可是Student中并没有此方法，然后继续向上找父类（Object）,也就是说此处调用的是Object 中的equals方法，而此时我们并不知道Object中的此方法内部的比较规则是什么，所以……，来来来，撸码哥给你上源码： OK,一切尽在不言中（源码中）！但是，在实际开发中希望的结果并不是这样！举个示例，我们现在做的一个学生管理系统，那么从实际的业务上来看，该系统将会有判断两个学生是否是同一个学生的功能（一个系统中出现多个学习信息一样的将无法区分），而我们一般判断的标准是根据学生的一些特征进行判读，如姓名+年龄+性别+身高等等，这个时候就需要用到比较，== 显然不行，Object

Java试题

一．单选题(20*2=40分) 1.向堆栈stack中插入一个数据obj，栈顶指向标为top，其操作步骤是____ A）stack.push(obj); B）stack.push(obj); top++; C）top++; stack.push(obj); D）stack.push(obj); stack.pop(); top++; 2.执行下列程序段后，y的值变为。 int x,y; for(y=1,x=1;y<=50;y++){ if(x>=10){ break; } if(x%2==1){ x+=5; continue; } x-=3; } A）3 B）4 C）5 D）6 3.当你试图编译运行下列代码的时候会发生什么？

public class Runt implements Runnable{ public static void main(String argv[]){ Runt r = new Runt(); Thread t = new Thread(r); t.start(); } public void start(){ for(int i=0;i<100;i++) System.out.println(i); } } A)从0一直输出到99 B)编译后无法输出 C)编译出错，该类还是一个抽象类 4.编译运行以下代码时会发生什么情况？ String s1= "One"; String s2 = new String("One"); if(s1.equals(s2)){ System.out.println("String equals"); } Boolean b1 = new Boolean(true); Boolean b2 = new Boolean(true);

equals与==的区别

关于equals与==的区别从以下几个方面来说：（1）如果是基本类型比较，那么只能用==来比较，不能用equals 比如： public class TestEquals { public static void main(String[] args) { int a = 3; int b = 4; int c = 3; System.out.println(a == b);//结果是false System.out.println(a == c);//结果是true System.out.println(a.equals(c));//错误，编译不能通过，equals方法 //不能运用与基本类型的比较 } } （2）对于基本类型的包装类型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量，==是比较地址的，而equals是比较内容的。比如： public class TestEquals { public static void main(String[] args) { Integer n1 = new Integer(30); Integer n2 = new Integer(30); Integer n3 = new Integer(31); System.out.println(n1 == n2);//结果是false 两个不同的Integer对象，故其地址不同， System.out.println(n1 == n3);//那么不管是new Integer(30)还是new Integer(31) 结果都显示false System.out.println(n1.equals(n2));//结果是true 根据jdk文档中的说明，n1与n2指向的对象中的内容是相等的，都是30，故equals比较后结果是true System.out.println(n1.equals(n3));//结果是false 因对象内容不一样，一个是30一个是31 } } 这是Integer的实例，如果是其他的比如Double、Character、Float等也一样。（3）注意：对于String(字符串)、StringBuffer(线程安全的可变字符序列)、StringBuilder(可变字符序列)这三个类作进一步的说明。（a）首先，介绍String的用法，请看下面的实例： public class TestEquals { public static void main(String[] args) { String s1 = "123";

c# equals与==的区别

c# equals与==的区别对于值类型，如果对象的值相等，则相等运算符(==) 返回true，否则返回false。对于string 以外的引用类型，如果两个对象引用同一个对象，则== 返回true。对于string 类型，== 比较字符串的值。 ==操作比较的是两个变量的值是否相等。 equals（）方法比较的是两个对象的内容是否一致．equals也就是比较引用类型是否是对同一个对象的引用。在C#语言中，重载了string 对象的很多方法方法(包括equals()方法)，使string对象用起来就像是值类型一样所以字符串可以像值类型一样用==比较但是其他的引用类型如果要想比较值是否相等，最好用Equals 如果你想比较两个对象是否是同一实例，用ReferenceEquals ，ReferenceEquals()用于引用比较，Equals用于比较值对于值类型的比较，这里就不做描述了，下面讨论引用类型的比较：首先我们看一段程序 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Per son { private string name; public string Name { get { r eturn name; } set { name = value; } } public Person(string name) {

https://www.360docs.net/doc/2015876806.html, = name; } } } using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Pr ogr am { static void Main(string[] ar gs) { string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' }); string b = new string(new char[] {'h', 'e', 'l', 'l', 'o' }); Console.WriteLine(a == b); Console.WriteLine(a.E quals(b)); obj ect g = a; obj ect h = b; Console.WriteLine(g == h); Console.WriteLine(g.Equals(h)); Person p1 = new Person("jia"); Person p2 = new Person("jia"); Console.WriteLine(p1 == p2); Console.WriteLine(p1.Equals(p2));

java中hashcode()和equals()的详解

如果函数返回类型不同，子类的同名函数不能继承父类的同名函数 c++ 如果返回值类型是基本数据类型，必须相同，不然编译不通过。如果返回值类型是类类型，可以不相同 hashcode方法浅析有许多人学了很长时间的Java，但一直不明白hashCode方法的作用，我来解释一下吧。首先，想要明白hashCode的作用，你必须要先知道Java中的集合。总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法，那需要更多的文章篇幅，我在这里就不介绍了。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode 方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。所以，Java对于eqauls方法和hashCode方法是这样规定的：1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同上面说的对象相同指的是用eqauls方法比较。你当然可以不按要求去做了，但你会发现，相同的对象可以出现在Set集合中。同时，增加新元素的效率会大大下降。 java中hashcode()和equals()的详解 1. 首先equals()和hashcode()这两个方法都是从object类中继承过来的。 equals()方法在object类中定义如下： public boolean equals(Object obj) { return (this == obj); } 很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们必需清楚，当String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。比如在String类中如下：