String a1="abc";
String a2="abc";
String a3=new Stirng("abc");
System.out.println(a1==a2);//true，不知你是否看错了
a1和a3相等是因为a1先看字符串池里有没有"abc"对象
有：直接将地址返回
没有:在字符串池中创建再返回
a3是看"abc"对象有没有在字符串池里，如果没有就存入字符串池里，有就不存，最后都要生成字符串对象,将堆里的对象地址返回来
所以
System.out.println( s1 == s3 );   //true

int j = 128;
int k = 128;
System.out.println( "j==k:" + ( j==k ));    //true.这里为true是因为int定义的是在栈中的,==比较里面的值        
        Integer x = 128;
        Integer y = 128;
        System.out.println( "x==y:" + ( x==y ));  //false,这时相信你知道了
        System.out.println( "x.equals(y)" + x.equals(y)); //true ,这里是Integer重写了Object类的equals方法
      
       如下java源码
public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();//由此可见是比较里面intValue值,当然就为true了
        }
        return false;
    }

回答你关于匿名对象的问题：
匿名对象
使用格式：new 类名()
匿名对象是对象的简化形式。
匿名对象两种使用情况：
        1.当对对象的方法只调用一次时，这样写比较简化，但是如果对一个对象进行多个成员调用，必须给这个对象起个名字；
        2.匿名对象可以作为实际参数进行传递。

1. class EqualsDemo
   
2. {
   
3.         public static void main ( String[] args)
   
4.         {
   
5.                         String s1 = "abc"; //"abc"这是一个匿名对象.可以这样看待吗? /*
   
6.                         /*——>这不是一个匿名对象，首先它是有名字的（s1），其次连new都没有。这个地方s1应该是一个字符串类型的变量*/
   
7.                         String s2 = "abc"; //"abc"这是另一个匿名对象             //——>解释同上
   
8.                         String s3 = new String( "abc" );                         //——>这个地方才是对String类的应用。
   
9.                        
   
10.                         System.out.println( s1 == s2 );  //false内存中有两个匿名对象"abc".对吗?
    
11.                                                  /*——>按照上面s1、s2的解释，你问的应该是错误的。*/
    
12.                                                 System.out.println( s1 == s3 );   //true
    
13.                
    
14.                         Integer i = 127;
    
15.                         Integer n = 127;
    
16.                         System.out.println( "i==n:" + ( i==n ));/*这里为true.因为127可以看作是一个byte对象,
    
17.                         小于128.所以不再内存中开辟另一个对象*/
    
18.                         System.out.println( "i.equals(n)" + i.equals(n));
    
19. 
    
20.                         int j = 128;
    
21.                         int k = 128;
    
22.                         System.out.println( "j==k:" + ( j==k ));    //true.int属于类还是结构呢?她们为什么有相等呢?
    
23.                                                          /*逻辑上 j != k, 所以输出的应该是true。int应该是数据类型吧，Integer才是类*/
    
24.         
    
25.                         Integer x = 128;
    
26.                         Integer y = 128;
    
27.                         System.out.println( "x==y:" + ( x==y ));  //false
    
28.                         System.out.println( "x.equals(y)" + x.equals(y)); //true
    
29.                 }
    
30. }

复制代码

System.out.println( "这句话怎么理解" )

这是最常用的语句这句话怎么理解呢?
-----------------------------------------------------------------
class EqualsDemo
{
        public static void main ( String[] args)
        {
        String s1 = "abc"; //"abc"这是一个匿名对象.可以这样看待吗?  
                String s2 = "abc"; //"abc"这是另一个匿名对象
                String s3 = new String( "abc" );
       
                System.out.println( s1 == s2 );  //false内存中有两个匿名对象"abc".对吗?
                System.out.println( s1.equals( s3 ));   //true
               
        Integer i = 127;
        Integer n = 127;
        System.out.println( "i==n:" + ( i==n ));        //这里为true.因为127可以看作是一个byte对象,小于128.所以不再内存中开辟另一个对象.
        System.out.println( "i.equals(n)" + i.equals(n));

       int j = 128;
        int k = 128;
        System.out.println( "j==k:" + ( j==k ));    //true.int属于类还是结构呢?她们为什么有相等呢?
       
        Integer x = 128;
        Integer y = 128;
        System.out.println( "x==y:" + ( x==y ));  //false
        System.out.println( "x.equals(y)" + x.equals(y)); //true
       
      
}
       
}

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。

Java中的简单类型从概念上分为四种：实数、整数、字符、布尔值。但是有一点需要说明的是，Java里面只有八种原始类型，其列表如下：

　　实数：double、float

　　整数：byte、short、int、long

　　字符：char

　　布尔值：boolean

复杂类型和基本类型的内存模型本质上是不一样的，简单数据类型的存储原理是这样的：所有的简单数据类型不存在“引用”的概念，简单数据类型都是直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面，而Java语言里面只有这八种数据类型是这种存储模型；而其他的只要是继承于Object类的复杂数据类型都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，简单地讲，“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的。

Java的简单数据讲解列表如下：

　　int：int为整数类型，在存储的时候，用4个字节存储，范围为-2,147,483,648到2,147,483,647，在变量初始化的时候，int类型的默认值为0。

　　short：short也属于整数类型，在存储的时候，用2个字节存储，范围为-32,768到32,767，在变量初始化的时候，short类型的默认值为0，一般情况下，因为Java本身转型的原因，可以直接写为0。

　　long：long也属于整数类型，在存储的时候，用8个字节存储，范围为-9,223,372,036,854,775,808到9,223,372,036, 854,775,807，在变量初始化的时候，long类型的默认值为0L或0l，也可直接写为0。

　　byte：byte同样属于整数类型，在存储的时候，用1个字节来存储，范围为-128到127，在变量初始化的时候，byte类型的默认值也为0。

　　float：float属于实数类型，在存储的时候，用4个字节来存储，范围为32位IEEEE 754单精度范围，在变量初始化的时候，float的默认值为0.0f或0.0F，在初始化的时候可以写0.0。

　　double：double同样属于实数类型，在存储的时候，用8个字节来存储，范围为64位IEEE 754双精度范围，在变量初始化的时候，double的默认值为0.0。

　　char：char属于字符类型，在存储的时候用2个字节来存储，因为Java本身的字符集不是用ASCII码来进行存储，是使用的16位Unicode字符集，它的字符范围即是Unicode的字符范围，在变量初始化的时候，char类型的默认值为'u0000'。

　　boolean：boolean属于布尔类型，在存储的时候不使用字节，仅仅使用1位来存储，范围仅仅为0和1，其字面量为true和false，而boolean变量在初始化的时候变量的默认值为false。

Integer是int的封装类，里面有很多进行处理的静态方法  
Integer是对象而int不是，内存的分配位置也不一样

int是一种基本数据类型，而Integer是相应于int的类类型，称为对象包装。  
实现这种对象包装的目的主要是因为类能够提供必要的方法，用于实现基本数据类型的数值与可打印字符串之间的转换，以及一些其他的实用程序方法；  
另外，有些数据结构库类只能操作对象，而不支持基本数据类型的变量，包装类提供一种便利的方式，能够把基本数据类型转换成等价的对象，从而可以利用数据结构库类进行处理。  

System.out.println();
首先System是位于java.lang中的一个类，它包含一些字段和方法，out就是其中的一个表示标准输出流的字段，jdk中out被定义为public static final PrintStream out；而println（）是PrintStream类中表示打印的方法
所以标准的输出语句就可以是System.out.println（）;

API的帮助文档中关于System类的介绍，其中有：
System
static PrintStream out
“标准”输出流。

关于System.out的详细介绍：
out
public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。

对于简单独立的 Java 应用程序，编写一行输出数据的典型方式是：
System.out.println(data)
请参阅 PrintStream 类中的 println 方法。

文档中关于PrintStream 的介绍，其中有这么一句
void println(Object x)
打印 Object，然后终止该行。
详细介绍是：
println
public void println(Object x)打印 Object，然后终止该行。此方法的行为就像先调用 print(Object) 然后调用 println() 一样。
参数： x - 要打印的 Object。

有时候追求一点细节很是能了解好的知识.
System.out.println( "这句话怎么理解" )

下面是我在c#书看到对   Console.Out.WriteLine()的解释.对应到java的System.out.println() 的理解

Console.out是一个属性,她返回一个设计用来专门向控制台输出的System.IO.TextWriter的基类的实现.
System.out她也是一个属性,她返回一个设计用来对应于显示器输出或者由主机环境或用户指定的另一个输出目标的java.io.PrintStream类的实现.
这里注意一点System.out返回的是一个属性
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

   String s1 = "abc"; //"abc"这是一个匿名对象.可以这样看待吗? /*
                        /*——>这不是一个匿名对象，首先它是有名字的（s1），其次连new都没有。这个地方s1应该是一个字符串类型的变量*/
-------------------------------------------------------------------------------------------------------------------------------
我对楼上看法不同
视频上说了 "abc" 是一个特殊对象
java api也说了  :  String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现...   (我的理解"abc"也是String实例的实现也就是她的对象)
  既然 "abc"是一个对象,没有对象名,不可以理解为匿名对象吗?

String s1=“abc”,这里有s1引用，应该就不叫匿名对象了吧，
Sysem.out.println(s1==s2); 这里，s1,s2都是对象的引用 应该用s1.equals(s2)比较,这样就返回true了。
Integer i=127;
Integer n=127;
System.out.println("i==n:"+(i==n));//这里的i,和n都是对象，之所以可以用==比，
                                  //那是因为这里有个自动拆箱动作，分别把i和n拆箱成int 型数据，才用==比的，对象是不用==比的



int j=128;
int k=128;
System.out.println("j==k:"+(j==k));//int是基本数据类型，不是对象，它们的值相等，所以j肯定等于k啊，这里比较的时两个基本数据型的变量的值，不是看作对象来比的。