乐趣区

01.Java基础问题汇总

目录介绍

1.0.0.1 请手写 equal 方法,讲讲具体的原理?
1.0.0.2 请说下 String 与 StringBuffer 区别,StringBuffer 底部如何实现?String 类可以被继承吗,为什么?
1.0.0.3 String a=”” 和 String a=new String(“”) 的的关系和异同?String 的创建机制?
1.0.0.4 static 关键字可以修饰什么?static 使用的注意事项有哪些?static 关键字的特点?
1.0.0.5 为什么 Java 中的 String 是不可变的(Immutable)?字符串设计和实现考量?String 不可变的好处?
1.0.0.6 Hashcode 与 equal 区别,什么时候需要用到 hashcode?讲讲里面的原理。如何解决 Hash 冲突?
1.0.0.7 访问修饰符 public,private,protected, 以及不写(默认)时的区别?
1.0.0.8 静态变量和实例变量的区别?成员变量与局部变量的区别有那些?
1.0.0.9 如何实现对象克隆?深克隆,浅克隆分别说的是什么意思?
1.0.1.0 int 和 Integer 的区别?装箱、拆箱什么含义?什么时候装箱 / 拆箱?装箱和拆箱是如何实现的?
1.0.1.1 Object 有哪些公有方法?
1.0.1.2 final,finally,finalize 有什么不同?finally 什么情况下不会被执行?
1.0.1.3 为什么要使用通配符?上界通配符和下界通配符如何理解和注意要点?什么是无界通配符?
1.0.1.4 什么是泛型擦除,能否通过开发中实际案例说下?如何获取泛型的具体的类型【反射】?
1.0.1.5 如何验证 int 类型是否线程安全?那些类型是线程安全的?举一个线程安全的例子【AtomicInteger】?
1.0.1.6 Java 序列话中如果有些字段不想进行序列化怎么办?
1.0.1.7 有没有可能 两个不相等的对象有相同的 hashcode?当两个对象 hashcode 相同怎么办?如何获取值对象?
1.0.1.8 原始数据类型和引用类型局限性?为何要引用基本数据包装类?
1.0.1.9 new Integer(123) 与 Integer.valueOf(123) 有何区别,请从底层实现分析两者区别?

好消息

博客笔记大汇总【15 年 10 月到至今】,包括 Java 基础及深入知识点,Android 技术博客,Python 学习笔记等等,还包括平时开发中遇到的 bug 汇总,当然也在工作之余收集了大量的面试题,长期更新维护并且修正,持续完善……开源的文件是 markdown 格式的!同时也开源了生活博客,从 12 年起,积累共计 500 篇 [近 100 万字],将会陆续发表到网上,转载请注明出处,谢谢!
链接地址:https://github.com/yangchong2…
如果觉得好,可以 star 一下,谢谢!当然也欢迎提出建议,万事起于忽微,量变引起质变!所有博客将陆续开源到 GitHub!

1.0.0.1 请手写 equal 方法,讲讲具体的原理?

代码如下所示,如果是手写代码,一定要弄清楚逻辑思路!
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = count;
if (n == anotherString.count) {
int i = 0;
while (n– != 0) {
if (charAt(i) != anotherString.charAt(i))
return false;
i++;
}
return true;
}
}
return false;
}

1.0.0.2 请说下 String 与 StringBuffer 区别,StringBuffer 底部如何实现?String 类可以被继承吗,为什么?

String 类的特点
String 的特点是一旦被创建,就不能被改变。注意是地址不能改变。StringBuffer 底层是可变的字节序列……

String 类可以被继承吗
看 String 源码可知,String 类被 final 关键字修饰了,所以不能被继承。这个地方可以说下 final 关键字作用。

String、StringBuffer 和 StringBuilder 的区别?

String 是字符串常量,而 StringBuffer、StringBuilder 都是字符串变量,即 String 对象一创建后不可更改,而后两者的对象是可更改的:
StringBuffer 是线程安全的,而 StringBuilder 是非线程安全的,这是由于 StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁
String 更适用于少量的字符串操作的情况,StringBuilder 适用于单线程下在字符缓冲区进行大量操作的情况,StringBuffer 适用于多线程下在字符缓冲区进行大量操作的情况
技术博客大总结

1.0.0.3 String a=”” 和 String a=new String(“”) 的的关系和异同?String 的创建机制?

区别

通过 String a=”” 直接赋值的方式得到的是一个字符串常量,存在于常量池;注意,相同内容的字符串在常量池中只有一个,即如果池已包含内容相等的字符串会返回池中的字符串,反之会将该字符串放入池中
通过 new String(“”) 创建的字符串不是常量是实例对象,会在堆内存开辟空间并存放数据,且每个实例对象都有自己的地址空间

String 的创建机制
由于 String 在 Java 世界中使用过于频繁,Java 为了避免在一个系统中产生大量的 String 对象,引入了字符串常量池。其运行机制是:创建一个字符串时,首先检查池中是否有值相同的字符串对象,如果有则不需要创建直接从池中刚查找到的对象引用;如果没有则新建字符串对象,返回对象引用,并且将新创建的对象放入池中。但是,通过 new 方法创建的 String 对象是不检查字符串池的,而是直接在堆区或栈区创建一个新的对象,也不会把对象放入池中。上述原则只适用于通过直接量给 String 对象引用赋值的情况。

1.0.0.4 static 关键字可以修饰什么?static 使用的注意事项有哪些?static 关键字的特点?

可以用来修饰:成员变量,成员方法,代码块,内部类等。具体如下所示

修饰成员变量和成员方法

被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享,可以并且建议通过类名调用。
被 static 声明的成员变量属于静态成员变量,静态变量存放在 Java 内存区域的方法区。

静态代码块

静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行 (静态代码块—> 非静态代码块—> 构造方法)
该类不管创建多少对象,静态代码块只执行一次.

静态内部类(static 修饰类的话只能修饰内部类)

静态内部类与非静态内部类之间存在一个最大的区别:
非静态内部类在编译完成之后会隐含地保存着一个引用,该引用是指向创建它的外围内,但是静态内部类却没有。没有这个引用就意味着:1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非 static 成员变量和方法。

静态导包 (用来导入类中的静态资源,1.5 之后的新特性):
这两个关键字连用可以指定导入某个类中的指定静态资源,并且不需要使用类名调用类中静态成员,可以直接使用类中静态成员变量和成员方法。

static 使用的注意事项有哪些?

在静态方法中是没有 this 关键字的

静态是随着类的加载而加载,this 是随着对象的创建而存在。
静态比对象先存在。

静态方法只能访问静态的成员变量和静态的成员方法【静态只能访问静态, 非静态可以访问静态的也可以访问非静态的】

static 关键字的特点?

随着类的加载而加载
优先于对象存在
被类的所有对象共享
可以通过类名调用【静态修饰的内容一般我们称其为:与类相关的,类成员】

1.0.0.5 为什么 Java 中的 String 是不可变的(Immutable)?字符串设计和实现考量?String 不可变的好处?

不可变类 String 的原因

String 主要的三个成员变量 char value[],int offset, int count 均是 private,final 的,并且没有对应的 getter/setter;
String 对象一旦初始化完成,上述三个成员变量就不可修改;并且其所提供的接口任何对这些域的修改都将返回一个新对象;
技术博客大总结
是典型的 Immutable 类,被声明成为 final class,所有属性也都是 final 的。也由于它的不可变,类似拼接、裁剪字符串等动作,都会产生新的 String 对象。

字符串设计和实现考量?

String 是 Immutable 类的典型实现,原生的保证了基础线程安全,因为你无法对它内部数据进行任何修改,这种便利甚至体现在拷贝构造函数中,由于不可变,Immutable 对象在拷贝时不需要额外复制数据。
为了实现修改字符序列的目的,StringBuffer 和 StringBuilder 底层都是利用可修改的(char,JDK 9 以后是 byte)数组,二者都继承了 AbstractStringBuilder,里面包含了基本操作,区别仅在于最终的方法是否加了 synchronized。
这个内部数组应该创建成多大的呢?如果太小,拼接的时候可能要重新创建足够大的数组;如果太大,又会浪费空间。目前的实现是,构建时初始字符串长度加 16(这意味着,如果没有构建对象时输入最初的字符串,那么初始值就是 16)。我们如果确定拼接会发生非常多次,而且大概是可预计的,那么就可以指定合适的大小,避免很多次扩容的开销。扩容会产生多重开销,因为要抛弃原有数组,创建新的(可以简单认为是倍数)数组,还要进行 arraycopy。

String 不可变的好处?

可以缓存 hash 值
因为 String 的 hash 值经常被使用,例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变,因此只需要进行一次计算。

String Pool 的需要
如果一个 String 对象已经被创建过了,那么就会从 String Pool 中取得引用。只有 String 是不可变的,才可能使用 String Pool。

安全性
String 经常作为参数,String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的,那么在网络连接过程中,String 被改变,改变 String 对象的那一方以为现在连接的是其它主机,而实际情况却不一定是。

线程安全
String 不可变性天生具备线程安全,可以在多个线程中安全地使用。

1.0.0.6 Hashcode 与 equal 区别,什么时候需要用到 hashcode?讲讲里面的原理。如何解决 Hash 冲突?

Hashcode 与 equal 区别

equals() 比较两个对象的地址值是否相等;hashCode() 得到的是对象的存储位置,可能不同对象会得到相同值
有两个对象,若 equals() 相等,则 hashcode() 一定相等;hashcode() 不等,则 equals() 一定不相等;hashcode() 相等,equals() 可能相等、可能不等
使用 equals() 比较两个对象是否相等效率较低,最快办法是先用 hashCode() 比较,如果 hashCode() 不相等,则这两个对象肯定不相等;如果 hashCode() 相等,此时再用 equal() 比较,如果 equal() 也相等,则这两个对象的确相等。

什么时候需要用到 hashcode

同样用于鉴定 2 个对象是否相等的,java 集合中有 list 和 set 两类,其中 set 不允许元素重复实现,那个这个不允许重复实现的方法,如果用 equal 去比较的话,如果存在 1000 个元素,你 new 一个新的元素出来,需要去调用 1000 次 equal 去逐个和他们比较是否是同一个对象,这样会大大降低效率。hashcode 实际上是返回对象的存储地址,如果这个位置上没有元素,就把元素直接存储在上面,如果这个位置上已经存在元素,这个时候才去调用 equal 方法与新元素进行比较,相同的话就不存了,散列到其他地址上
技术博客大总结

如何解决 Hash 冲突

开放定址法:常见的线性探测方式,在冲突发生时,顺序查看表中下一单元,直到找出一个空单元或查遍全表
链地址法:将有冲突数组位置生出链表
建立公共溢出区:将哈希表分为基本表和溢出表两部分,和基本表发生冲突的元素一律填入溢出表
再哈希法:构造多个不同的哈希函数,有冲突使用下一个哈希函数计算 hash 值

1.0.0.7 访问修饰符 public,private,protected, 以及不写(默认)时的区别?

类的成员不写访问修饰时默认为 default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。
区别如下:
作用域 当前类 同包 子类 其他
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×

1.0.0.8 静态变量和实例变量的区别?成员变量与局部变量的区别有那些?

静态变量和实例变量的区别

静态变量是被 static 修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量在内存中有且仅有一个拷贝。静态变量可以实现让多个对象共享内存。在 Java 开发中,上下文类和工具类中通常会有大量的静态成员。
实例变量必须依存于某一实例,需要先创建对象然后通过对象才能访问到它

成员变量与局部变量的区别

1. 从语法形式上,看成员变量是属于类的,而局部变量是在方法中定义的变量或是方法的参数;成员变量可以被 public,private,static 等修饰符所修饰,而局部变量不能被访问控制修饰符及 static 所修饰;但是,成员变量和局部变量都能被 final 所修饰;
2. 从变量在内存中的存储方式来看,成员变量是对象的一部分,而对象存在于堆内存,局部变量存在于栈内存
3. 从变量在内存中的生存时间上看,成员变量是对象的一部分,它随着对象的创建而存在,而局部变量随着方法的调用而自动消失。
4. 成员变量如果没有被赋初值,则会自动以类型的默认值而赋值(一种情况例外被 final 修饰但没有被 static 修饰的成员变量必须显示地赋值);而局部变量则不会自动赋值。

1.0.0.9 如何实现对象克隆?深克隆,浅克隆分别说的是什么意思?

有两种方式:

1. 实现 Cloneable 接口并重写 Object 类中的 clone() 方法;
2. 实现 Serializable 接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下。

注意问题:
基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用 Object 类的 clone 方法克隆对象。

代码如下所示
public class MyUtil {

private MyUtil() {
throw new AssertionError();
}

public static <T> T clone(T obj) throws Exception {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bout);
oos.writeObject(obj);

ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bin);
return (T) ois.readObject();

// 说明:调用 ByteArrayInputStream 或 ByteArrayOutputStream 对象的 close 方法没有任何意义
// 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源
}
}

class CloneTest {
public static void main(String[] args) {
try {
Person p1 = new Person(“Hao LUO”, 33, new Car(“Benz”, 300));
Person p2 = MyUtil.clone(p1); // 深度克隆
p2.getCar().setBrand(“BYD”);
// 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性
// 原来的 Person 对象 p1 关联的汽车不会受到任何影响
// 因为在克隆 Person 对象时其关联的汽车对象也被克隆了
System.out.println(p1);
} catch (Exception e) {
e.printStackTrace();
}
}
}

通过反射获得泛型的实际类型参数

把泛型变量当成方法的参数,利用 Method 类的 getGenericParameterTypes 方法来获取泛型的实际类型参数

例子:
public class GenericTest {

public static void main(String[] args) throws Exception {
getParamType();
}

/* 利用反射获取方法参数的实际参数类型 */
public static void getParamType() throws NoSuchMethodException{
Method method = GenericTest.class.getMethod(“applyMap”,Map.class);
// 获取方法的泛型参数的类型
Type[] types = method.getGenericParameterTypes();
System.out.println(types[0]);
// 参数化的类型
ParameterizedType pType = (ParameterizedType)types[0];
// 原始类型
System.out.println(pType.getRawType());
// 实际类型参数
System.out.println(pType.getActualTypeArguments()[0]);
System.out.println(pType.getActualTypeArguments()[1]);
}

/* 供测试参数类型的方法 */
public static void applyMap(Map<Integer,String> map){

}

}

输出结果:
java.util.Map<java.lang.Integer, java.lang.String>
interface java.util.Map
class java.lang.Integer
class java.lang.String

1.0.1.0 int 和 Integer 的区别?装箱、拆箱什么含义?什么时候装箱 / 拆箱?装箱和拆箱是如何实现的?

int 和 Integer 的区别:基本数据类型、引用类型

Integer 是 int 的包装类,int 则是 java 的一种基本数据类型
Integer 变量必须实例化后才能使用,而 int 变量不需要
Integer 实际是对象的引用,当 new 一个 Integer 时,实际上是生成一个指针指向此对象;而 int 则是直接存储数据值
Integer 的默认值是 null,int 的默认值是 0

装箱、拆箱

装箱就是自动将基本数据类型转换为包装器类型
拆箱就是自动将包装器类型转换为基本数据类型

// 拆箱
int yc = 5;
// 装箱
Integer yc = 5;

jdk 中如何操作装箱、拆箱

在 JDK 中,装箱过程是通过调用包装器的 valueOf 方法实现的,而拆箱过程是通过调用包装器的 xxxValue 方法实现的(xxx 代表对应的基本数据类型)。
Integer、Short、Byte、Character、Long 这几个类的 valueOf 方法的实现是类似的,有限可列举,共享 [-128,127];
Double、Float 的 valueOf 方法的实现是类似的,无限不可列举,不共享;
Boolean 的 valueOf 方法的实现不同于以上的整型和浮点型,只有两个值,有限可列举,共享;

什么时候装箱 / 拆箱?
什么时候拆箱主要取决于:在当前场景下,你需要的是引用类型还是原生类型。若需要引用类型,但传进来的值是原生类型,则自动装箱(例如,使用 equals 方法时传进来原生类型的值);若需要的是原生类型,但传进来的值是引用类型,则自动拆箱(例如,使用运算符进行运算时,操作数是包装类型)。

装箱和拆箱是如何实现的
以 Interger 类为例,下面看一段代码来了解装箱和拆箱的实现
public class Main {
public static void main(String[] args) {
Integer y = 10;
int c = i;
}
}

然后来编译一下:

从反编译得到的字节码内容可以看出,在装箱的时候自动调用的是 Integer 的 valueOf(int) 方法。而在拆箱的时候自动调用的是 Integer 的 intValue 方法。
因此可以用一句话总结装箱和拆箱的实现过程:装箱过程是通过调用包装器的 valueOf 方法实现的,而拆箱过程是通过调用包装器的 xxxValue 方法实现的。(xxx 代表对应的基本数据类型)。

1.0.1.1 Object 有哪些公有方法?

常用方法

equals():和 == 作用相似
hashCode():用于哈希查找,重写了 equals() 一般都要重写该方法
getClass():获取 Class 对象
wait():让当前线程进入等待状态,并释放它所持有的锁
notify()&notifyAll():唤醒一个(所有)正处于等待状态的线程
toString():转换成字符串

1.0.1.2 final,finally,finalize 有什么不同?finally 什么情况下不会被执行?

final 可以修饰类,方法,变量

final 修饰类代表类不可以继承拓展
final 修饰变量表示变量不可以修改
final 修饰方法表示方法不可以被重写

finally 则是 Java 保证重点代码一定要被执行的一种机制
可以使用 try-finally 或者 try-catch-finally 来进行类似关闭 JDBC 连接、保证 unlock 锁等动作。

finalize 是基础类 java.lang.Object 的一个方法
它的设计目的是保证对象在被垃圾收集前完成特定资源的回收。finalize 机制现在已经不推荐使用,并且在 JDK 9 开始被标记为 deprecated。

final 关键字深入理解

可以将方法或者类声明为 final,这样就可以明确告知别人,这些行为是不许修改的。
如果你关注过 Java 核心类库的定义或源码,有没有发现 java.lang 包下面的很多类,相当一部分都被声明成为 final class?在第三方类库的一些基础类中同样如此,这可以有效避免 API 使用者更改基础功能,某种程度上,这是保证平台安全的必要手段。
使用 final 修饰参数或者变量,也可以清楚地避免意外赋值导致的编程错误,甚至,有人明确推荐将所有方法参数、本地变量、成员变量声明成 final。
final 变量产生了某种程度的不可变(immutable)的效果,所以,可以用于保护只读数据,尤其是在并发编程中,因为明确地不能再赋值 final 变量,有利于减少额外的同步开销,也可以省去一些防御性拷贝的必要。

在以下 4 种特殊情况下,finally 块不会被执行:

1. 在 finally 语句块中发生了异常。
2. 在前面的代码中用了 System.exit() 退出程序。
3. 程序所在的线程死亡。
4. 关闭 CPU。

1.0.1.3 为什么要使用通配符?上界通配符和下界通配符如何理解和注意要点?什么是无界通配符?

为什么要使用通配符
通配符的设计存在一定的场景,例如在使用泛型后,首先声明了一个 Animal 的类,而后声明了一个继承 Animal 类的 Cat 类,显然 Cat 类是 Animal 类的子类,但是 List<Cat> 却不是 List<Animal> 的子类型,而在程序中往往需要表达这样的逻辑关系。为了解决这种类似的场景,在泛型的参数类型的基础上新增了通配符的用法。

<? extends T> 上界通配符
上界通配符顾名思义,<? extends T> 表示的是类型的上界【包含自身】,因此通配的参数化类型可能是 T 或 T 的子类。正因为无法确定具体的类型是什么,add 方法受限(可以添加 null,因为 null 表示任何类型),但可以从列表中获取元素后赋值给父类型。如上图中的第一个例子,第三个 add() 操作会受限,原因在于 List<Animal> 和 List<Cat> 是 List<? extends Animal> 的子类型。

<? super T> 下界通配符
下界通配符 <? super T> 表示的是参数化类型是 T 的超类型(包含自身),层层至上,直至 Object,编译器无从判断 get() 返回的对象的类型是什么,因此 get() 方法受限。但是可以进行 add() 方法,add() 方法可以添加 T 类型和 T 类型的子类型,如第二个例子中首先添加了一个 Cat 类型对象,然后添加了两个 Cat 子类类型的对象,这种方法是可行的,但是如果添加一个 Animal 类型的对象,显然将继承的关系弄反了,是不可行的。

<?> 无界通配符

任意类型,如果没有明确,那么就是 Object 以及任意的 Java 类了
无界通配符用 <?> 表示,? 代表了任何的一种类型,能代表任何一种类型的只有 null(Object 本身也算是一种类型,但却不能代表任何一种类型,所以 List<Object> 和 List<null> 的含义是不同的,前者类型是 Object,也就是继承树的最上层,而后者的类型完全是未知的)。
技术博客大总结

1.0.1.4 什么是泛型擦除,能否通过开发中实际案例说下?如何获取泛型的具体的类型【反射】?

开发中的泛型擦除案例
泛型是提供给 javac 编译器使用的,限定集合的输入类型,编译器编译带类型说明的集合时会去掉“类型”信息。
public class GenericTest {
public static void main(String[] args) {
new GenericTest().testType();
}
public void testType(){
ArrayList<Integer> collection1 = new ArrayList<Integer>();
ArrayList<String> collection2= new ArrayList<String>();
System.out.println(collection1.getClass()==collection2.getClass());
// 两者 class 类型一样, 即字节码一致
System.out.println(collection2.getClass().getName());
//class 均为 java.util.ArrayList, 并无实际类型参数信息
}

// 输出结果
//true
//java.util.ArrayList
}

如何获取泛型的具体的类型?

使用反射可跳过编译器,往某个泛型集合加入其它类型数据。
只有引用类型才能作为泛型方法的实际参数,具体案例如下所示

public class GenericTest {
public static void main(String[] args) {
swap(new String[]{“111″,”222”},0,1);// 编译通过

//swap(new int[]{1,2},0,1);
// 编译不通过, 因为 int 不是引用类型

swap(new Integer[]{1,2},0,1);// 编译通过
}

/* 交换数组 a 的第 i 个和第 j 个元素 */
public static <T> void swap(T[]a,int i,int j){
T temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
但注意基本类型有时可以作为实参,因为有自动装箱和拆箱。下面例子 (编译通过了):
public class GenericTest {
public static void main(String[] args) {
new GenericTest().testType();
int a = biggerOne(3,5);
//int 和 double, 取交为 Number
Number b = biggerOne(3,5.5);
//String 和 int 取交为 Object
Object c = biggerOne(“1”,2);
}
// 从 x,y 中返回 y
public static <T> T biggerOne(T x,T y){
return y;
}
}

同时,该例还表明,当实参不一致时,T 取交集,即第一个共同的父类。

另外,如果用 Number b = biggerOne(3,5.5); 改为 String c = biggerOne(3,5.5); 则编译报错:

Error:(17, 29) java: 不兼容的类型: 推断类型不符合上限
推断: java.lang.Number&java.lang.Comparable<? extends java.lang.Number&java.lang.Comparable<?>>
上限: java.lang.String,java.lang.Object

1.0.1.5 如何验证 int 类型是否线程安全?那些类型是线程安全的?举一个线程安全的例子【AtomicInteger】?

如何验证 int 类型是否线程安全

200 个线程,每个线程对共享变量 count 进行 50 次 ++ 操作
int 作为基本类型,直接存储在内存栈,且对其进行 +,- 操作以及 ++,–操作都不是原子操作,都有可能被其他线程抢断,所以不是线程安全。int 用于单线程变量存取,开销小,速度快
技术博客大总结

int count = 0;
private void startThread() {
for (int i = 0;i < 200; i++){
new Thread(new Runnable() {
@Override
public void run() {
for (int k = 0; k < 50; k++){
count++;
}
}
}).start();
}
// 休眠 10 秒,以确保线程都已启动
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
Log.e(“ 打印日志 —-“,count+””);
}
}

// 期望输出 10000,最后输出的是 9818
// 注意:打印日志 —-: 9818

那些类型是线程安全的
Java 自带的线程安全的基本类型包括:AtomicInteger, AtomicLong, AtomicBoolean, AtomicIntegerArray,AtomicLongArray 等

AtomicInteger 线程安全版

AtomicInteger 类中有有一个变量 valueOffset,用来描述 AtomicInteger 类中 value 的内存位置。
当需要变量的值改变的时候,先通过 get()得到 valueOffset 位置的值,也即当前 value 的值. 给该值进行增加,并赋给 next
compareAndSet()比较之前取到的 value 的值当前有没有改变,若没有改变的话,就将 next 的值赋给 value,倘若和之前的值相比的话发生变化的话,则重新一次循环,直到存取成功,通过这样的方式能够保证该变量是线程安全的
value 使用了 volatile 关键字,使得多个线程可以共享变量,使用 volatile 将使得 VM 优化失去作用,在线程数特别大时,效率会较低。

private static AtomicInteger atomicInteger = new AtomicInteger(1);
static Integer count1 = Integer.valueOf(0);
private void startThread1() {
for (int i = 0;i < 200; i++){
new Thread(new Runnable() {
@Override
public void run() {
for (int k = 0; k < 50; k++){
// getAndIncrement: 先获得值,再自增 1,返回值为自增前的值
count1 = atomicInteger.getAndIncrement();
}
}
}).start();
}
// 休眠 10 秒,以确保线程都已启动
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
Log.e(“ 打印日志 —-“,count1+””);
}
}

// 期望输出 10000,最后输出的是 10000
// 注意:打印日志 —-: 10000

//AtomicInteger 使用了 volatile 关键字进行修饰,使得该类可以满足线程安全。
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}

1.0.1.6 Java 序列话中如果有些字段不想进行序列化怎么办?

对于不想进行序列化的变量,使用 transient 关键字修饰。
transient 关键字的作用是:阻止实例中那些用此关键字修饰的的变量序列化;当对象被反序列化时,被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量,不能修饰类和方法。

1.0.1.8 原始数据类型和引用类型局限性?为何要引用基本数据包装类?

原始数据类型和引用类型局限性

原始数据类型和 Java 泛型并不能配合使用
Java 的泛型某种程度上可以算作伪泛型,它完全是一种编译期的技巧,Java 编译期会自动将类型转换为对应的特定类型,这就决定了使用泛型,必须保证相应类型可以转换为 Object。

为何要引用基本数据包装类

就比如,我们使用泛型,需要用到基本数据类型的包装类。
Java 的对象都是引用类型,如果是一个原始数据类型数组,它在内存里是一段连续的内存,而对象数组则不然,数据存储的是引用,对象往往是分散地存储在堆的不同位置。这种设计虽然带来了极大灵活性,但是也导致了数据操作的低效,尤其是无法充分利用现代 CPU 缓存机制。
Java 为对象内建了各种多态、线程安全等方面的支持,但这不是所有场合的需求,尤其是数据处理重要性日益提高,更加高密度的值类型是非常现实的需求。

1.0.1.9 new Integer(123) 与 Integer.valueOf(123) 有何区别,请从底层实现分析两者区别?

new Integer(123) 与 Integer.valueOf(123) 的区别在于:

new Integer(123) 每次都会新建一个对象;
Integer.valueOf(123) 会使用缓存池中的对象,多次调用会取得同一个对象的引用。

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y); // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k); // true

valueOf() 方法的实现比较简单,就是先判断值是否在缓存池中,如果在的话就直接返回缓存池的内容。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

在 Java 8 中,Integer 缓存池的大小默认为 -128~127。
static final int low = -128;
static final int high;
static final Integer cache[];

static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty(“java.lang.Integer.IntegerCache.high”);
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE – (-low) -1);
} catch(NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;

cache = new Integer[(high – low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);

// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}

编译器会在自动装箱过程调用 valueOf() 方法,因此多个 Integer 实例使用自动装箱来创建并且值相同,那么就会引用相同的对象。
Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

基本类型对应的缓冲池如下:

boolean values true and false
all byte values
short values between -128 and 127
int values between -128 and 127
char in the range u0000 to u007F

在使用这些基本类型对应的包装类型时,就可以直接使用缓冲池中的对象。

其他介绍
01. 关于博客汇总链接

1. 技术博客汇总

2. 开源项目汇总

3. 生活博客汇总

4. 喜马拉雅音频汇总

5. 其他汇总

02. 关于我的博客

我的个人站点:www.yczbj.org,www.ycbjie.cn
github:https://github.com/yangchong211

知乎:https://www.zhihu.com/people/…

简书:http://www.jianshu.com/u/b7b2…

csdn:http://my.csdn.net/m0_37700275

喜马拉雅听书:http://www.ximalaya.com/zhubo…

开源中国:https://my.oschina.net/zbj161…

泡在网上的日子:http://www.jcodecraeer.com/me…

邮箱:yangchong211@163.com
阿里云博客:https://yq.aliyun.com/users/a… 239.headeruserinfo.3.dT4bcV
segmentfault 头条:https://segmentfault.com/u/xi…

掘金:https://juejin.im/user/593943…

退出移动版