Java generics interview questions

What are generics in Java? What are the benefits of using generics?

Generics Types are a new feature of Java SE 1.5. The essence of generics is parameterized types, which means that the data type being operated on is specified as a parameter.

Benefits:                                                                                                                                                                                                                                                                                          #2. Backward and backward compatibility3. Generalized code, the code can be reused more

4. High performance, code written in GJ (generic JAVA) can be compiled for java The server and virtual machine bring more type information, which provides conditions for further optimization of Java programs.

How do generics work in Java? What is type erasure? How does it work?

1. Type checking: Provide type checking before generating bytecode

2. Type erasure: All type parameters are replaced with their qualified types, including classes and variables and method (type erasure)3. If type erasure and polymorphism conflict, a bridge method is generated in the subclass to solve the problem

4. If a generic method is called The return type is erased, a cast is inserted when the method is called

Type erasure:

All type parameters are replaced with their qualified types:

For example, T->Object ? extends BaseClass->BaseClass

How it works:

Generics are implemented through type erasure , the compiler erases all type-related information at compile time, so there is no type-related information at runtime. For example, Listf7e83be87db5cd2d9a8a0b8117b38cd4 is represented by only one List at runtime.

The purpose of this is to ensure compatibility with binary class libraries developed in versions prior to Java 5. You cannot access the type parameters at runtime because the compiler has converted the generic type into a primitive type. Depending on your answer to this generics question, you will get some follow-up questions, such as why generics are implemented by type erasure or show you some incorrect generics that will cause compiler errors. code.

Can you pass a Listf7e83be87db5cd2d9a8a0b8117b38cd4 to a method that accepts a Lista87fdacec66f0909fc0757c19f2d2b1d parameter?

For anyone who is not familiar with generics, this Java generics question may seem confusing, because at first glance String is a type of Object, so ListIf you think about it further, you will find that it makes sense for Java to do this, because Lista87fdacec66f0909fc0757c19f2d2b1d can store any type of object including String, Integer, etc., while Listf7e83be87db5cd2d9a8a0b8117b38cd4 can only Used to store String s.

List<Object> objectList;
List<String> stringList;
objectList = stringList; //compilation error incompatible types

How to prevent unchecked type warnings in Java?

If you mix generics and primitive types, such as the following code, javac in java 5 The compiler will generate unchecked type warnings, such as

List<String> rawList = newArrayList()

Note: Hello.java uses unchecked or unsafe operations;This kind of warning can be used @SuppressWarnings(" unchecked") annotation to block.

What is the difference between Lista87fdacec66f0909fc0757c19f2d2b1d and primitive type List in Java?

The main differences between primitive types and parameterized typesa87fdacec66f0909fc0757c19f2d2b1d The difference is that the compiler will not perform type safety checks on primitive types at compile time, but will check types with parameters. By using Object as the type, you can tell the compiler that the method can accept any type of object, such as String or Integer.

The test point of this question lies in the correct understanding of primitive types in generics. The second difference between them is that you can pass any type with parameters to the primitive type List, but you cannot pass Listf7e83be87db5cd2d9a8a0b8117b38cd4 to a method that accepts Lista87fdacec66f0909fc0757c19f2d2b1d, because a compilation error will occur.

Write a generic program to implement LRU caching?

This is equivalent to an exercise for those who like Java programming. To give you a hint, LinkedHashMap can be used to implement a fixed-size LRU cache. When the LRU cache is full, it will move the oldest key-value pair out of the cache.

LinkedHashMap provides a method called removeEldestEntry(), which will be called by put() and putAll() to delete the oldest key-value pair. Of course, if you've already written a running JUnit test, you're free to write your own implementation code.

Can generics be used in Array?

这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。

如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?

编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。最简单的情况下，一个泛型方法可能会像这样：

public V put(K key, V value) {
return cahe.put(key,value);
}

C++模板和java泛型之间有何不同？

java泛型实现根植于“类型消除”这一概念。当源代码被转换为Java虚拟机字节码时，这种技术会消除参数化类型。有了Java泛型，我们可以做的事情也并没有真正改变多少；他只是让代码变得漂亮些。鉴于此，Java泛型有时也被称为“语法糖”。

这和 C++模板截然不同。在 C++中，模板本质上就是一套宏指令集，只是换了个名头，编译器会针对每种类型创建一份模板代码的副本。

由于架构设计上的差异，Java泛型和C++模板有很多不同点：

C++模板可以使用int等基本数据类型。Java则不行，必须转而使用Integer。

在Java中，可以将模板的参数类型限定为某种特定类型。

在C++中，类型参数可以实例化，但java不支持。

在Java中，类型参数不能用于静态方法(?)和变量，因为它们会被不同类型参数指定的实例共享。在C++，这些类时不同的，因此类型参数可以用于静态方法和静态变量。

在Java中，不管类型参数是什么，所有的实例变量都是同一类型。类型参数会在运行时被抹去。在C++中，类型参数不同，实例变量也不同。

The above is the detailed content of Java generics interview questions. For more information, please follow other related articles on the PHP Chinese website!