1、HashMap、HashTable、ConcurrentHashMap的区别HashMap和HashTable都实现...

阿里后端面试题第四波, 从Java程序员必须掌握的Hash table开始(图1)

1、HashMap、HashTable、ConcurrentHashMap的区别

HashMap和HashTable都实现了Map接口,里面存放的元素不保证有序,并且不存在相同元素。

区别(线程安全和保存值是否为null方面)

1 HashMap和HashTable在功能上基本相同,但HashMap是线程不安全的,HashTable是线程安全的。

HashMap的put源码如下:

public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold) } if (key == null) return putForNullKey(value) //说明key和value值都是可以为null int hash = hash(key) int i = indexFor(hash, table.length) for (EntryK,Ve = table【i】 e != null; e = e.next) { Object k; if (e.hash == hash(k = e.key) == key key.equals(k)) { V oldValue = e.value; e.value = value; e.recordAccess(this) return oldValue; } } modCount++; addEntry(hash, key, value, i) return null; }

2可以看到,HashMap的key和value都是可以为null的,当get方法返回null值时,HashMap中可能存在某个key,只不过该key值对应的value为null,也有可能是HashM中不存在该key,所以不能使用get==null来判断是否存在某个key值,对于HashMap和HashTable,提供了containsKey方法来判断是否存在某个key。

HashTable的put源码如下:

public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { //当value==null的时候,会抛出异常 throw new NullPointerException; } // Makes sure the key is not already in the hashtable. Entry tab = table; int hash = hash(key) int index = (hash0x7FFFFFFF) % tab.length; for (EntryK,Ve = tabindex ; e != null ; e = e.next) { if (e.hash == hash)e.key.equals(key) { V old = e.value; e.value = value; return old; } } modCount++; if (count= threshold) { // Rehash the table if the threshold is exceeded rehash; tab = table; hash = hash(key) index = (hash0x7FFFFFFF) % tab.length; } // Creates the new entry. EntryK,Ve = tabindex tabindex = new Entry(hash, key, value, e) count++; return null; }

3HashTable是不允许key和value为null的。HashTable中的方法大部分是同步的,因此HashTable是线程安全的。

拓展:

1 影响HashMap或HashTable性能的两个因素:初始容量和load factor。

HashMap中有如下描述: When the number of entries in the hash table exceeds the product of the load factor and the current capacity。

the hash table isirehashed/i(that is, internal data structures are rebuilt)

当我们Hash表中数据记录的大小超过当前容量,Hash表会进行rehash操作,其实就是自动扩容,这种操作一般会比较耗时。所以当我们能够预估Hash表大小时,在初始化的时候就尽量指定初始容量,避免中途Hash表重新扩容操作,如:

HashMapString, Integermap = new HashMapString, Integer(20)

类似可以指定容量的还有ArrayList、Vector

2使用选择上,当我们需要保证线程安全,HashTable优先选择。当我们程序本身就是线程安全的,HashMap是优先选择。

其实HashTable也只是保证在数据结构层面上的同步,对于整个程序还是需要进行多线程并发控制;在JDK后期版本中,对于HashMap,可以通过Collections获得同步的HashMap;如下:

Map m = Collections.synchronizedMapnew HashMap...。

这种方式获得了具有同步能力的HashMap。

3在JDK1.5以后,出现了ConcurrentHashMap,它可以很好地解决在并发程序中使用HashMap的问题,ConcurrentHashMap和HashTable功能很像,不允许为null的key或value,但它不是通过给方法加synchronized方法进行并发控制的。

在ConcurrentHashMap中使用分段锁技术Segment,将数据分成一段一段的存储,给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问,能够实现真正的并发访问。效率也比HashTable好的多。

2、TreeMap、HashMap、LinkedHashMap的区别

关于Map集合,前面几篇都有讲过,可以去回顾一下。而TreeMap、HashMap、LinkedHashMap都是Map的一些具体实现类,其关系图如下:

1LinkedHashMap保存了数据的插入顺序,底层是通过一个双链表的数据结构来维持这个插入顺序的。key和value都可以为null。

2TreeMap实现了SortMap接口,它保存的记录是根据键值key排序,默认是按key升序排列。也可以指定排序的Comparator。

HashMap、LinkedHashMap和TreeMap都是线程不安全的,HashTable是线程安全的。提供两种遍历Map的方法如下:

1推荐方式:

MapString, Integermap = new HashMapString, Integer20 for Map.EntryString, Integerentry : map.entrySet{ //直接遍历出Entry System.out.println“key--”+entry.getKey+“value--”+m.getentry.getValue; }

这种方式相当于首先通过SetMap.EntryString,Integerset = map.entrySet;方式拿到Set集合,而Set集合是可以通过foreach的方式遍历的。

2 普通方式:

MapString, Integermap = new HashMapString, Integer20 IteratorStringkeySet = map.keySet.iterator; //遍历Hash表中的key值集合,通过key获取value whilekeySet .hasNext{ Object key = keySet .next; System.out.println“key--”+key+“value--”+m.getkey; } 3、Collection包结构,与Collections的区别。

Collection的包结构如下:

Statck类为Vector的子类。由于Collection类继承Iterable类,所以,所有Collection的实现类都可以通过foreach的方式进行遍历。

Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。

当于对Array进行类似操作的类—Arrays。

如,Collections.max(Collection coll) 取coll中最大的元素。

Collections.sort(List list) 对list中元素排序

4、OOM你遇到过哪些情况,SOF你遇到过哪些情况

OOM:OutOfMemoryError异常。

即内存溢出,是指程序在申请内存时,没有足够的空间供其使用,出现了Out Of Memory,也就是要求分配的内存超出了能给你的,不能满足需求,于是产生溢出。

内存溢出分为上溢和下溢,比方说栈,栈满时再做进栈必定产生空间溢出,叫上溢,栈空时再做退栈也产生空间溢出,称为下溢。

有时候内存泄露会导致内存溢出,所谓内存泄露(memory leak)是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄露危害可以忽略,但内存泄露堆积后果很严重,无论多少内存,迟早会被占光,举个例子,就是说的篮子(内存)是有限的,而你申请了一个篮子,拿到之后没有归还(忘记还了或是丢了)于是造成一次内存泄漏。在你需要用篮子的时候,又去申请,如此反复,最终的篮子无法满足你的需求,最终会由内存泄漏造成内存溢出。

遇到的OOM:

1Java Heap 溢出

Java堆用于存储对象实例,我们只要不断的创建对象,而又没有及时回收这些对象(即内存泄漏)就会在对象数量达到最大堆容量限制后产生内存溢出异常。

2方法区溢出

方法区用于存放Class的相关信息,如类名、访问修饰符、常量池、字段描述、方法描述等。

异常信息:java.lang.OutOfMemoryError:PermGen space

方法区溢出也是一种常见的内存溢出异常,一个类如果要被垃圾收集器回收,判定条件是很苛刻的。在经常动态生成大量Class的应用中,要特别注意这点。

SOF:StackOverflow(堆栈溢出)

当应用程序递归太深而发生堆栈溢出时,抛出该错误。因为栈一般默认为1-2m,一旦出现死循环或者是大量的递归调用,在不断的压栈过程中,造成栈容量超过1m而导致溢出。

栈溢出的原因:

递归调用 大量循环或死循环 全局变量是否过多 数组、List、Map数据过大

OOM在Android中出现比较多:

场景有: 加载的图片太多或图片过大时、分配特大的数组、内存相应资源过多没有来不及释放等。

解决方法:

1在内存引用上做处理,软引用是主要用于内存敏感的高速缓存。在jvm报告内存不足之前会清除所有的软引用,这样以来gc就有可能收集软可及的对象,可能解决内存吃紧问题,避免内存溢出。什么时候会被收集取决于gc的算法和gc运行时可用内存的大小。

3显示的调用GC来回收内存,如:

if(bitmapObject.isRecycled==false) //如果没有回收 bitmapObject.recycle。

4优化Dalvik虚拟机的堆内存分配

增强程序堆内存的处理效率

//在程序onCreate时就可以调用 即可 privatefinalstaticfloat TARGET_HEAP_UTILIZATION = 0.75f; VMRuntime.getRuntime.setTargetHeapUtilization(TARGET_HEAP_UTILIZATION)

设置堆内存的大小

privatefinalstaticintCWJ_HEAP_SIZE = 6* 1024* 1024; //设置最小heap内存为6MB大小 VMRuntime.getRuntime.setMinimumHeapSize(CWJ_HEAP_SIZE)

5用LruCache 和 AsyncTask解决

从cache中去取Bitmap,如果取到Bitmap,就直接把这个Bitmap设置到ImageView上面。

如果缓存中不存在,那么启动一个task去加载(可能从文件来,也可能从网络)

5、Java面向对象的三个特征与含义,多态的实现方式

Java中两个非常重要的概念:类和对象。类可以看做是一个模板,描述了一类对象的属性和行为;而对象是类的一个具体实现。Java面向对象的三大基本特征:

1封装

属性用来描述同一类事物的特征,行为用来描述同一类事物可做的一些操作。封装就是把属于同一类事物的共性(属性和行为)归到一个类中,只保留有限的接口和方法与外部进行交互,避免了外界对对象内部属性的。Java中使用访问控制符来保护对类、属性、方法的访问。

2继承

子类通过这种方式来接收父类所有的非private的属性和方法(构造方法除外)这里的接收是直接拥有的意思,即可以直接使用父类字段和方法,因此,继承相当于“扩展”子类在拥有了父类的属性和特征后,可以专心实现自己特有的功能。

构造方法不能被继承,因为在创建子类时,会先去自动“调用”父类的构造方法,如果真的需要子类构造函数特殊的形式,子类直接修改或重载自己的构造函数就好了。

3多态

多态是程序在运行的过程中,同一种类型在不同的条件下表现不同的结果。比如:

Animal a = new Dog; // 子类对象当做父类对象来使用,运行时,根据对象的实际类型去找子类覆盖之后的方法

多态实现方式:

设计时多态,通过方法的重载实现多态; 运行时多态,通过重写父类或接口的方法实现运行时多态; 6、interface与abstract类的区别

abstract class 只能被继承extends,体现的是一种继承关系,而根据继承的特征,有继承关系的子类和父类应该是一种“is-a”的关系,也即两者在本质上应该是相同的(有共同的属性特征)

interface 是用来实现的implements,它并不要求实现者和interface之间在本质上相同,是一种“like-a”的关系,interface只是定义了一系列的约定而已(实现者表示愿意遵守这些约定)所以一个类可以去实现多个interface(即该类遵守了多种约定)

很多情况下interface和abstract都能满足我们要求,在我们选择用abstract火interface的时候,尽量符合上面的要求,即如果两者间本质是一样的,是一种“is-a”的关系,尽量用abstract,当两者之间本质不同只是简单的约定行为的话,可以选择interface。

特点:

abstract类其实和普通类一样,拥有有自己的数据成员和方法,只不过abstract类里面可以定义抽象abstract的方法(声明为abstract的类也可以不定义abstract的方法,直接当做普通类使用,但是这样就失去了抽象类的意义) 一个类中声明了abstract的方法,该类必须声明为abstract类。 interface中只能定义常量和抽象方法。在接口中,我们定义的变量默认为public static final类型,所以不可以在显示类中修改interface中的变量;定义的方法默认为public abstract,其中abstract可以不明确写出。 7、static class 与non static class的区别

static class--静态内部类,non static class--非静态内部类,即普通内部类

普通内部类:

内部类可以直接使用外部类的所有变量(包括private、静态变量、普通变量)这也是内部类的主要优点(不用生成外部类对象而直接使用外部类变量)如下例子:

public class OutClass { private String mName = “lly” static int mAge = 12; class InnerClass{ String name; int age; private void getName{ name = mName; age = mAge; System.out.println(“name=”+name+“age=”+age) } } public static void main(String args) { //第一种初始化内部类方法 OutClass.InnerClass innerClass = new OutClass.new InnerClass; innerClass.getName; //第二种初始化内部类方法 OutClass out = new OutClass; InnerClass in = out.new InnerClass; in.getName; } }

输出:

可以看到,内部类里面可以直接访问外部类的静态和非静态变量,包括private变量。在内部类中,我们也可以通过外部类.this.变量名的方式访问外部类变量,如:name = OutClass.this.mName。

内部类的初始化依赖于外部类,只有外部类初始化出来了,内部类才能够初始化。

私有内部类(包括私有静态内部类和私有非静态内部类)

如果一个内部类只希望被外部类中的方法操作,那只要给该内部类加上private修饰,声明为private 的内部类只能在外部类中使用,不能在别的类中new出来。如上private class InnerClass{...},此时只能在OutClass类中使用。

静态内部类:

静态内部类只能访问外部类中的静态变量。如下:

public class OutClass { private String mName = “lly” static int mAge = 12; static class StaticClass{ String name = “lly2” int age; private void getName{ // name = mName; //不能引用外部类的非静态成员变量 age = mAge; System.out.println(“name=”+name+“age=”+age) } } public static void main(String args) { //第一种初始化静态内部类方法 OutClass.StaticClass staticClass = new OutClass.StaticClass; staticClass.getName; //或者直接使用静态内部类初始化 StaticClass staticClass2 = new StaticClass; staticClass2.getName; } }

输出:

可以看到,静态内部类只能访问外部类中的静态变量,静态内部类的初始化不依赖于外部类,由于是static,类似于方法使用,OutClass.StaticClass是一个整体。

匿名内部类:

匿名内部类主要是针对抽象类和接口的具体实现。在Android的监听事件中用的很多。如:

textView.setOnClickListener(new View.OnClickListener{ //OnClickListener为一个接口interface public void onClick(View v){ ... } } )

对于抽象类:

public abstract class Animal { public abstract void getColor; } public class Dog{ public static void mainString args { Animal dog = new Animal { @Override public void getColor { System.out.println“黑色”; } } ; dog.getColor; } }

输出:黑色

对于接口类似,只需要把abstract class 改为interface即可。

END——

看到网上疯传的《阿里Java架构师成长之路》网友瞬间沸腾了

字节跳动Java研发面试99题(含答案)JVM+Spring+MySQL+线程池+锁

Java程序员备战“金九银十”必备的面试技巧(附携程Java岗面试题)

Java程序员奋斗史,为了年薪40W,知道我这五年是怎么过来的吗?

本文相关词条概念解析:

内存

内存是计算机中重要的部件之一,它是与CPU进行沟通的桥梁。计算机中所有程序的运行都是在内存中进行的,因此内存的性能对计算机的影响非常大。内存(Memory)也被称为内存储器,其作用是用于暂时存放CPU中的运算数据,以及与硬盘等外部存储器交换的数据。只要计算机在运行中,CPU就会把需要运算的数据调到内存中进行运算,当运算完成后CPU再将结果传送出来,内存的运行也决定了计算机的稳定运行。内存是由内存芯片、电路板、金手指等部分组成的。

网友评论

头像
jokerq
面试JAVA程序员时,有哪些需要掌握的面试题?
2019-10-15 20:18 293
头像
抓个和尚做
如echo$obj;或print$obj;__clone()克隆对象时被调用
2019-10-10 05:55 666
头像
baobaojinh
onezero,写接口,很多公司是前后端完全分离
2019-10-13 10:56 318
头像
巫师很可爱
若不存在,则会调用__get函数
2019-10-14 10:19 297
头像
上之者上也
如果用在被包含文件中,则返回被包含的文件名
2019-10-15 01:28 560
头像
委屈art
如果有您用的模板引擎的名字是
2019-10-12 18:05 357
头像
麦子不香了
返回该方法被定义时的名字(区分大小写)
2019-10-17 08:21 809
头像
夏日的黑
php程序员面试题都有哪些?
2019-10-15 08:03 337
头像
太阳珊瑚花
__call()对象调用某个方法,若方法存在,则直接调用
2019-10-13 14:17 361
头像
刘玲1212
如果用在被包括文件中,则返回被包括的文件所在的目录
2019-10-17 11:53 779
头像
zjgyj
Js、jQuery
2019-10-08 01:58 200
头像
qyn1982
$_COOKIE[“user”];删除cookie
2019-10-10 13:59 487
头像
我若成仙
选取最适用的字段属性,应该尽量把字段设置为NOTNULL,这样在将来执行查询的时候,数据库不用去比较NULL值
2019-10-09 23:47 257
头像
fappleaa
在工作中,为什么Java程序员常常瞧不起PHP程序员?
2019-10-14 07:41 756
头像
飞天女侠啵c
此常量是在编译时定义
2019-10-13 02:33 739
头像
昔小朝
今天,小编根据自己曾经的面试经验和经历,已经开发JAVA这几年遇到的问题来说说面试JAVA时会被问道哪些题
2019-10-10 04:40 449
头像
熊熊aaa
__LINE__文件中的当前行号
2019-10-16 13:45 951
头像
痛好痛好痛
include()就不是这样,脚本会继续运行
2019-10-16 07:35 5