一次电话Java面试的问题总结（JDK8新特性、哈希冲突、HashMap原理、线程安全、Linux查询命令、Hadoop节点）

面试涉及问题含有：

Java

　　JDK8新特性

　　集合（哈希冲突、HashMap的原理、自动排序的集合TreeSet）

　　多线程安全问题

　　String和StringBuffer

JVM

　　原理、运行流程、内部结构

Linux

　　查询含有某字符串内容的命令grep

　　查询进程、GC状态、杀死进程

Hadoop五种节点介绍

——————————————————————————————————–

JAVA：

1、JDK8新特性：

函数接口Functional Interface

　　　　只包含一个抽象方法的接口，也成为SAM（Single Abstract Method单方法接口）类型的接口。

　　　　　例如Runnable接口的run（）方法。JDK8新增了许多函数接口，其中一个重要的原因就是支持Lambda表达式。

Lambda（拉姆达）表达式（闭包） − Lambda允许把函数作为一个方法的参数，函数作为参数传递进方法中。

　　　　　　一种匿名方法，可以将函数接口中的函数作为方法参数处理。在Java中Lambda表达式返回值是一个对象，这个对象必须是单方法接口。

　　　　　　lambda表达式的重要特征:

　　　　　　　　可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

　　　　　　　　可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

　　　　　　　　可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

　　　　　　　　可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

　　　　　　Lambda的设计可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

Arrays.asList( "a", "b", "d" ).forEach( e -> {
    System.out.print( e );
    System.out.print( e );
} );


String separator = ",";
Arrays.asList( "a", "b", "d" ).forEach( 
    ( String e ) -> System.out.print( e + separator ) );

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
等同于
Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
    int result = e1.compareTo( e2 );
    return result;
} );

方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

　　　　Lambda表达式的一种特殊形式。当一个lambda表达式body中仅仅是调用某个方法，此时使用方法引用替代Lambda表达式。从形式上直接引用这个方法，比在lambda表达式body中引用在形式上更简洁。

　　　　　　方法引用通过方法的名字来指向一个方法。

　　　　　　方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

　　　　　　方法引用使用一对冒号 :: 。

Java 8使用两个新概念扩展了接口的含义：默认方法和静态方法。默认方法使得接口有点类似traits，不过要实现的目标不一样。默认方法使得开发者可以在 不破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。

默认方法和抽象方法之间的区别在于抽象方法需要实现，而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写，例子代码如下：

private interface Defaulable {
    default String notRequired() { 
        return "Default implementation"; 
    }        
}
 
private static class DefaultableImpl implements Defaulable {
}
 
private static class OverridableImpl implements Defaulable {
    @Override
    public String notRequired() {
        return "Overridden implementation";
    }
}
Defaulable接口使用关键字default定义了一个默认方法notRequired()。DefaultableImpl类实现了这个接口，同时默认继承了这个接口中的默认方法；OverridableImpl类也实现了这个接口，但覆写了该接口的默认方法，并提供了一个不同的实现。

Java 8带来的另一个有趣的特性是在接口中可以定义静态方法，例子代码如下：

private interface DefaulableFactory {
    // Interfaces now allow static methods
    static Defaulable create( Supplier< Defaulable > supplier ) {
        return supplier.get();
    }
}
下面的代码片段整合了默认方法和静态方法的使用场景：
public static void main( String[] args ) {
    Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
    System.out.println( defaulable.notRequired() );
 
    defaulable = DefaulableFactory.create( OverridableImpl::new );
    System.out.println( defaulable.notRequired() );
}
输出结果如下：
Default implementation
Overridden implementation

默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。

　　　　主要目的是为了升级标准JDK接口，另外也是为了能在JDK8中顺畅的使用Lamb的表达式。

private interface DefaulableFactory {
    // Interfaces now allow static methods
    static Defaulable create( Supplier< Defaulable > supplier ) {
        return supplier.get();
    }
}

新工具 − 新的编译工具，如：Nashorn引擎 jjs、类依赖分析器jdeps。
java批量数据操作bulk dataoperations

　　　　目的是应用lambda函数来实现包含并行操作在内的多种数据处理功能，而支持并行数据操作是其关键内容。这个并行操作实在java7的java.util.concurrency的Fork/Join机制上实现的。

Stream API −新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。
Date Time API − 加强对日期与时间的处理。
Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。
重复注解：

自从Java 5中引入注解以来，这个特性开始变得非常流行，并在各个框架和项目中被广泛使用。不过，注解有一个很大的限制是：在同一个地方不能多次使用同一个注解。Java 8打破了这个限制，引入了重复注解的概念，允许在同一个地方多次使用同一个注解。

在Java 8中使用@Repeatable注解定义重复注解，实际上，这并不是语言层面的改进，而是编译器做的一个trick，底层的技术仍然相同。可以利用下面的代码说明：

package com.javacodegeeks.java8.repeatable.annotations;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
public class RepeatingAnnotations {
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters {
        Filter[] value();
    }
 
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter {
        String value();
    };
 
    @Filter( "filter1" )
    @Filter( "filter2" )
    public interface Filterable {        
    }
 
    public static void main(String[] args) {
        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() );
        }
    }
}

正如我们所见，这里的Filter类使用@Repeatable(Filters.class)注解修饰，而Filters是存放Filter注解的容器，编译器尽量对开发者屏蔽这些细节。这样，Filterable接口可以用两个Filter注解注释（这里并没有提到任何关于Filters的信息）。

另外，反射API提供了一个新的方法：getAnnotationsByType()，可以返回某个类型的重复注解，例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例，输出到控制台的内容如下所示： filter1 filter2

2、集合：

哈希冲突：

（见博客：https://www.cnblogs.com/wuchaodzxx/p/7396599.html）

如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。

哈希函数的设计至关重要，好的哈希函数会尽可能地保证计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。

（1）开放定址法

这种方法也称再散列法，其基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式：

Hi=（H（key）+d_i）% m i=1，2，…，n

其中H（key）为哈希函数，m 为表长，d_i称为增量序列。增量序列的取值方式不同，相应的再散列方式也不同。主要有以下三种：

线性探测再散列

d_ii=1，2，3，…，m-1

这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表。

二次探测再散列

d_i=1²，-1²，2²，-2²，…，k²，-k² ( k<=m/2 )

这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活。

伪随机探测再散列

d_i=伪随机数序列。

（2）再哈希法

这种方法是同时构造多个不同的哈希函数：

H_i=RH₁（key） i=1，2，…，k

当哈希地址H_i=RH₁（key）发生冲突时，再计算H_i=RH₂（key）……，直到冲突不再产生。这种方法不易产生聚集，但增加了计算时间。

（3）链地址法

这种方法的基本思想是将所有哈希地址为i的元素构成一个称为同义词链的单链表，并将单链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况。

（4）建立公共溢出区

这种方法的基本思想是：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表。

HashMap的底层原理：

见博客：https://www.cnblogs.com/chengxiao/p/6059914.html

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。

//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

Entry是HashMap中的一个静态内部类。代码如下：

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

自动排序的集合：

TreeSet(树集)是一个有序集合，可以按照任何顺序将元素插入该集合，当对该集合进行迭代时，各个值将自动以排序后的顺序出现。TreeSet中的元素按照升序排列，缺省是按照自然顺序进行排序，意味着TreeSet中的元素要实现Comparable接口，或者有一个自定义的比较器Comparator。

TreeSet底层使用的是TreeMap，TreeMap的底层实现是红黑树(详细见http://www.cnblogs.com/xujian2014/p/4645943.html)。

 public TreeSet()
 {
        this(new TreeMap<E,Object>());
 }

使用示例：

public class Test
{
    public static void main(String[] args)
    {
        TreeSet<String> treeSet=new TreeSet<>();
        treeSet.add("Bili");
        treeSet.add("Amy");
        treeSet.add("cDy");
        for (String string : treeSet)
        {
            System.out.println(string);
        }
 }

　　由于String类实现了Comparable接口，它的compareTo方法是按照字典顺序来对字符串进行排序，所以结果如下：

注意：

　　1、TreeSet的排列顺序必须是全局顺序，也就是说任何两个元素都是必须可比的，同时只有当他们比较相同时才返回0。

　　2、如果树集包含了n个元素，那么平均需要进行log₂n次比较，才能找到新元素的正确位置。

3、线程：

多线程安全运行：

在多个线程并发执行访问同一个数据时，如果不采取相应的措施，将会是非常危险的。为避免这种情况发生，我们要将多个线程对同一数据的访问同步，确保线程安全。

所谓同步(synchronization)就是指一个线程访问数据时，其它线程不得对同一个数据进行访问，即同一时刻只能有一个线程访问该数据，当这一线程访问结束时其它线程才能对这它进行访问。同步最常见的方式就是使用锁(Lock)，也称为线程锁。锁是一种非强制机制，每一个线程在访问数据或资源之前，首先试图获取(Acquire)锁，并在访问结束之后释放(Release)锁。在锁被占用时试图获取锁，线程会进入等待状态，直到锁被释放再次变为可用。

Java里面一般用以下几种机制保证线程安全：

1.互斥同步锁（悲观锁）

1）Synchorized

2）ReentrantLock

互斥同步锁也叫做阻塞同步锁，特征是会对没有获取锁的线程进行阻塞。

要理解互斥同步锁，首选要明白什么是互斥什么是同步。简单的说互斥就是非你即我，同步就是顺序访问。互斥同步锁就是以互斥的手段达到顺序访问的目的。操作系统提供了很多互斥机制比如信号量，互斥量，临界区资源等来控制在某一个时刻只能有一个或者一组线程访问同一个资源。

Java里面的互斥同步锁就是Synchorized和ReentrantLock，前者是由语言级别实现的互斥同步锁，理解和写法简单但是机制笨拙，在JDK6之后性能优化大幅提升，即使在竞争激烈的情况下也能保持一个和ReentrantLock相差不多的性能，所以JDK6之后的程序选择不应该再因为性能问题而放弃synchorized。ReentrantLock是API层面的互斥同步锁，需要程序自己打开并在finally中关闭锁，和synchorized相比更加的灵活，体现在三个方面：等待可中断，公平锁以及绑定多个条件。但是如果程序猿对ReentrantLock理解不够深刻，或者忘记释放lock，那么不仅不会提升性能反而会带来额外的问题。另外synchorized是JVM实现的，可以通过监控工具来监控锁的状态，遇到异常JVM会自动释放掉锁。而ReentrantLock必须由程序主动的释放锁。

互斥同步锁都是可重入锁，好处是可以保证不会死锁。但是因为涉及到核心态和用户态的切换，因此比较消耗性能。JVM开发团队在JDK5-JDK6升级过程中采用了很多锁优化机制来优化同步无竞争情况下锁的性能。比如：自旋锁和适应性自旋锁，轻量级锁，偏向锁，锁粗化和锁消除。

2.非阻塞同步锁

1) 原子类（CAS）

非阻塞同步锁也叫乐观锁，相比悲观锁来说，它会先进行资源在工作内存中的更新，然后根据与主存中旧值的对比来确定在此期间是否有其他线程对共享资源进行了更新，如果旧值与期望值相同，就认为没有更新，可以把新值写回内存，否则就一直重试直到成功。它的实现方式依赖于处理器的机器指令：CAS（Compare And Swap）

JUC中提供了几个Automic类以及每个类上的原子操作就是乐观锁机制。

不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。

非阻塞锁是不可重入的，否则会造成死锁。

3.无同步方案

1）可重入代码

在执行的任何时刻都可以中断-重入执行而不会产生冲突。特点就是不会依赖堆上的共享资源

2）ThreadLocal/Volaitile

线程本地的变量，每个线程获取一份共享变量的拷贝，单独进行处理。

3) 线程本地存储

如果一个共享资源一定要被多线程共享，可以尽量让一个线程完成所有的处理操作，比如生产者消费者模式中，一般会让一个消费者完成对队列上资源的消费。典型的应用是基于请求-应答模式的web服务器的设计

4、String和StringBuffer

（1）String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是final类,即不能被继承

String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。
   String a = “a”; //假设a指向地址0x0001
   a = “b”;//重新赋值后a指向地址0x0002，但0x0001地址中保存的”a”依旧存在，但已经不再是a所指向的,a 已经指向了其它地址。
   因此String的操作都是改变赋值地址而不是改变值操作。

（2）StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象。它只能通过构造函数来建立对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中赋值的时候可以通过它的append方法.

StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。
   StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区
   StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区
   StringBuffer buf=new StringBuffer(“this is a test”)//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区。

本文链接：https://www.cnblogs.com/1996swg/p/9600537.html

一次电话Java面试的问题总结（JDK8新特性、哈希冲突、HashMap原理、线程安全、Linux查询命令、Hadoop节点）

（1）开放定址法

线性探测再散列

二次探测再散列

伪随机探测再散列

（3）链地址法

（4）建立公共溢出区

使用示例：

一次电话Java面试的问题总结（JDK8新特性、哈希冲突、HashMap原理、线程安全、Linux查询命令、Hadoop节点）的更多相关文章

随机推荐

热门专题

目录导航