JAVA基础串讲

知识整体梳理

八种基本类型，byte的范围
基本类型、对象、数组
引用传递和值传递
equals和==的区别
equals()和hashcode()方法
String不可变的理解，String, StringBuilder和StringBuffer
String.intern()方法在jdk1.7之后的变化
基本类型的包装类，内部都是final
装箱与自动拆箱
数组与集合，集合的底层源码，主要是HashMap
计算机内部都是用补码表示的，所有的题目都是转换为补码，然后再转换为源码
字库、字符集和编码，UTF-8项目中，char char1= ‘中’是否正确？
表达式求值在Java内部是用两个栈来实现的，包括运算符栈+操作数栈，要从这个角度理解运算符的优先级，“表达式求值”问题，两个核心关键点：
（1）双栈，一个操作数栈，一个运算符栈；
（2）运算符优先级，栈顶运算符，和，即将入栈的运算符的优先级比较：
运算符优先级：()级别最高，=赋值级别最低，单目优先级【例如++】>双目运算【例如a*b】>三目运算【例如a?b:c，这个即if/else表达式】
面向对象三大特性，重载和重写
错误与异常，RuntimeException和其它Exception

Java中boolean类型占用多少个字节

java的基本数据类型中，boolean只有两种状态，默认值为false.取值范围是{true,false}，理论上占1bit，实际上：

1.单个的boolean 类型变量在编译的时候是使用的int 类型。

boolean a=true; //这个a在JVM中占4个字节即：32位。

2.boolean 类型的数组时，在编译的时候是作为byte array来编译的所以boolean 数组里面的每一个元件占1个字节，

boolean[] b = new boolean[10]; //数组时，每一个boolean在JVM中占1个字节。

描述一下值传递和引用传递的区别

值传递：

方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的是原始值的一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值的修改，不影响实际参数的值。

引用传递：

也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；

在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象。

==和equals区别？String的equals方法是如何重写的？为什么要重写equals方法？为什么要重写hashCode方法?

www.bimowo.com/kstudy-web/clienttopic/view.do?topicId=751

Java 如何重写对象的 equals 方法和 hashCode 方法

String s1 = new String(“abc”); String s2 = “abc”; s1 == s2? 语句1在内存中创建了几个对象？

www.bimowo.com/kstudy-web/clienttopic/view.do?topicId=751

补充：

        String str1 = "str";
        String str2 = "ing";
        String str3 = "str" + "ing";//常量池中的对象
        String str4 = str1 + str2; //在堆上创建的新的对象    
        String str5 = "string";//常量池中的对象
        System.out.println(str3 == str4);//false
        System.out.println(str3 == str5);//true
        System.out.println(str4 == str5);//false
      
        String s1 = new String("计算机");
        String s2 = s1.intern();
        String s3 = "计算机";
        System.out.println(s2);//计算机
        System.out.println(s1 == s2);//false，因为一个是堆内存中的 String 对象一个是常量池中的 String 对象，
        System.out.println(s3 == s2);//true，因为两个都是常量池中的 String 对象

157570189520201

尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。

请着重掌握关于String的以下知识：

String对”+”的重载
- String s = “a” + “b”，编译器会进行常量折叠(因为两个都是编译期常量，编译期可知)，即变成 String s = “ab”
- 对于能够进行优化的(String s = “a” + 变量等)用 StringBuilder 的 append() 方法替代，最后调用 toString() 方法 (底层就是一个 new String())
字符串拼接的几种方式和区别
JDK 6和JDK 7中substring的原理及区别
对new String(“abc”)的理解

String为什么是不可变的？jdk源码中的String如何定义的？为什么这么设计？

https://blog.csdn.net/weixin_42447959/article/details/82598778

请描述一下static关键字和final关键字的用法。

静态变量、静态方法、静态类

1.静态变量：

声明为static的静态变量实质上就是全局变量，当声明一个对象时，并不产生static变量的拷贝，而是该类所有实例变量共用同一个static变量。也就是说这个静态变量只加载一次，只分配一块储存空间。

2.静态方法：

声明为static的静态方法有以下几个特点：

（1）静态方法只能调用静态方法；

（2）静态方法只能访问静态数据；

（3）静态方法不能以任何方式引用this或super；

3.静态类：

通常一个普通类不允许声明为静态，只有一个内部类才可以（main方法就是一个典型），这时这个声明的静态类可以直接作为一个普通类来使用，而不需要实例一个外部类。

final的作用从变量、方法、类三个方面来理解、

final修饰的变量的值不能被修改，是一个常量；

final修饰的方法不能被重写；

final修饰的类不能被继承；

接口和抽象类的区别是什么？

https://www.jianshu.com/p/c4f023d02f0c

重载和重写的区别？

重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。　　

重写：发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

面向对象的三大特性，谈谈你对xx的理解

https://www.cnblogs.com/inspred/p/9526253.html

请写出下面程序的输出结果（考察的是基本类型的转换，及原码反码补码的运算）

   public static void main(String[] args) {
           // TODO Auto-generated method stub
           int a=255;
           System.out.println(Integer.toBinaryString(a));
           System.out.println((byte) a); 
   }

byte的取值范围是多少？怎么计算出来的？

https://blog.csdn.net/qq_23418393/article/details/57421688

       int i = Integer.MAX_VALUE;
       int j = Integer.MAX_VALUE;
       int k = i + j;
       System.out.println("i (" + i + ") + j (" + j + ") = k (" + k + ")");

输出结果：i (2147483647) + j (2147483647) = k (-2)

每个类型都有一定的表示范围，但是，在程序中有些计算会导致超出表示范围，即溢出，溢出的时候并不会抛异常，也没有任何提示。*这里思考一下为什么结果是-2。*

hashMap相关

连环问

hashMap平时都怎么使用？key值可以传null吗?
hashMap工作原理是什么？内部是什么数据结构？
当两个key对象的hashcode一样，put的时候会发生什么
当两个key对象的hashcode一样时，get如何处理？
当hashMap的大小超过了负载因子定义的容量，会发生什么？
hashMap的key对象必须是不可变的吗？如果是可变的，那会出现什么问题？
hashMap是线程安全的吗？会在哪些方法或者功能出现线程安全的问题？线程安全的集合实现有哪些？

*HashMap是必须要掌握的集合！高频常考题！！*

https://blog.csdn.net/suifeng629/article/details/82179996

HashMap 和 Hashtable 的区别

线程是否安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；
效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
初始容量大小和每次扩充容量大小的不同： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小（HashMap 中的 tableSizeFor()方法保证，下面给出了源代码）。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

HashMap 中带有初始容量的构造函数：

	public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
     public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

下面这个方法保证了 HashMap 总是使用2的幂作为哈希表的大小。

    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

HashMap和HashSet区别

如果你看过 HashSet 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 clone()、writeObject()、readObject()是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。

HashMap	HashSet
实现了Map接口	实现Set接口
存储键值对	仅存储对象
调用 `put（）`向map中添加元素	调用 `add（）`方法向Set中添加元素
HashMap使用键（Key）计算Hashcode	HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，

HashMap底层实现

JDK1.8之前

JDK1.8 之前 HashMap 底层是 数组和链表 结合在一起使用也就是 链表散列。HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。

所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法换句话说使用扰动函数之后可以减少碰撞。

JDK 1.8 HashMap 的 hash 方法源码:

JDK 1.8 的 hash方法相比于 JDK 1.7 hash 方法更加简化，但是原理不变。
```
 static final int hash(Object key) {
      int h;
      // key.hashCode()：返回散列值也就是hashcode
      // ^ ：按位异或
      // >>>:无符号右移，忽略符号位，空位都以0补齐
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }
```
对比一下 JDK1.7的 HashMap 的 hash 方法源码.
```
static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
```
相比于 JDK1.8 的 hash 方法，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。

所谓 “拉链法” 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
JDK1.8之后

相比于之前的版本， JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。

TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。

推荐阅读：

《Java 8系列之重新认识HashMap》：https://zhuanlan.zhihu.com/p/21673805

HashMap的长度为什么是2的幂次方

为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ (n - 1) & hash”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。

这个算法应该如何设计呢？

我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。

HashMap多线程操作导致死循环问题

主要原因在于并发下的Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。并发环境下推荐使用 ConcurrentHashMap 。

HashMap的线程安全实现有哪些？

ConcurrentHashMap 和 HashTable的区别主要体现在实现线程安全的方式上不同。

底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。HashTable和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
实现线程安全的方式（重要）： ① 在JDK1.7的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后对 synchronized锁做了很多优化）整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。

两者的对比图：

HashTable:

157533914411357

JDK1.7的ConcurrentHashMap：

157533916856855

JDK1.8的ConcurrentHashMap（TreeBin: 红黑二叉树节点 Node: 链表节点）：

157533918703023

集合其它类

Collection和Collections的区别
LinkedList和ArrayList的区别，Vector
List接口、set接口、map接口
List中如何删除元素，如何遍历排序
hashMap的遍历，为什么使用EntrySet而不使用KeySet

Integer缓存池

Integer x = 3;
Integer y = 3;
System.out.println(x == y);// true
Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a == b);//false
System.out.println(a.equals(b));//true

Integer a = 10; = Integer.valueOf(3) 当创建Integer对象时大小在-128~127之间，对象存放在Integer常量池中

下次再用到会直接从常量池中取出。有点像String常量池。

UTF-8和Unicode的关系

https://www.zhihu.com/question/23374078/answer/65352538

项目为UTF-8环境，char c = ‘中’，是否合法？

因为Java是以unicode字符集作为编码方式的（JVM内部使用的是UTF-16编码）。unicode是一个定长的编码标准，每个字符都是2个字节，也就是1个char类型的空间。

Java在编译时会把utf8的中文字符转换成对应的unicode来进行传输运算（即UTF-16）。

所以是合法的。（即UTF-8是项目环境，实际展示的时候是转换为unicode字符集的UTF-16进行运算的）

Arrays.asList获得的List使用时需要注意什么

asList 得到的只是一个 Arrays 的内部类，一个原来数组的视图 List，因此如果对它进行增删操作会报错

用 ArrayList 的构造器可以将其转变成真正的 ArrayList

Collection和Collections区别？

Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。是list，set等的父接口。

Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

日常开发中，不仅要了解Java中的Collection及其子类的用法，还要了解Collections用法。可以提升很多处理集合类的效率。

你知道fail-fast 和 fail-safe吗?谈谈你的理解。

一：快速失败（fail—fast）
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。
原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
注意：这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。
场景：java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。
二：安全失败（fail—safe）
采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。
原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。
缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。
fail-fast和fail-safe的理解

ArrayList和LinkedList和Vector的区别？

List主要有ArrayList、LinkedList与Vector几种实现。

这三者都实现了List 接口，使用方式也很相似,主要区别在于因为实现方式的不同,所以对不同的操作具有不同的效率。

ArrayList 是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.

LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.

当然,这些对比都是指数据量很大或者操作很频繁的情况下的对比,如果数据和运算量很小,那么对比将失去意义.

Vector 和ArrayList类似,但属于强同步类。如果你的程序本身是线程安全的(thread-safe,没有在多个线程之间共享同一个集合/对象),那么使用ArrayList是更好的选择。

Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%.

而 LinkedList 还实现了 Queue 接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等.

注意: 默认情况下ArrayList的初始容量非常小,所以如果可以预估数据量的话,分配一个较大的初始值属于最佳实践,这样可以减少调整大小的开销。

Set和List区别？Set如何保证元素不重复?

*Set和List区别如下：*

List,Set都是继承自Collection接口。都是用来存储一组相同类型的元素的。

List特点：元素有放入顺序，元素可重复。

有顺序，即先放入的元素排在前面。

Set特点：元素无放入顺序，元素不重复。

无顺序，即先放入的元素不一定排在前面。不可重复，即相同元素在set中只会保留一份。所以，有些场景下，set可以用来去重。不过需要注意的是，set在元素插入时是要有一定的方法来判断元素是否重复的。这个方法很重要，决定了set中可以保存哪些元素。

*Set如何保证元素不重复:*

在Java的Set体系中，根据实现方式不同主要分为两大类。HashSet和TreeSet。

1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值 2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束

在HashSet中，基本的操作都是有HashMap底层实现的，因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候，首先计算元素的hashcode值，然后通过扰动计算和按位与的方式计算出这个元素的存储位置，如果这个位置位空，就将元素添加进去；如果不为空，则用equals方法比较元素是否相等，相等就不添加，否则找一个空位添加。

TreeSet的底层是TreeMap的keySet()，而TreeMap是基于红黑树实现的，红黑树是一种平衡二叉查找树，它能保证任何一个节点的左右子树的高度差不会超过较矮的那棵的一倍。

TreeMap是按key排序的，元素在插入TreeSet时compareTo()方法要被调用，所以TreeSet中的元素要实现Comparable接口。TreeSet作为一种Set，它不允许出现重复元素。TreeSet是用compareTo()来判断重复元素的。

UTF-8与GBK互转，为什么会乱码

https://blog.csdn.net/yangfengjueqi/article/details/79486162

posted @ 2022-07-12 20:30 Faetbwac 阅读(53) 评论(0) 编辑收藏举报

刷新页面返回顶部

Faetbwac

少才多志，一步一行。

JAVA基础串讲

JAVA基础串讲

知识整体梳理

Java中boolean类型占用多少个字节

描述一下值传递和引用传递的区别

==和equals区别？String的equals方法是如何重写的？为什么要重写equals方法？为什么要重写hashCode方法?

String s1 = new String(“abc”); String s2 = “abc”; s1 == s2? 语句1在内存中创建了几个对象？

String为什么是不可变的？jdk源码中的String如何定义的？为什么这么设计？

请描述一下static关键字和final关键字的用法。

接口和抽象类的区别是什么？

重载和重写的区别？

面向对象的三大特性，谈谈你对xx的理解

请写出下面程序的输出结果（考察的是基本类型的转换，及原码反码补码的运算）

byte的取值范围是多少？怎么计算出来的？

hashMap相关

连环问

HashMap 和 Hashtable 的区别

HashMap和HashSet区别

HashMap底层实现

HashMap的长度为什么是2的幂次方

HashMap多线程操作导致死循环问题

HashMap的线程安全实现有哪些？

集合其它类

Integer缓存池

UTF-8和Unicode的关系

项目为UTF-8环境，char c = ‘中’，是否合法？

Arrays.asList获得的List使用时需要注意什么

Collection和Collections区别？

你知道fail-fast 和 fail-safe吗?谈谈你的理解。

ArrayList和LinkedList和Vector的区别？

Set和List区别？Set如何保证元素不重复?

UTF-8与GBK互转，为什么会乱码

公告

Faetbwac

少才多志，一步一行。

JAVA基础串讲

JAVA基础串讲

知识整体梳理

Java中boolean类型占用多少个字节

描述一下值传递和引用传递的区别

==和equals区别？String的equals方法是如何重写的？为什么要重写equals方法？为什么要重写hashCode方法?

String s1 = new String(“abc”); String s2 = “abc”; s1 == s2? 语句1在内存中创建了几个对象？

String为什么是不可变的？jdk源码中的String如何定义的？为什么这么设计？

请描述一下static关键字和final关键字的用法。

接口和抽象类的区别是什么？

重载和重写的区别？

面向对象的三大特性，谈谈你对xx的理解

请写出下面程序的输出结果 （考察的是基本类型的转换，及原码反码补码的运算）

byte的取值范围是多少？怎么计算出来的？

hashMap相关

连环问

HashMap 和 Hashtable 的区别

HashMap和HashSet区别

HashMap底层实现

HashMap的长度为什么是2的幂次方

HashMap多线程操作导致死循环问题

HashMap的线程安全实现有哪些？

集合其它类

Integer缓存池

UTF-8和Unicode的关系

项目为UTF-8环境，char c = ‘中’，是否合法？

Arrays.asList获得的List使用时需要注意什么

Collection和Collections区别？

你知道fail-fast 和 fail-safe吗?谈谈你的理解。

ArrayList和LinkedList和Vector的区别？

Set和List区别？Set如何保证元素不重复?

UTF-8与GBK互转，为什么会乱码

公告

请写出下面程序的输出结果（考察的是基本类型的转换，及原码反码补码的运算）