java 不规则图形_这样不规则的Java后端面试题你见过吗？

1.JAVA中的几种基本数据类型是什么,各自占用多少字节.

先了解2个单词：

1、bit --位：位是计算机中存储数据的最小单位，指二进制数中的一个位数，其值为“0”或“1”。

2、byte --字节：字节是计算机存储容量的基本单位，一个字节由8位二进制数组成。在计算机内部，一个字节可以表示一个数据，也可以表示一个英文字母，两个字节可以表示一个汉字。1B＝8bit

1Byte=8bit

1KB=1024Byte(字节)=8*1024bit

1MB=1024KB

1GB=1024MB

1TB=1024GB

3、基本数据类型注意事项：未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。

如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”(不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆)，表示为long型。

带有“F”(不区分大小写)后缀的整数和浮点数都是float类型的；带有“D”(不区分大小写)后缀的整数和浮点数都是double类型的。

编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。

int型值可以赋给所有数值类型的变量；

long型值可以赋给long、float、double类型的变量；

float型值可以赋给float、double类型的变量；

double型值只能赋给double类型变量

4、基本数据类型取值范围：

boolean : This data type represents one bit of information, but its "size" isn't something that's precisely defined.(ref)这种数据类型代表一个比特的信息，但它的“大小”没有明确的定义。

boolean类型没有给出精确的定义，《Java虚拟机规范》给出了4个字节，和boolean数组1个字节的定义，具体还要看虚拟机实现是否按照规范来，所以1个字节、4个字节都是有可能的。

2.String 类能被继承吗?为什么?

String 被声明为 final，因此它不可被继承。

内部使用 char 数组存储数据，该数组被声明为 final，这意味value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。public final class String implements java.io.Serializable, Comparable, CharSequence {

/** The value is used for character storage. */

private final char value[];

不可变的好处：

1. 可以缓存 hash 值

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

2. String Pool 的需要

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

3. 安全性

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

4. 线程安全

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

Program Creek : Why String is immutable in Java?

平常我们定义的String str=”a”;其实和String str=new String(“a”)还是有差异的。

前者默认调用的是String.valueOf来返回String实例对象，至于调用哪个则取决于你的赋值，比如String num=1,调用的是public static String valueOf(int i) {

return Integer.toString(i);

}

后者则是调用如下部分：public String(String original) {

this.value = original.value;

this.hash = original.hash;

}

最后我们的变量都存储在一个char数组中。

3.String ,StringBuffer,StringBuilder的区别?

1. 可变性String 不可变

StringBuffer 和 StringBuilder 可变

2. 线程安全String 不可变，因此是线程安全的

StringBuilder 不是线程安全的

StringBuffer 是线程安全的，内部使用 synchronized 进行同步StackOverflow : String, StringBuffer, and StringBuilder

4.ArrayList和LinkedList有什么区别?

ArrayList和Vector使用了基于动态数组的实现，可以认为ArrayList或者Vector封装了对内部数组的操作，比如向数组中添加，删除，插入新的元素或者数据的扩展和重定向。

LinkedList使用了循环双向链表数据结构。与基于数组的ArrayList 相比,这是两种截然不同的实现技术，这也决定了它们将适用于完全不同的工作场景。

LinkedList链表由一系列表项连接而成。 一个表项总是包含3个部分:元素内容，前驱表和后驱表，如图所示:

在下图展示了一个包含3个元素的LinkedList的各个表项间的连接关系。在JDK的实现中，无论LikedList是否为空,链表内部都有一个header表项，它既表示链表的开始，也表示链表的结尾。表项header的后驱表项便是链表中第一个元素,表项header的前驱表项便是链表中最后一个元素。

ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下：对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

LinkedList不支持高效的随机元素访问。

ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

5.讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当new的时候，他们的执行顺序。父类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行

子类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行

父类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行

父类构造方法

子类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行

子类构造方法

结论：对象初始化的顺序，先静态方法，再构造方法，每个又是先基类后子类。

6.用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么，他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。

HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap

7.JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何设计。

自己思考？？？？

8.有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。

reeMap和LinkedHashMap是有序的(TreeMap默认升序，LinkedHashMap则记录了插入顺序)。

9.抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。

1. 抽象类

抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。

抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。public abstract class AbstractClassExample {

protected int x;

private int y;

public abstract void func1();

public void func2() {

System.out.println("func2");

}

}

public class AbstractExtendClassExample extends AbstractClassExample {

@Override

public void func1() {

System.out.println("func1");

}

}

// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated

AbstractClassExample ac2 = new AbstractExtendClassExample();

ac2.func1();

2. 接口

接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。

从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。

接口的成员(字段 + 方法)默认都是 public 的，并且不允许定义为 private 或者 protected。

接口的字段默认都是 static 和 final 的。public interface InterfaceExample {

void func1();

default void func2(){

System.out.println("func2");

}

int x = 123;

// int y; // Variable 'y' might not have been initialized

public int z = 0; // Modifier 'public' is redundant for interface fields

// private int k = 0; // Modifier 'private' not allowed here

// protected int l = 0; // Modifier 'protected' not allowed here

// private void fun3(); // Modifier 'private' not allowed here

}

public class InterfaceImplementExample implements InterfaceExample {

@Override

public void func1() {

System.out.println("func1");

}

}

// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated

InterfaceExample ie2 = new InterfaceImplementExample();

ie2.func1();

System.out.println(InterfaceExample.x);

3. 比较从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。

从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。

接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。

接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。

4. 使用选择

使用接口：需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；

需要使用多重继承。

使用抽象类：

需要在几个相关的类中共享代码。

需要能控制继承来的成员的访问权限，而不是都为 public。

需要继承非静态和非常量字段。

在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。

深入理解 abstract class 和 interface

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

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

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

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

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

抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。

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

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

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

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