huansky
huansky

java 泛型基础问题汇总

 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句，例如。习惯上称为“有界类型”。 

5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName("java.lang.String");

泛型擦除以及相关的概念

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

 

类型擦除引起的问题及解决方法

 1、先检查，在编译，以及检查编译的对象和引用传递的问题

2、自动类型转换

3、类型擦除与多态的冲突和解决方法

4、泛型类型变量不能是基本数据类型

5、运行时类型查询

6、异常中使用泛型的问题

7、数组（这个不属于类型擦除引起的问题）

9、类型擦除后的冲突

10、泛型在静态方法和静态类中的问题

 

1. 问：Java 的泛型是什么？有什么好处和优点？JDK 不同版本的泛型有什么区别？ 

答：泛型是 Java SE 1.5 的新特性，泛型的本质是参数化类型，这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。在 Java SE 1.5 之前没有泛型的情况的下只能通过对类型 Object 的引用来实现参数的任意化，其带来的缺点是要做显式强制类型转换，而这种强制转换编译期是不做检查的，容易把问题留到运行时，所以 泛型的好处是在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率，避免在运行时出现 ClassCastException。

JDK 1.5 引入了泛型来允许强类型在编译时进行类型检查；JDK 1.7 泛型实例化类型具备了自动推断能力，譬如 List list = new ArrayList(); 可以写成 List llist = new ArrayList<>(); 了，JDK 具备自动推断能力。下面几种写法可以说是不同版本的兼容性了：

//JDK 1.5 推荐使用的写法
List list = new ArrayList();
//JDK 1.7 推荐使用的写法
List llist = new ArrayList<>();

//可以使用，但不推荐，是为了兼容老版本，IDE 会提示警告，可以通过注解屏蔽警告

List list = new ArrayList();

//可以使用，但不推荐，是为了兼容老版本，IDE 会提示警告，可以通过注解屏蔽警告

List list = new ArrayList(); 

 

2. 问：Java 泛型是如何工作的？什么是类型擦除？

答：泛型是通过类型擦除来实现的，编译器在编译时擦除了所有泛型类型相关的信息，所以在运行时不存在任何泛型类型相关的信息，譬如 List 在运行时仅用一个 List 来表示，这样做的目的是为了和 Java 1.5 之前版本进行兼容。泛型擦除具体来说就是在编译成字节码时首先进行类型检查，接着进行类型擦除（即所有类型参数都用他们的限定类型替换，包括类、变量和方法），接着如果类型擦除和多态性发生冲突时就在子类中生成桥方法解决，接着如果调用泛型方法的返回类型被擦除则在调用该方法时插入强制类型转换。

 

3. 问：Java 泛型类、泛型接口、泛型方法有什么区别？

 答：泛型类是在实例化类的对象时才能确定的类型，其定义譬如 class Test {}，在实例化该类时必须指明泛型 T 的具体类型。

泛型接口与泛型类一样，其定义譬如 interface Generator { E dunc(E e); }。

泛型方法所在的类可以是泛型类也可以是非泛型类，是否拥有泛型方法与所在的类无关，所以在我们应用中应该尽可能使用泛型方法，不要放大作用空间，尤其是在 static 方法时 static 方法无法访问泛型类的类型参数，所以更应该使用泛型的 static 方法（声明泛型一定要写在 static 后返回值类型前）。泛型方法的定义譬如 void func(T val) {}。 

 

4. 问：Java 如何优雅的实现元组？

 答：元组其实是关系数据库中的一个学术名词，一条记录就是一个元组，一个表就是一个关系，纪录组成表，元组生成关系，这就是关系数据库的核心理念。很多语言天生支持元组，譬如 Python 等，在语法本身支持元组的语言中元组是用括号表示的，如 (int, bool, string) 就是一个三元组类型，不过在 Java、C 等语言中就比较坑爹，语言语法本身不具备这个特性，所以在 Java 中我们如果想优雅实现元组就可以借助泛型类实现，如下是一个三元组类型的实现：

Triplet {

   private A a;
   private B a;
   private C a;
   public Triplet(A a, B b, C c) {
       this.a = a;
       this.b = b;
       this.c = c;
   }
}

 

5. 问：下面程序块的运行结果是什么，为什么？

Class c1 = new ArrayList().getClass();

Class c2 = new ArrayList().getClass();

System.out.println(c1 == c2);

答：上面代码段结果为 true，解释如下。

因为 load 的是同一个 class 文件，存在 ArrayList.class 文件但是不存在 ArrayList.class 文件，即便是通过 class.getTypeParameters() 方法获取类型信息也只能获取到 [T] 一样的泛型参数占位符。泛型是通过擦除来实现的，所以编译后任何具体的泛型类型都被擦除了（替换为非泛型上边界，如果没有指定边界则为 Object 类型），泛型类型只有在静态类型检查期间才出现，上面都被擦除成了 ArrayList 类型，所以运行时加载的是同一个 class 文件。

 

6. 问：为什么 Java 泛型要通过擦除来实现？擦除有什么坏处或者说代价？

 答：可以说 Java 泛型的存在就是一个不得已的妥协，正因为这种妥协导致了 Java 泛型的混乱，甚至说是 JDK 泛型设计的失败。Java 之所以要通过擦除来实现泛型机制其实是为了兼容性考虑，只有这样才能让非泛化代码到泛化代码的转变过程建立在不破坏现有类库的实现上。正是因为这种兼容也带来了一些代价，譬如泛型不能显式地引用运行时类型的操作之中（如向上向下转型、instanceof 操作等），因为所有关于参数的信息都丢失了，所以任何时候使用泛型都要提醒自己背后的真实擦除类型到底是什么；此外擦除和兼容性导致了使用泛型并不是强制的（如 List list = new ArrayList(); 等写法）；其次擦除会导致我们在编写代码时十分谨慎（如不想被擦除为 Object 类型时不要忘了添加上边界操作等）。

 

7. 问：下面三个 funcX 方法有问题吗，为什么？

class Product {
   private void func1(Object arg) {
       if (arg instanceof T) {}
   }
   private void func2() {
       T var = new T();
   }
   private void func3() {
       T[] vars = new T[3];
   }

}

答：func1、func2、func3 三个方法均无法编译通过。

因为泛型擦除丢失了在泛型代码中执行某些操作的能力，任何在运行时需要知道确切类型信息的操作都将无法工作。

 

 8. 问：下面代码段有问题吗，运行效果是什么，为什么？

ArrayList arrayList = new ArrayList();

arrayList.add(1);

arrayList.getClass().getMethod("add", Object.class).invoke(arrayList, "abc");

for (int i=0; i) {

　　System.out.println(arrayList.get(i));

}

答：由于在程序中定义的 ArrayList 泛型类型实例化为 Integer 的对象，如果直接调用 add 方法则只能存储整形数据，不过当我们利用反射调用 add 方法时就可以存储字符串，因为 Integer 泛型实例在编译之后被擦除了，只保留了原始类型 Object，所以自然可以插入。

 

9. 问：请比较深入的谈谈你对 Java 泛型擦除的理解和带来的问题认识？

答：Java 的泛型是伪泛型，因为在编译期间所有的泛型信息都会被擦除掉，譬如 List 在运行时仅用一个 List 来表示（所以我们可以通过反射 add 方法来向 Integer 的泛型列表添加字符串，因为编译后都成了 Object），这样做的目的是为了和 Java 1.5 之前版本进行兼容。泛型擦除具体来说就是在编译成字节码时首先进行类型检查，接着进行类型擦除（即所有类型参数都用他们的限定类型替换，包括类、变量和方法，如果类型变量有限定则原始类型就用第一个边界的类型来替换，譬如 class Prd {} 的原始类型就是 Comparable），接着如果类型擦除和多态性发生冲突时就在子类中生成桥方法解决，接着如果调用泛型方法的返回类型被擦除则在调用该方法时插入强制类型转换。

先检查再擦除的类型检查是针对引用的，用引用调用泛型方法就会对这个引用调用的方法进行类型检测而无关它真正引用的对象。可以说这是为了兼容带来的问题，如下：

ArrayList arrayList1 = new ArrayList();  

arrayList1.add("123");    //编译通过
arrayList1.add(123);    //编译错误
String str1 = arrayList1.get(0);    //返回类型是 String
ArrayList arrayList2 = new ArrayList();
arrayList2.add("123");    //编译通过
arrayList2.add(123);    //编译错误
String object2 = arrayList2.get(0);    //返回类型是 String

ArrayList arrayList3 = new ArrayList();

arrayList3.add("123");    //编译通过

arrayList3.add(123);    //编译通过  

Object object3 = arrayList3.get(0);    //返回类型是 Object

所以说擦除前的类型检查是针对引用的，用这个引用调用泛型方法就会对这个引用调用的方法进行类型检测而无关它真正引用的对象。

先检查再擦除带来的另一个问题就是泛型中参数化类型无法支持继承关系，因为泛型的设计初衷就是为了解决 Object 类型转换的弊端而存在，如果泛型中参数化类型支持继承操作就违背了设计的初衷而继续回到原始的 Object 类型转换弊端。也同样可以说这是为了兼容带来的问题，如下：

ArrayList arrayList1 = new ArrayList();  

arrayList1.add(new Object());  

arrayList1.add(new Object());  
ArrayList arrayList2 = arrayList1;    //编译错误

ArrayList arrayList3 = new ArrayList();  
arrayList3.add("abc");  

arrayList3.add(new String());  

ArrayList arrayList4 = arrayList3;    //编译错误

ArrayList arrayList5 = new ArrayList();    //编译错误

ArrayList arrayList6 = new ArrayList();    //编译错误 
  
 
之所以这样我们可以从反面来论证，假设编译不报错则当通过 arrayList2 调用 get() 方法取值时返回的是 String 类型的对象（因为类型检测是根据引用来决定的），而实际上存放的是 Object 类型的对象，这样 get 出来就会 ClassCastException 了，所以这违背了泛型的初衷。对于 arrayList4 同样假设编译不报错，当调用 arrayList4 的 get() 方法取出来的 String 变成了 Object 虽然不会出现 ClassCastException，但是依然没有意义啊，泛型出现的原因就是为了解决类型转换的问题，其次如果我们通过 arrayList4 的 add() 方法继续添加对象则可以添加任意类型对象实例，这就会导致我们 get() 时更加懵逼不知道加的是什么类型了，所以怎么说都是个死循环。
 
 
擦除带来的另一个问题就是泛型与多态的冲突，其通过子类中生成桥方法解决了多态冲突问题，这个问题的验证也很简单，可以通过下面的例子说明：
 
 
 
  
class Creater {  

   private T value;
   public T getValue() {  
       return value;  
   }
   public void setValue(T value) {  
       this.value = value;  
   }  
}
class StringCreater extends Creater {  
   @Override  
   public void setValue(String value) {  
       super.setValue(value);  
   }
   @Override  
   public String getValue() {  
       return super.getValue();  
   }  

}
StringCreater stringCreater =new StringCreater();  
stringCreater.setValue("abc");                  
stringCreater.setValue(new Object());    //编译错误
 
 
 
 
上面代码段的运行情况很诧异吧，按理来说 Creater 类被编译擦除后 setValue 方法的参数应该是 Object 类型了，子类 StringCreater 的 setValue 方法参数类型为 String，看起来父子类的这组方法应该是重载关系，所以调用子类的 setValue 方法添加字符串和 Object 类型参数应该都是合法才对，然而从编译来看子类根本没有继承自父类参数为 Object 类型的 setValue 方法，所以说子类的 setValue 方法是对父类的重写而不是重载（从子类添加 @Override 注解没报错也能说明是重写关系）。关于出现上面现象的原理其实我们通过 javap 看下两个类编译后的本质即可：
 
 
 
  
class StringCreater extends Creater {

 ......

 public void setValue(java.lang.String);    //重写的setValue方法

   Code:
      0: aload_0
      1: aload_1
      2: invokespecial #2    // Method Creater.setValue:(Ljava/lang/Object;)V
      5: return


 public java.lang.String getValue();    //重写的getValue方法  

   Code:
      0: aload_0
      1: invokespecial #3    // Method Creater.getValue:()Ljava/lang/Object;
      4: checkcast     #4    // class java/lang/String
      7: areturn

 public void setValue(java.lang.Object);    //编译器生成的桥方法，调用我们重写的setValue方法
   Code:
      0: aload_0
      1: aload_1
      2: checkcast     #4    // class java/lang/String
      5: invokevirtual #5    // Method setValue:(Ljava/lang/String;)V
      8: return

 public java.lang.Object getValue();    //编译器生成的桥方法，调用我们重写的getValue方法
   Code:
      0: aload_0
      1: invokevirtual #6    // Method getValue:()Ljava/lang/String;
      4: areturn
}
 
 
 
 
通过编译后的字节码我们可以看到 Creater 泛型类在编译后类型被擦除为 Object，而我们子类的本意是进行重写实现多态，可类型擦除后子类就和多态产生了冲突，所以编译后的字节码里就出现了桥方法来实现多态。可以看到桥方法的参数类型都是 Object，也就是说子类中真正覆盖父类方法的是桥方法，而子类 String 参数 setValue、getValue 方法上的 @Oveerride 注解只是个假象，桥方法的内部实现是直接调用了我们自己重写的那两个方法；不过上面的 setValue 方法是为了解决类型擦除与多态之间的冲突生成的桥方法，而 getValue 是一种协变，之所以子类中 Object getValue() 和 String getValue() 方法可以同时存在是虚拟机内部的一种区分（我们自己写的代码是不允许这样的），因为虚拟机内部是通过参数类型和返回类型来确定一个方法签名的，所以编译器为了实现泛型的多态允许自己做这个看起来不合法的实现，实质还是交给了虚拟机去区别。
 
 
先检查再擦除带来的另一个问题就是泛型读取时会进行自动类型转换问题，所以如果调用泛型方法的返回类型被擦除则在调用该方法时插入强制类型转换。
 
 
关于这个可以通过 javap 去查看使用 List 的 add、get 方法后的字节码指令，你会发现 checkcast 指令不是在 get 方法里面强转的（虽然 get 方法里面返回值在代码里面是被转换成了 T，实际编译擦除了），而是在调用处强转的。
 
 
擦除带来的另一个问题是泛型类型参数不能是基本类型，比如 ArrayList 是不合法的，只有 ArrayList 是合法的，因为当类型擦除后 ArrayList 的原始类型是 Object，而 Object 是引用类型而不是基本类型。
 
 
擦除带来的另一个问题是无法进行具体泛型参数类型的运行时类型检查，譬如 arrayList instanceof ArrayList 是非法的，Java 对于泛型运行时检查的支持仅限于 arrayList instanceof ArrayList 方式。 
 
 
擦除带来的另一个问题是我们不能抛出也不能捕获泛型类的对象，因为异常是在运行时捕获和抛出的，而在编译时泛型信息会被擦除掉，擦除后两个 catch 会变成一样的东西。也不能在 catch 子句中使用泛型变量，因为泛型信息在编译时已经替换为原始类型（譬如 catch(T) 在限定符情况下会变为原始类型 Throwable），如果可以在 catch 子句中使用则违背了异常的捕获优先级顺序。
 
 
这一个题目能说明白和全面泛型基本就掌握百分之九十了。
 
 
 
 
 
10. 问：为什么 Java 的泛型数组不能采用具体的泛型类型进行初始化？
 
 
答：这个问题可以通过一个例子来说明。
 
 
 
  
List[] lsa = new List[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List li = new ArrayList();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.
 
 
 
 
由于 JVM 泛型的擦除机制，所以上面代码可以给 oa[1] 赋值为 ArrayList 也不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现 ClassCastException，如果可以进行泛型数组的声明则上面说的这种情况在编译期不会出现任何警告和错误，只有在运行时才会出错，但是泛型的出现就是为了消灭 ClassCastException，所以如果 Java 支持泛型数组初始化操作就是搬起石头砸自己的脚。而对于下面的代码来说是成立的：
 
 
 
  
List[] lsa = new List[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List li = new ArrayList();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK
 
 
 
 
所以说采用通配符的方式初始化泛型数组是允许的，因为对于通配符的方式最后取出数据是要做显式类型转换的，符合预期逻辑。综述就是说 Java 的泛型数组初始化时数组类型不能是具体的泛型类型，只能是通配符的形式，因为具体类型会导致可存入任意类型对象，在取出时会发生类型转换异常，会与泛型的设计思想冲突，而通配符形式本来就需要自己强转，符合预期。 
 
 
关于这道题的答案其 Oracle 官方文档给出了原因：https://docs.oracle.com/javase/tutorial/extra/generics/fineprint.html
 
 
 
 
 
11. 问：下面语句哪些是有问题，哪些没有问题？
 
 
 
  
List[] list1 = new ArrayList[10];    //编译错误，非法创建
List[] list2 = new ArrayList[10];    //编译错误，需要强转类型
List[] list3 = (List[]) new ArrayList[10];    //OK，但是会有警告

List[] list4 = new ArrayList[10];    //编译错误，非法创建
List[] list5 = new ArrayList[10];    //OK
List[] list6 = new ArrayList[10];    //OK，但是会有警告
 
 
 
 
答：上面每个语句的问题注释部分已经阐明了，因为在 Java 中是不能创建一个确切的泛型类型的数组的，除非是采用通配符的方式且要做显式类型转换才可以。 
 
 
 
 
 
12. 问：如何正确的初始化泛型数组实例？
 
 
答：这个无论我们通过 new ArrayList[10] 的形式还是通过泛型通配符的形式初始化泛型数组实例都是存在警告的，也就是说仅仅语法合格，运行时潜在的风险需要我们自己来承担，因此那些方式初始化泛型数组都不是最优雅的方式，我们在使用到泛型数组的场景下应该尽量使用列表集合替换，此外也可以通过使用 java.lang.reflect.Array.newInstance(Class componentType, int length) 方法来创建一个具有指定类型和维度的数组，如下：
 
 
 
  
public class ArrayWithTypeToken {  

   private T[] array;
   public ArrayWithTypeToken(Class type, int size) {  
      array = (T[]) Array.newInstance(type, size);  
   }
   public void put(int index, T item) {  
       array[index] = item;  
   }

   public T get(int index) {  
       return array[index];  
   }

   public T[] create() {  
       return array;  
   }

}
 
 
 
 
 
  
ArrayWithTypeToken arrayToken = new ArrayWithTypeToken(Integer.class, 100);
Integer[] array = arrayToken.create();
 
 
 
 
所以使用反射来初始化泛型数组算是优雅实现，因为泛型类型 T 在运行时才能被确定下来，我们能创建泛型数组也必然是在 Java 运行时想办法，而运行时能起作用的技术最好的就是反射了。
 
 
 
 
 
13. 问：Java 泛型对象能实例化 T t = new T() 吗，为什么？
 
 
答：不能，因为在 Java 编译期没法确定泛型参数化类型，也就找不到对应的类字节码文件，所以自然就不行了，此外由于 T 被擦除为 Object，如果可以 new T() 则就变成了 new Object()，失去了本意。如果要实例化一个泛型 T 则可以通过反射实现（实例化泛型数组也类似），如下：
 
 
 
  
static  T newTclass(Class clazz) throws InstantiationException, IllegalAccessException {  

   T obj = clazz.newInstance();  

   return obj;  

}
 
 
 
 
原因就不解释了，姑且可以认为和上面泛型数组创建一个原因，至于本质深层次原因请关注后边关于泛型反射面试题的推送。
 
 
 
 
 
14. 问：什么是 Java 泛型中的限定通配符和非限定通配符？有什么区别？
 
 
 答：限定通配符对类型进行限制，泛型中有两种限定通配符，一种是  来保证泛型类型必须是 T 的子类来设定泛型类型的上边界，另一种是  来保证泛型类型必须是 T 的父类来设定类型的下边界，泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。非限定通配符  表示可以用任意泛型类型来替代，可以在某种意义上来说是泛型向上转型的语法格式，因为 List 与 List 不存在继承关系。
 
 
 
 
 
15. 问：简单说说 List 与 List 原始类型之间的区别？ 
 
答：主要区别有两点。
 
 
     
  
  •  
    原始类型和带泛型参数类型  之间的主要区别是在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用 Object 作为类型可以告知编译器该方法可以接受任何类型的对象（比如 String 或 Integer）。
      
  
  •  
    我们可以把任何带参数的类型传递给原始类型 List，但却不能把 List 传递给接受 List 的方法，因为会产生编译错误。
      
  
 
     
     
 
    16. 问：简单说说 List 与 List 类型之间的区别？ 
 
    答：这道题跟上一道题看起来很像，实质上却完全不同。List 是一个未知类型的 List，而 List 其实是任意类型的 List，我们可以把 List、List 赋值给 List，却不能把 List 赋值给 List。譬如：
     
 
     
  
    List listOfAnyType;

List listOfObject = new ArrayList();

List listOfString = new ArrayList();

List listOfInteger = new ArrayList();

listOfAnyType = listOfString; //legal

listOfAnyType = listOfInteger; //legal

listOfObjectType = (List) listOfString; //compiler error  
  
 
    所以通配符形式都可以用类型参数的形式来替代，通配符能做的用类型参数都能做。 通配符形式可以减少类型参数，形式上往往更为简单，可读性也更好，所以能用通配符的就用通配符。 如果类型参数之间有依赖关系或者返回值依赖类型参数或者需要写操作则只能用类型参数。
     
 
     
     
 
    17. 问：List和List 之间有什么区别？
     
 
    答：有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符，这两个 List 的声明都是限定通配符的例子，List 可以接受任何继承自 T 的类型的 List，而 List 可以接受任何 T 的父类构成的 List。例如 List 可以接受 List 或 List。Java 容器类的实现中有很多这种用法，比如  Collections 中就有如下一些方法：
     
 
     
  
    public static extends Comparablesuper T>> void sort(List list)

public static  void sort(List list, Comparatorsuper T> c)

public static  void copy(Listsuper T> dest, Listextends T> src)

public static  T max(Collectionextends T> coll, Comparatorsuper T> comp)
     
 
     
 
     
     
 
    18. 问：说说  和  有什么区别？
     
 
    答：它们用的地方不一样， 用于定义类型参数，声明了一个类型参数 T，可放在泛型类定义中类名后面、接口后面、泛型方法返回值前面。  用于实例化类型参数，用于实例化泛型变量中的类型参数，只是这个具体类型是未知的，只知道它是 E 或 E 的某个子类型。虽然它们不一样，但两种写法经常可以达到相同的目的，譬如：
     
 
     
  
    public void addAll(Beanextends E> c)

public extends E> void addAll(Bean c)
     
 
     
 
     
     
 
    19. 问：说说 List 与 List 的关系和区别？ 
 
    答：这两个东西没有关系只有区别。
     
 
    因为也许很多人认为 String 是 Object 的子类，所以 List 应当可以用在需要 List 的地方，但是事实并非如此，泛型类型之间不具备泛型参数类型的继承关系，所以 List 和 List 没有关系，无法转换。
     
 
     
     
 
    20. 问：下面两个代码片段有问题吗，为什么？
     
 
     
  
    //Part 1
     
  
     List obj = new ArrayList(); obj.add("I love Android!"); 
     
  
    //Part 2
     
  
    Object[] objArray = new Long[1]; objArray[0] = "I love Android!";
     
  
 
     答：上面 Part 1 编译出错，Part 2 编译 OK，运行出错。
     
 
    因为 List 和 ArrayList 没有继承关系，而 Java 的数组是在运行时类型检查的。
     
 
     
     
 
    21. 问：如何把 int 值放入 ArrayList list = new ArrayList(); 的 list 列表中？
     
 
    答：本题实质为泛型的擦除，不过答案比较多，常见的一种是通过兼容性，一种是通过反射的特性来处理。
     
 
    通过泛型擦除兼容性实现如下：
     
 
     
  
    ArrayList list = new ArrayList();

ArrayList list1 = list;

list1.add(12);
System.out.println(list1.get(0)); 
     
 
     
 
    通过反射实现如下：
     
 
     
  
    ArrayList list = new ArrayList();

Class clazz = list.getClass();

Method m = clazz.getMethod("add", Object.class);

m.invoke(list, 100); 
     
 
     
 
     
     
 
    22. 问：泛型擦除到底擦除了哪些信息？
     
 
    答：这道题就比较有意思和深度了，很多没有深入了解泛型的人可能听到这道题就觉得题出的有问题，因为在他们的认识里泛型信息都被擦除了，怎么还分擦除了哪些信息？难道还分情况？答案是确定的，泛型擦除其实是分情况擦除的，不是完全擦除，一定要消除这个误区。
     
 
    Java 在编译时会在字节码里指令集之外的地方保留部分泛型信息，泛型接口、类、方法定义上的所有泛型、成员变量声明处的泛型都会被保留类型信息，其他地方的泛型信息都会被擦除。
     
 
    感兴趣的可以自己编写各种场景的泛型代码然后编译后反编译查看即可发现。
     
 
     
     
 
    23. 问：既然泛型类型在编译时就被擦除了，那类似 Gson 这种 json 解析框架是如何解析数据到泛型类型 Bean 结构的呢？ 
     
 
    答：本题其实一箭双雕，即考察了对于 Gson 框架是否熟悉又考察了 Java 泛型与反射的关系及泛型的实质。
     
 
    由于在运行期间无法通过 getClass() 得知 T 的具体类型，所以 Gson 通过借助 TypeToken 类来解决这个问题，使用样例如下：
     
 
     
  
    ArrayList list = new ArrayList();

list.add("java");

Type type = new TypeToken>(){}.getType();

String gStr = new Gson().toJson(list, type);

ArrayList gList = new Gson().fromJson(gStr, type);
     
 
     
 
    可以看到 TypeToken 的使用非常简单，只用将需要获取类型的泛型类作为 TypeToken 的泛型参数构造一个匿名的子类就可以通过 getType() 方法获取到我们使用的泛型类的泛型参数类型。
     
 
    通过上面的使用样例我们会发现使用 Gson 解析转换的 Bean 不存在特殊的构造方法，因此可以排除在泛型类的构造方法中显示地传入泛型类的 Class 类型作为这个泛型类的私有属性来保存泛型类的类型信息的实现方案，所以通过源码分析发现 Gson 使用了另一种方式来获取泛型的类型参数，其方法依赖 Java 的 Class 字节码中存储的泛型参数信息，Java 的泛型机制虽然在编译期间进行了擦除，但是在编译 Java 源代码成 class 文件中还是保存了泛型相关的信息，这些信息被保存在 class 字节码的常量池中，使用了泛型的代码处会生成一个 signature 签名字段，通过签名 signature 字段指明这个常量池的地址，JDK 提供了方法去读取这些泛型信息的方法，然后再借助反射就可以获得泛型参数的具体类型，具体实现原理如下：
     
 
     
  
    Type mySuperClass = new ArrayList(){}.getClass().getGenericSuperclass();
Type type = ((ParameterizedType) mySuperClass).getActualTypeArguments()[0];
System.out.println(type);
     
 
     
 
    所以获取泛型参数类型的实质就是通过 Class 类的 getGenericSuperClass() 方法返回一个 ParameterizedType 对象（对于 Object、接口和原始类型返回 null，对于数组 class 返回 Object.class），ParameterizedType 表示带有泛型参数类型的 Java 类型，JDK1.5 引入泛型后 Java 中所有的 Class 都实现了 Type 接口，ParameterizedType 继承了 Type 接口，所有包含泛型的 Class 类都会自动实现这个接口。 
     
 
    关于 class 文件中存储泛型参数类型的详细信息可以参考：http://stackoverflow.com/questions/937933/where-are-generic-types-stored-in-java-class-files 
     
 
     
     
 
    24. 问：下面程序的输出是什么？为什么？
     
 
     
  
    public class Demo {

   public static void main(String[] args) throws Exception {

       ParameterizedType type = (ParameterizedType) Bar.class.getGenericSuperclass();
       System.out.println(type.getActualTypeArguments()[0]);
       ParameterizedType fieldType = (ParameterizedType) Foo.class.getField("children").getGenericType();
       System.out.println(fieldType.getActualTypeArguments()[0]);
       ParameterizedType paramType = (ParameterizedType) Foo.class.getMethod("foo", List.class).getGenericParameterTypes()[0];

       System.out.println(paramType.getActualTypeArguments()[0]);
       System.out.println(Foo.class.getTypeParameters()[0].getBounds()[0]);

   }

   class Fooextends CharSequence> {

       public List children = new ArrayList();

       public List foo(List foo) {
           return null;
       }
       public void bar(Listextends String> param) {
           //empty
       }
   }
   class Bar extends Foo {}
}
     
 
     
 
    答：其运行结果如下。
     
 
     
  
    class java.lang.String
class Demo$Bar
class java.lang.String
interface java.lang.CharSequence 
     
 
     
 
    通过上面例子会发现泛型类型的每一个类型参数都被保留了，而且在运行期可以通过反射机制获取到，因为泛型的擦除机制实际上擦除的是除结构化信息外的所有东西（结构化信息指与类结构相关的信息，而不是与程序执行流程有关的，即与类及其字段和方法的类型参数相关的元数据都会被保留下来通过反射获取到）。
     
 
     
     
 
    25. 问：请说说下面代码片段中注释行执行结果和原因？
     
 
     
  
    DynamicArray ints = new DynamicArray<>();
DynamicArrayextends Number> numbers = ints;
Integer a = 200;
numbers.add(a);        //这三行add现象？
numbers.add((Number)a);
numbers.add((Object)a);

public void copyTo(DynamicArraysuper E> dest){

   for(int i=0; i){

       dest.add(get(i));    //这行add现象？
   }
} 
     
 
     
 
    答：上面代码段注释行执行情况解释如下。
     
 
    三个 add 方法都是非法的，无论是 Integer，还是 Number 或 Object，编译器都会报错。因为 ? 表示类型安全无知，? extends Number 表示是 Number 的某个子类型，但不知道具体子类型， 如果允许写入，Java 就无法确保类型安全性，所以直接禁止。
     
 
    最后方法的 add 是合法的，因为  形式与  正好相反，超类型通配符表示 E 的某个父类型，有了它我们就可以更灵活的写入了。
     
 
    本题特别重要：一定要注意泛型类型声明变量 ？时写数据的规则。
     
 
     
     
 
    26. 问：请说说下面代码片段中注释行执行结果和原因？
     
 
     
  
    Vectorextends Number> x1 = new Vector();    //正确
Vectorextends Number> x2 = new Vector();    //编译错误

Vectorsuper Integer> y1 = new Vector();    //正确
Vectorsuper Integer> y2 = new Vector();    //编译错误
     
 
     
 
    答：上面代码编译运行情况如注释所示，本题主要考察泛型中的 ? 通配符的上下边界扩展问题。
     
 
    通配符对于上边界有如下限制：Vector x = new Vector<类型2>(); 中的类型1指定一个数据类型，则类型2就只能是类型1或者是类型1的子类。
     
 
    通配符对于下边界有如下限制：Vector x = new Vector<类型2>(); 中的类型1指定一个数据类型，则类型2就只能是类型1或者是类型1的父类。
     
 
     
     
 
    27. 问：下面程序合法吗？
     
 
     
  
    class Beansuper Student> { //TODO }
     
 
     
 
    答：编译时报错，因为 Java 类型参数限定只有 extends 形式，没有 super 形式。
     
 
     
     
 
    28. 问：下面程序有什么问题？该如何修复？
     
 
     
  
    public class Test {  

   public static void main(String[] args) throws Exception{  
       List listInteger = new ArrayList();  
       printCollection(listInteger);    
   }  
   public static void printCollection(Collection collection) {  
       for(Object obj:collection){  
           System.out.println(obj);  
       }    
   }  
}
     
  
 
    答：语句 printCollection(listInteger); 编译报错，因为泛型的参数是没有继承关系的。修复方式就是使用 ？通配符，printCollection(Collection collection)，因为在方法 printCollection(Collection collection) 中不可以出现与参数类型有关的方法，譬如 collection.add()，因为程序调用这个方法的时候传入的参数不知道是什么类型的，但是可以调用与参数类型无关的方法，譬如
     
 
     
  
     collection.size()。 
     
 
     
 
     
     
 
    29. 问：请解释下面程序片段的执行情况及原因？
     
 
     
  
    public class Test{
   public static  T add(T x, T y){  
       return y;
   }
   public static void main(String[] args) {
       int t0 = Test.add(10, 20.8);
       int t1 = Test.add(10, 20);

       Number t2 = Test.add(100, 22.2);
       Object t3 = Test.add(121, "abc");
       int t4 = Test.add(10, 20);

       int t5 = Test.add(100, 22.2);
       Number t6 = Test.add(121, 22.2);
   }
}
     
 
     
 
    答：t0 编译直接报错，add 的两个参数一个是 Integer，一个是 Float，所以取同一父类的最小级为 Number，故 T 为 Number 类型，而 t0 类型为 int，所以类型错误。
     
 
       
  
    •  
      t1 执行赋值成功，add 的两个参数都是 Integer，所以 T 为 Integer 类型。
       
      •  
  
    •  
      t2 执行赋值成功，add 的两个参数一个是 Integer，一个是 Float，所以取同一父类的最小级为 Number，故 T 为 Number 类型。 
       
      •  
  
    •  
      t3 执行赋值成功，add 的两个参数一个是 Integer，一个是 Float，所以取同一父类的最小级为 Object，故 T 为 Object 类型。
       
      •  
  
    •  
      t4 执行赋值成功，add 指定了泛型类型为 Integer，所以只能 add 为 Integer 类型或者其子类的参数。
       
      •  
  
    •  
      t5 编译直接报错，add 指定了泛型类型为 Integer，所以只能 add 为 Integer 类型或者其子类的参数，不能为 Float。 
       
      •  
  
    •  
      t6 执行赋值成功，add 指定了泛型类型为 Number，所以只能 add 为 Number 类型或者其子类的参数，Integer 和 Float 均为其子类，所以可以 add 成功。 
       
      •  
 
     
 
    t0、t1、t2、t3 其实演示了调用泛型方法不指定泛型的几种情况，t4、t5、t6 演示了调用泛型方法指定泛型的情况。 在调用泛型方法的时可以指定泛型，也可以不指定泛型；在不指定泛型时泛型变量的类型为该方法中的几种类型的同一个父类的最小级（直到 Object），在指定泛型时该方法中的几种类型必须是该泛型实例类型或者其子类。切记，java 编译器是通过先检查代码中泛型的类型，然后再进行类型擦除，再进行编译的。
     
 
     
     
 
    30. 问：下面两个方法有什么区别？为什么？
     
 
     
  
    public static  T get1(T t1, T t2) {  

   if(t1.compareTo(t2) >= 0);

   return t1;  

}  

 

public static extends Comparable> T get2(T t1, T t2) {

   if(t1.compareTo(t2) >= 0);  

   return t1;  

}
     
 
     
 
    答：get1 方法直接编译错误，因为编译器在编译前首先进行了泛型检查和泛型擦除才编译，所以等到真正编译时 T 由于没有类型限定自动擦除为 Object 类型，所以只能调用 Object 的方法，而 Object 没有 compareTo 方法。
     
 
    get2 方法添加了泛型类型限定可以正常使用，因为限定类型为 Comparable 接口，其存在 compareTo 方法，所以 t1、t2 擦除后被强转成功。所以类型限定在泛型类、泛型接口和泛型方法中都可以使用，不过不管该限定是类还是接口都使用 extends 和 & 符号，如果限定类型既有接口也有类则类必须只有一个且放在首位，如果泛型类型变量有多个限定则原始类型就用第一个边界的类型变量来替换。
     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(java 泛型基础问题汇总)
    
        
    
            
    
                
      
                    
    • Long类型前后端数据不一致
                        igotyback
前端
                        
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      
                    
      • 
                    
    • LocalDateTime 转 String
                        igotyback
java开发语言
                        
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      
                    
      • 
                    
    • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update
                        iBaoxing
github
                        
      如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
      
                    
      • 
                    
    • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      
                    
      • 
                    
    • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
      目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
      
                    
      • 
                    
    • 四章-32-点要素的聚合
                        彩云飘过

                        
      本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      
                    
      • 
                    
    • 高端密码学院笔记285
                        柚子_b4b4

                        
      高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
      
                    
      • 
                    
    • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
      运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
      
                    
      • 
                    
    • 数组去重
                        好奇的猫猫猫

                        
      整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      
                    
      • 
                    
    • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
      大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
      
                    
      • 
                    
    • 大伟说成语之唉声叹气
                        求索大伟

                        
      ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
      
                    
      • 
                    
    • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
      第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
      
                    
      • 
                    
    • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
      在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
      
                    
      • 
                    
    • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      
                    
      • 
                    
    • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
      数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
      
                    
      • 
                    
    • 高级 ECharts 技巧：自定义图表主题与样式
                        SnowMan1993
echarts信息可视化数据分析
                        
      ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
      
                    
      • 
                    
    • 01-Git初识
                        Meereen
Gitgit
                        
      01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
      
                    
      • 
                    
    • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
      ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
      
                    
      • 
                    
    • Rust基础知识
                        GRKF15
rust开发语言后端
                        
      1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
      
                    
      • 
                    
    • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
      聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
      
                    
      • 
                    
    • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
      Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
      
                    
      • 
                    
    • ExpRe[25] bash外的其它shell：zsh和fish
                        tritone
ExpRebashlinuxubuntushell
                        
      文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
      
                    
      • 
                    
    • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      
                    
      • 
                    
    • 网络编程基础
                        记得开心一点啊
网络
                        
      目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
      
                    
      • 
                    
    • 简单了解 JVM
                        记得开心一点啊
jvm
                        
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      
                    
      • 
                    
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      
                    
      • 
                                
    • 面向对象面向过程
                                    3213213333332132
java
                                    
      面向对象：把要完成的一件事，通过对象间的协作实现。 
面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 
我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 
 
1、面向对象 
 

package bigDemo.ObjectOriented;

/**
 * 大象类
 * 
 * @Description
 * @author FuJian
      
                                
      • 
                                
    • Java Hotspot: Remove the Permanent Generation
                                    bookjovi
HotSpot
                                    
        
openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122 
  
JEP 122: Remove the Permanent Generation

Author	Jon Masamitsu
Organization	Oracle
Created	2010/8/15
Updated	2011/
      
                                
      • 
                                
    • 正则表达式向前查找向后查找,环绕或零宽断言
                                    dcj3sjt126com
正则表达式
                                    
      向前查找和向后查找 
1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。 
    对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 
2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
      
                                
      • 
                                
    • BaseDao
                                    171815164
seda
                                    
      

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class BaseDao {

	public Conn
      
                                
      • 
                                
    • Ant标签详解--Java命令
                                    g21121
Java命令
                                    
              这一篇主要介绍与java相关标签的使用          终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。               
1
      
                                
      • 
                                
    • [简单]代码片段_电梯数字排列
                                    53873039oycg
代码
                                    
             今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       
import java.util.Arrays;

public class 电梯数字排列_S3_Test {
	public static void main(S
      
                                
      • 
                                
    • Hessian原理
                                    云端月影
hessian原理
                                    
      Hessian 原理分析 
 
 
 
 
 
一．      远程通讯协议的基本原理 
 
网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
      
                                
      • 
                                
    • 区分Activity的四种加载模式----以及Intent的setFlags
                                    aijuans
android
                                    
        
在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 
这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 
Activity有四种加载模式： 
 
 standard 
 singleTop
      
                                
      • 
                                
    • hibernate几个核心API及其查询分析
                                    antonyup_2006
html.netHibernatexml配置管理
                                    
      (一)  org.hibernate.cfg.Configuration类 
        读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.) 
        Configuration co
      
                                
      • 
                                
    • PL/SQL的流程控制
                                    百合不是茶
oraclePL/SQL编程循环控制
                                    
      PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有 
  
流程控制; 
   分支语句 if 条件 then 结果 else 结果  end if ;

  条件语句 case    when   条件  then  结果;

   循环语句  loop    
      
                                
      • 
                                
    • 强大的Mockito测试框架
                                    bijian1013
mockito单元测试
                                    
      一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
      
                                
      • 
                                
    • 精通Oracle10编程SQL(11)开发子程序
                                    bijian1013
oracle数据库plsql
                                    
      /*
 *开发子程序
 */
--子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用
--PL/SQL有两种类型的子程序：过程和函数
--开发过程
--建立过程：不带任何参数
CREATE OR REPLACE PROCEDURE out_time
IS
BEGIN
 DBMS_OUTPUT.put_line(systimestamp);
E
      
                                
      • 
                                
    • 【EhCache一】EhCache版Hello World
                                    bit1129
Hello world
                                    
      本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍 
  环境准备 
1.新建Maven项目 
  
2.添加EhCache的Maven依赖 
        <dependency>
            <groupId>ne
      
                                
      • 
                                
    • 学习EJB3基础知识笔记
                                    白糖_
beanHibernatejbosswebserviceejb
                                    
      最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。 
  
EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
      
                                
      • 
                                
    • angular.bootstrap
                                    boyitech
AngularJSAngularJS APIangular中文api
                                    
      angular.bootstrap 
描述：  
    手动初始化angular。 
    这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。 
    使用方法：       angular .
      
                                
      • 
                                
    • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数
                                    bylijinnan
java
                                    
      

public class SearchInShiftedArray {

	/**
	 * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。
	 * 请在这个特殊数组中找出给定的整数。
	 * 解答：
	 * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
      
                                
      • 
                                
    • 天使还是魔鬼？都是我们制造
                                    ducklsl
生活教育情感
                                    
      ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！ 
    从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！ 
    自己挑了两部先看了看，但是发现看完之后，心里久久不能平
      
                                
      • 
                                
    • [机器智能与生物]研究生物智能的问题
                                    comsci
生物
                                    
       
 
      我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别.... 
 
 
      但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
      
                                
      • 
                                
    • 获取Android Device的信息
                                    dai_lm
android
                                    
      
String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT;
phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI;
phoneInfo += ", TAGS: " + android.os.Build.TAGS;
ph
      
                                
      • 
                                
    • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现
                                    datamachine
java算法字符串匹配
                                    
      原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
      
                                
      • 
                                
    • 小学5年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
      long 长的 
show 给...看，出示 
mouth 口，嘴 
write 写 
  
use 用，使用 
take 拿，带来 
hand 手 
clever 聪明的 
  
often 经常 
wash 洗 
slow 慢的 
house 房子 
  
water 水 
clean 清洁的 
supper 晚餐 
out 在外 
  
face 脸，
      
                                
      • 
                                
    • macvim的使用实战
                                    dcj3sjt126com
macvim
                                    
      macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳 
  
1. 下载macvim 
https://code.google.com/p/macvim/ 
  
2. 了解macvim 
:h               vim的使用帮助信息 
:h macvim  
      
                                
      • 
                                
    • java二分法查找
                                    蕃薯耀
java二分法查找二分法java二分法
                                    
      java二分法查找 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月23日 11:40:03 星期二 
http:/
      
                                
      • 
                                
    • Spring Cache注解+Memcached
                                    hanqunfeng
springmemcached
                                    
      Spring3.1 Cache注解  
依赖jar包： 
<!-- simple-spring-memcached -->
		<dependency>
			<groupId>com.google.code.simple-spring-memcached</groupId>
			<artifactId>simple-s
      
                                
      • 
                                
    • apache commons io包快速入门
                                    jackyrong
apache commons
                                    
      原文参考 
http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html 
 
  Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍： 
  1）  工具类 
  2
      
                                
      • 
                                
    • 如何学习编程
                                    lampcy
java编程C++c
                                    
      首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
      
                                
      • 
                                
    • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy
                                    nannan408
Spring3
                                    
      1.前言。 
   如题。 
2.描述。 
   


@DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。

@DependsOn({"steelAxe","abc"})
@Comp
      
                                
      • 
                                
    • Spring4+quartz2的配置和代码方式调度
                                    Everyday都不同
代码配置spring4quartz2.x定时任务
                                    
      前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API…… 
  
quartz定时任务必须搞清楚几个概念： 
JobDetail——处理类 
Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 
Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
      
                                
      • 
                                
    • Hibernate入门
                                    tntxia
Hibernate
                                    
        
前言 
  
使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。 
  
Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。 
  
如
      
                                
      • 
                                
    • Math类
                                    xiaoxing598
Math
                                    
      一、Java中的数字（Math）类是final类，不可继承。 
1、常数    PI：double圆周率 E：double自然对数    
2、截取（注意方法的返回类型）    double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数   int round(float f) 返回四舍五入后的整数 long round
      
                                
      •