Ⅰ 四道Java基础题，你能做对几道
符的使用
首先看一段比较有意思的代码
[java] view plain
Integer a = 1000,b=1000;
Integer c = 100,d=100; public void mRun(final String name){
new Runnable() {
public void run() {
System.out.println(name);
}
};
}
System.out.println(a==b);
System.out.println(c==d);
如果这道题你能得出正确答案，并能了解其中的原理的话。说明你基础还可以。如果你的答案 是 true 和true的话，你的基础就有所欠缺了。
首先公布下答案， 运行代码，我们会得到 false true。我们知道==比较的是两个对象的引用，这里的abcd都是新建出来的对象，按理说都应该输入false才对。这就是这道题的有趣之处，无论是面试题还是论坛讨论区，这道题的出场率都很高。原理其实很简单，我们去看下Integer.java这个类就了然了。
[java] view plain
public static Integer valueOf(int i) {
return i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
}
/**
* A cache of instances used by {@link Integer#valueOf(int)} and auto-boxing
*/
private static final Integer[] SMALL_VALUES = new Integer[256];
static {
for (int i = -128; i < 128; i++) {
SMALL_VALUES[i + 128] = new Integer(i);
}
}
当我们声明一个Integer c = 100;的时候。此时会进行自动装箱操作，简单点说，也就是把基本数据类型转换成Integer对象，而转换成Integer对象正是调用的valueOf方法，可以看到，Integer中把-128-127 缓存了下来。官方解释是小的数字使用的频率比较高，所以为了优化性能，把这之间的数缓存了下来。这就是为什么这道题的答案回事false和ture了。当声明的Integer对象的值在-128-127之间的时候，引用的是同一个对象，所以结果是true。
2String
接着看代码
[java] view plain
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
大家又来猜一猜这道题的答案是什么？
按照==的语法来看， 首先s1、s2、s3是三个不同的对象，常理来说，输出都会是false。然而程序的运行结果确实true、false。第二个输出false可以理解，第一个输出true就又让人费解了。我们知道一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，而堆内存中则存放new 出来的对象和数组。然而除此之外还有一块区域叫做常量池。像我们通常想String s1 = "abc"; 这样申明的字符串对象，其值就是存储在常量池中。当我们创建String s1 = "abc"这样一个对象之后，"abc"就存储到了常量池（也可叫做字符串池）中，当我们创建引用String s2 = "abc" 的时候，Java底层会优先在常量池中查找是否存在"abc"，如果存在则让s2指向这个值，不会重新创建，如果常量池中没有则创建并添加的池中。这就是为什么答案是true 和false的原因。
3final关键字
还是来看一段代码
[java] view plain
public void mRun(final String name){
new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(name);
}
}.start();
}
这种代码相信大家写过很多，当内部类访问局部变量的时候，需要在局部变量前加final修饰符，不然编译器就会报错。通常我们也是这么干的。好的，第二个问题来了，为什么要加final修饰符？相信大多数小伙伴都没有思考过这个问题，但凡使用的时候，直接加上就得了，从来没去深究过其中的原理。这对于一个优秀的程序员来说是不可取，我们不仅要知其然还要知其所以然。
现在我们来分析一下，为什么要加final关键字。首先内部类的生命周期是成员级别的，而局部变量的生命周期实在方法体之类。也就是说会出现这样一种情况，当mRun方法执行，new 的线程运行，新线程里面会睡一秒。主线程会继续执行，mRun执行完毕，name属性生命周期结束。1秒之后，Syetem.out.printh(name)执行。然而此时name已经寿终正寝，不在内存中了。Java就是为了杜绝这种错误，严格要求内部类中方位局部变量，必须使用final关键字修饰。局部变量被final修饰之后，此时会在内存中保有一份局部变得的复制品，当内部类访问的时候其实访问的是这个复制品。这就好像是把局部变量的生命周期变长了。说到底还是Java工程师提前把这个坑给我们填了，不然不知道又会有多少小伙伴会为了内部类局部变量而发愁了。
4Integer与int那些事
看下面代码
[java] view plain
Integer a = new Integer(1000);
int b = 1000;
Integer c = new Integer(10);
Integer d = new Integer(10);
System.out.println(a == b);
System.out.println(c == d);
这道题是继第一题的后续，如果这道题你能很快速的得出答案，那么恭喜你，==比较符你就算掌握的比较透彻了。
---------------我是华丽分割线-------------
正确答案： true 、false
看到这个答案很多小伙伴又会不解，先来说下第二个，按第一题来说Integer不是把-128-127缓存起来了吗？这不是应该是true嘛，但是你仔细看，这里的Integer是我们自己new出来的，并不是用的缓存，所以结果是false。 现在来看第一个为啥又是true了呢？ 首先这里的值为1000，肯定和我们所知的Integer缓存没有关系。既然和缓存没有关系，a是新new出来的对象，按理说输入应该是false才对。但是注意b这里是int类型。当int和Integer进行==比较的时候，Java会把Integer进行自动拆箱，也就是把Integer转成int类型，所以这里进行比较的是int类型的值，所以结果即为true。
学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：232300090【长按复制】 我们一起学Java！
Ⅱ Java 的Integer，int与new Integer到底怎么回事
1. int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。
2. Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
3. new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。
Ⅲ java中int变量边界值问题
你好，很高兴回答你的问题。
你的这个是相等的啊。
如果是
Integer a = 128;
Integer b = 128;
他俩是不相等的。
因为java的Integer类在自动装箱时如果值在-128到127这个范围内则使用缓存内的对象，这样相同值就是相同对象。
如果值不在这个范围，则是新创建对象，即便是相同值也是不同对象。
而等号比较的是是否为相同对象。
如果有帮助到你，请点击采纳。
Ⅳ Integer中的问题
……LZ很有意思。
System.out,println(a=b);
这一句话中有两个bug,应该是
System.out.println(a==b);
另外这个问题确实是这样的，Integer会自动缓存[-128,127]之间的Integer对象。不过你如果这么写：
Integer a = new Integer(126);
Integer b = new Integer(126);
System.out.println(a==b);
输出false
Ⅳ JAVAEE里面都包含什么
Java EE 5是不是象Sun说的是Java EE史上最简单的版本，它将大大降低开发难度呢？Java EE 5面世后，企业该如何选择呢？以前使用J2EE1.4及以前版本的企业会升级到Java EE 5吗？
Java今年已经11岁了。在这11年里，被应用到了企业、桌面、Web、移动等各个领域。其中覆盖面最广的J2EE及相关产品被广泛应用到企业中。但从1999年诞生的第一个J2EE版本一直到 J2EE1.4总被人们不断地抱怨，这并不是因为它不够强大，恰恰相反，正是因为它太强大了，强大得让人难以使用。
Sun这些年也一直在试图改变这一切，但一直未能如愿。在2002年J2EE1.4推出后，它的复杂程度达到了顶点。尤其是EJB2.0，开发和调试的难度非常大。也许是Sun要下决心改变这一切，或者是受到市场和开发人员的压力，终于在今年5月份正式发布了J2EE5(现已经改名为Java EE 5)规范，并宣称Java EE 5将是Java EE史上最简单的版本，它将大大降低开发难度。但业界对此却表示怀疑。Java EE 5真的变简单了吗？这好像有点突然！Java EE在未来是否能走上一条简单的光明之路呢？
Java EE 5横空出世
Java EE 5终于在千呼万唤中诞生了。在今年的JavaOne会议上，Sun特意派去了一个宣讲团，对Java EE 5进行了大吹特吹，并称Java EE 5最大的改变就是简化开发。同时，还特别提到了EJB3.0可以通过Java最新提供的注释（annotations）以及其它一些特性来提高开发和测试的效率。Sun的鼓吹声还没有完全散尽，业界的嘘嘘声就此起彼伏。一位高级分析师，Richard Monson-Haefel，称Java EE 5虽然做了很多改进，但仍然无法克服它的庞大和复杂。这位高级分析师目前是EJB3.0规范的设计者之一，从Java EE 5的设计者口中说出这样的话，我想它的分量一定不轻。
也许Sun并不愿意听到这样的评论。但Monson-Haefel还是喋喋不休地数落着Java EE 5的种种不是。
Monson-Haefel说：“Java EE中的功能高度集成，我们将无法单独使用其中的一部分。而且许多Servlet、Java数据库和JavaServer Pages开发人员一般只使用Java EE的某些相关的特性。但Java EE规范要求必须使用所有的特性[APIs]。为了使程序可以正常运行，这些开发人员不得不建立一个复杂的工程来满足这些要求。这是因为Java EE仍然保持了上世纪90年代后期的编程方法，也就是说Java EE是以API为中心的”。Monson-Haefel甚至危言耸听地称“Java EE的应用已经走到了尽头！”。
也并不是所有的人都象Monson-Haefel这么悲观。一位JBoss公司的发言人说：“我们并不完全反对Burton集团高级分析师 Richard Monson-Haefel的关于平台复杂性的观点，但是没有人同意他关于Java EE的应用已经走到尽头的这个结论。”
IBM一向是Java的忠实支持者，也站出来为Java EE说话。Jim Knudson，作为IBM 的Java EE架构师，曾公开表示“虽然Java EE平台在使用上是有一些复杂，但这并不能成为我们放弃这个平台的理由”。
Java EE 5刚一问世，就引来了这么多的议论，当然，这些议论有好的，也有对Java EE 5不利的。那么Java EE的主要用户群：企业，该如何做出选择呢？
企业会为Java EE 5埋单吗？
Java EE 5面世后，企业该如何选择呢？以前使用J2EE1.4及以前版本的企业会升级到Java EE 5吗？
也许Monson-Haefel的一席话会吓倒很多企业。但Jim Knudson对此仍然很乐观。虽然他表示同意Java EE平台很复杂这一观点，但是他说某些复杂性是来自于用户的需求，并且我们要使用户达到他们期望的效果。他说IBM的那些预期实现SOA的用户都打算在 Java EE 5平台上面构建SOA。
JBoss产品管理部主管Ram Venkataraman也支持这样的观点：Java EE平台增加了复杂性是有必要的，因为需要使用它来处理各种服务，不仅仅是简单的调用关系数据库的Ajax风格Web服务，而且还有大容量事务处理的财务服务。
也许很多企业的负责人听了这些对Java EE 5赞扬的话，他们会迫不急待地尝试一下Java EE 5。这对于那些已经或即将搭建SOA构架的企业尤其重要。由于基于Java的SOA一般都是建立在J2EE服务器上，这就迫使企业必须做出是否升级到新版 Java EE的选择。
如果企业选择了Java EE 5，那可能会增加后续的成本。这是因为Java EE 5是基于Sun最新的JDK的，因此，Java EE 5增加了很多新的API。虽然这些API好象使Java EE 5变得更简单了，但开发人员必须要学习一整套新的编程模型持久化的API。而这些企业必须为此增加培训的费用。
其实Sun的初衷也是好的，只是简化Java EE的做法不妥。也许Sun还不明白，一味地增加功能并不能有效地简化Java EE的使用难度，有时还可能适得其反。如果Sun能够加一个用于开发的所见即所得（WYSIWYG）的拖放系统，那才叫真正地简化开发。而象这样增加很多的API，甚至将编程的思维方式都改变了，这样做并不能使Java EE平台变得更简单，而只是换汤不换药而已。
自从Sun将Java EE平台的设计移交给JCP后，对于Java EE逐渐增加的复杂性，JCP也难辞其咎。作为JCP的成员，Monson-Haefel和JCP的所有成员应该为Java EE 5变成今天这个样子而负责。实际上JCP的成员很早就和Sun的Java EE 5开发团队讨论过这个问题，但Sun表现得并不积极。这样看来，JCP和Sun都应该为此负一定的责任。
JCP的主管，Onno Kluyt却有不同的看法：“Monson-Haefel所看到的复杂性问题并不是JCP所负责的范围。JCP是一个制定标准的组织，并不是一个负责优化的组织，并不应该为Java EE 5的复杂性负责”。同时Kluyt还提到让Java EE 5变得更简单最好方法就是有一个好的IDE，简单是每个JSR所关注的，也是它们的中心任务。然而Java EE的开发者并不知道怎么去做。毕竟，Java EE是否简单，它的开发人员并没有发言权，而最有发言权的是那些使用Java EE的人。”
Java EE：路在何方
也许上面的喋喋不休使我们的头都大了，但我们可以不必管它。最后还得让Sun来盖棺定论。终于，Sun公司负责企业Java平台的副总裁Karen Padir为Java EE 5作了比较中庸的阐述：“平台当然要复杂了，因为它是应用服务器的规范。而且，应用服务器是很复杂的，因为复杂性的存在主要是为了开发人员能够在应用服务器上工作，但是应用程序的开发人员并不一定会涉及到复杂性，因为他们仅仅使用那些完成工作所必需的工具就可以了。开发人员可以忽略他们所不需要的复杂性”。
就象微软的Office一样，虽然复杂，但并不是所有的人都会涉及到所有复杂的功能。因此，Java EE并没有我们想象的那样复杂。反而通过JDK5的支持，在某些应用的性能上，如Web Services，会有很大的提高。因此，如果企业要建立新的应用（尤其是SOA），还是可以考虑Java EE 5的。对于那些已经使用多年的系统来说，升级时得要慎重一些。不过，从总体来说，Java EE 5还是非常不错的。
Ⅵ java swap（Integer a ,Integer b）实现交换
public class App {
public static void main(String[] args) {
Integer a=1, b=2;
System.out.println("before:a=" + a + ", b=" + b);
swap(a,b);
System.out.println("after:a=" + a + ", b=" + b);
}
public static void swap(Integer i1, Integer i2) {
Integer tmp = i1;
i1 = i2;
i2 = tmp;
}
}
输出结果：a=1,b=2
java里两种参数传递形式：值传递，引用传递
java变量分为基本类型，引用类型，两种类型的参数传递给方法时都是按值传递
形参和实参所占的内存地址不一样
形参中的内容只是实参中存储的对象引用的一份拷贝
交换的是两个引用变量的副本，原来的a,b引用指向不变。
请查看Integer.java
private final int value;
public Integer(int value) {
this.value = value;
}
public class App {
public static void main(String[] args) {
Integer a=1; // Integer a = Integer.valueOf(1); IntegerCache.cache[1+128] == 1
Integer b=2;
System.out.println("before: a=" + a + ", b=" + b);
swap(a, b);
System.out.println("after: a=" + a +", b=" + b);
}
public static void swap(Integer i1, Integer i2) throws NoSuchFieldException {
//通过反射获得类私有不可变变量（private final int value;）
Field field = Integer.class.getDeclaredField(name:"value");
//通过setAccessible去访问私有的成员变量
field.setAccessible(true);
int tmp = i1.intValue(); //tmp值是1，
field.set(i1, i2.intValue()); // i1的值设置为Integer.valueOf(i2.intValue()).intValue()，此时i1地址是IntegerCache.cache[1+128]: 值为2
field.set(i2, tmp); //int-->Object Integer.valueOf(tmp).intValue(), tmp的值是地址IntegerCache.cache[1+128],
}
｝
javap -v App.class 查看App的字节码
自动封装
Integer a = 1; // Integer a = Ineger.valueOf(1);
valueOf(int i) i在-128到127之间，返回缓存中的值 return IntegerCache.cache[i + (-IntegerCache.low)]
所以Integer a=1，b=1时，a == b ，两个的内存地址是同一个。
上面运行结果：
a=2, b=2
解决：
Integer tmp = new Integer(i1.intValue());
得 a=2, b=1
知识点：
1.自动装箱和拆箱
2.Integer -128到127之间的缓存
3.反射，通过反射去修改private final 变量。
https://www.cnblogs.com/doStudying/p/7851254.html 这里列出了field.setInt()方法，跟上面的set方法的区别， 应该？是参数类型不一致，是否用到IntegerCache
http://www.docin.com/p-700305321.html 这里副本的值指向a,b的地址。用this可实现，但注意static方法里不能用this。
Ⅶ JAVA中 为什么这三种输出结果是true,false,true
int 是基础数据类型， Integer 是类, 是对 int的封装对象，具备对象的一切特性。
Integer是一个对象，==比较的是引用地址，与 int 比较，jvm会将Integer转化为int, 所以结果为true。
但Integer之间比较时，如果是用new创建的对象，一定返回false。
Integer 大于127 是需要新建 new 对象。Integer c = 128 ;会编译为 Integer c = Integer.valueOf(128); 是用new创建的对象。Integer d = 128; 也是用new创建，所以返回false。
Ⅷ java中Integer在JDK1.6和JDK1.7中的区别
运行下面这段代码：
System.out.println(Integer.valueOf("127")==Integer.valueOf("127"));
System.out.println(Integer.valueOf("128")==Integer.valueOf("128"));
System.out.println(Integer.parseInt("128")==Integer.valueOf("128"));
JDK1.6输出结果：
false
false
true
JDk1.7输出结果：
true
false
true
JDK1.7版本开始，Integer有了静态缓存，这点注意一下。
Ⅸ java stringbuffer 的缓冲长度多少
StringBuffer缓冲长度，或者叫容量会随着内部储存的字符串长度而翻倍增大。
比如用了49个字符，容量为50，再加入2个字符时，容量会从50变成100，此时字符串长度为51
初始容量默认为16，也可以自定义更小或更大。
Ⅹ java里Integer类在-128和127之间为什么能直接用==比较,好像还只能在自动装箱的时候是吗求详解，谢谢啦！
因为Integer实现的时候 对于-128 到127之间的值会做缓存处理
比如 Integer i=100,j=100;
那么j实际上就是指向的i,因为i缓存了
如果Integer i=200,j=200;
这时候不会缓存，会新建一个对象200,
所以第一次 i==j为真
第二次 i==j为假