java中的知识_Java中的小知识

Java中的小知识

目录

1.String、StringBuffer与StringBuilder

###1.1 三者介绍

* String：字符串常量

* StringBuffer与StringBuilder：字符串变量

1.2 三者执行速度比较

StringBuilder > StringBuffer > String

原因：String是字符串常量，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，所以使得执行效率很低；而StringBuffer与StringBuilder是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作，这样就不会像String一样创建一些额外的对象，所以速度较快。

特例：

String str = “This is only a” + “ simple” + “ test”;

StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

以上代码StringBuffer 没有明显的优势。

原因：在JVM中实现时

String str = “This is only a” + “ simple” + “test”;

等价于

String str = “This is only a simple test”;

如果你的字符串是来自另外的String对象的话，速度就没那么快了,比如

str =str1 + str2 +str3；

1.3 线程安全

StringBuilder：线程非安全的

StringBuffer：线程安全的

说明：当我们在字符串缓冲被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，但是可以保证StringBuffer是可以正确操作的。但是由于大多数情况下我们的操作是在单线程下，所以大多数情况下，考虑到速度的原因，建议用StringBuilder而不用StringBuffer的。

1.4 使用场景

String：操作少量的数据时

StringBuilder 单线程使用字符串缓冲区操作大量数据时

StringBuffer 多线程使用字符串缓冲区操作大量数据时

2. java中的整型及原码、反码、补码的概念

java中的整型有byte，short，int，long四类。java没有无符号类型(unsigned)，所以各个整型能表示的最大整数大约是该类型能表示的数量的一半。

byte：1字节 -128 ~ 127，

short：2字节 -32 768 ~ 32 767；

int：4字节 -2 147 483 648 ~ 2 147 483 647(20亿)

long：8字节 -9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807

说明：java中用补码表示二进制数，补码的最高位是符号位，最高位为“0”表示正数，最高位为“1”表示负数。正数补码为其本身；负数补码为其绝对值各位取反加1；

步骤：

byte为一字节8位，最高位是符号位，即最大值是01111111，因正数的补码是其本身，即此正数为01111111，十进制表示形式为127

最大正数是01111111，那么最小负是10000000(最大的负数是11111111，即-1)

10000000是最小负数的补码表示形式，我们把补码计算步骤倒过来就即可。10000000减1得01111111然后取反10000000，因为负数的补码是其绝对值取反，即10000000为最小负数的绝对值，而10000000的十进制表示是128，所以最小负数是-128

由此可以得出byte的取值范围是-128到+127

说明：各个类型取值范围的计算方法与此大致相同，感兴趣的同学可以自己试着计算

概念：

[原码]就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

[反码]表示法规定：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

[补码]表示法规定：正数的补码与其原码相同；负数的补码是在其反码的末位加1。

3. int 与Integer

详细说明可以参考文献 [彻底让你明白 Integer 类和 int 基本数据类型的区别](https://blog.csdn.net/teacher_lee_zzsxt/article/details/79230501)

### 3.1 int 与Integer的基本区别

* Integer 是 int 包装类，int 是八大基本数据类型之一(byte,char,short,int,long,float,double,boolean)

* Integer 是类，默认值为null，int是基本数据类型，默认值为0；

* Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。

3.2 Integer 的自动拆箱和装箱

自动拆箱和自动装箱是 JDK1.5 以后才有的功能，在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。

3.2.1 自动装箱

一般我们创建一个类的时候是通过new关键字，比如：

Object obj = new Object();

但是对于 Integer 类，我们却可以这样：

Integer a = 128;

通过反编译工具，我们可以看到，生成的class文件是：

Integer a = Integer.valueOf(128);

这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。

3.2.2 自动拆箱

我们将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。如，

Integer a = new Integer(128);

int m = a;

反编译生成的class文件：

Integer a = new Integer(128);

int m = a.intValue();

简单来讲：自动装箱就是Integer.valueOf(int i);自动拆箱就是 i.intValue();

3.3 实验

public static void main(String[] args) {

Integer i = 10;

Integer j = 10;

System.out.println(i == j); //true

Integer a = 128;

Integer b = 128;

System.out.println(a == b); //false

int k = 10;

System.out.println(k == i); //true

int kk = 128;

System.out.println(kk == a); //true

Integer m = new Integer(10);

Integer n = new Integer(10);

System.out.println(m == n); //false

Integer a1 = 1;

Integer b1 = 2;

Integer c = 3;

Integer e = 321;

Integer f = 321;

Long g = 3L;

Long h = 2L;

System.out.println(c == (a1 + b1));//true

System.out.println(c.equals((a1+b1)));//true

System.out.println(g == (a1+b1));//true

System.out.println(g.equals(a1+b1));//false

System.out.println(g.equals(a1+h));//true

}

说明：

第一个打印结果为true：对于 i == j ,我们知道这是两个Integer类，他们比较应该是用equals，这里用==比较的是地址，那么结果肯定为false，但是实际上结果为true。分析源码我们可以知道在 i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。

第二个打印结果为 false：从上面的分析我们知道，128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false

第三个打印结果为true：Integer 的自动拆箱功能，也就是比较两个基本数据类型，结果当然为true

第四个打印结果为 true：解释和第三个一样。int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比较。

第五个打印结果为 false：因为这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。

第六个打印结果为true： 由于 a+b包含了算术运算，因此会触发自动拆箱过程(会调用intValue方法),==比较符又将左边的自动拆箱，因此它们比较的是数值是否相等。

第七个打印结果为true： 对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。

第八个打印结果为true： 对于 g == (a+b)，首先计算 a+b,也是先调用各自的intValue方法，得到数值之后，由于前面的g是Long类型的，也会自动拆箱为long，==运算符能将隐含的将小范围的数据类型转换为大范围的数据类型，也就是int会被转换成long类型，两个long类型的数值进行比较。

第九个打印结果为false： 对于 g.equals(a+b),同理a+b会先自动拆箱，然后将结果自动装箱，需要说明的是 equals 运算符不会进行类型转换。所以是Long.equals(Integer)，结果当然是false

第十个打印结果为true： 对于g.equals(a+h),运算符+会进行类型转换，a+h各自拆箱之后是int+long，结果是long，然后long进行自动装箱为Long，两个Long进行equals判断。

3.4 其他封装类

其他的基本类型也有其对应的封装类，分别是：

boolean Boolean

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

4. &与&&

* **&：**(1)按位与，(2)逻辑与

* **&&：**短路与

说明：逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。

5. java中的基本数据类型

基本数据类型包括byte、int、short、long、float、double、boolean、char。

说明：String 不是基本的数据类型，是final类型的类。

6. 抽象类与接口的区别

**说明：**

接口是对动作的抽象，抽象类是对根源的抽象。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类(如果是类的话……)，他们的抽象类是人。说明，他们都是人。

人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类(抽象类)(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

区别如下：

抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

抽象类要被子类继承，接口要被类实现。

接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

抽象类可以有具体的方法 和属性, 接口只能有抽象方法和不可变常量

抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果

抽象类里可以没有抽象方法

如果一个类里有抽象方法，那么这个类只能是抽象类

抽象方法要被实现，所以不能是静态的，也不能是私有的。

接口可继承接口，并可多继承接口，但类只能单根继承。

抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高

抽象类主要用来抽象类别,接口主要用来抽象功能.

抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。

7. java的基本特性

###7.1 抽象

现实生活中的事物被抽象成对象，把具有相同属性和行为的对象被抽象成类，再从具有相同属性和行为的类中抽象出父类。

7.2 封装

隐藏对象的属性和实现细节，仅仅对外公开接口。

封装具有一下优点：

便于使用者正确、方便的使用系统，防止使用者错误修改系统属性；

有助于建立各个系统之间的松耦合关系；

提高软件的可重用性；

降低了大型系统的风险，即便整个系统不成功，个别独立的子系统有可能还有价值。

封装的两大原则：

把尽可能多的东西藏起来，对外提供简洁的接口；

把所有的属性封装起来。

7.3 继承

子类和父类之间的继承关系，子类可以获取到父类的属性和方法。

**注：关于子类能否继承父类的私有方法？ **

从语言角度上说：JDK官方文档明确说明子类不能继承父类的私有方法；

但从内存角度来说，jvm在实例化子类对象之前，会先在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类对象。所以子类确实拥有父类所有的属性和方法，但是父类中的私有方法子类无法访问。

7.4 多态

java语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。