谷歌清洁工
谷歌清洁工

预热：泛型

本文大量参考Thinking in java（解析，填充）。

定义:多态算是一种泛化机制，解决了一部分可以应用于多种类型代码的束缚。虽然我们可以在参数定义一个基类或者是一个接口，但是他们的约束还是太强了，有的时候我们更希望编写更通用的代码，使代码能够应用于“某种不具体的类型”.而正是泛型的出现解决了这类问题，它实现了参数化类型的概念。其最初的目的是希望类或方法能够具备最广泛的表达能力（通过解耦类或方法与所使用的 类型之间的约束）。在你创建参数化类型的一个实例时，编译器会为你负责转型操作，并且保证类的正确性。

泛型参数不能使用基本类型.

泛型类:

public class Holder {
    private T a;
    public T getA() {
        return a;
    }
    
    public void setA(T a) {
        this.a = a;
    }
    
public static void main(String[] args) {
    Holder aHolder=new Holder<>();
    aHolder.setA("asd");
    aHolder.setA(new Object());
    
}
}```

创建Holder对象时可以指定泛型指向的对象，指明后就只能在Holder内部放入该类型（或其子类，多态与泛型不冲突），所以这里放入Object以及String都是可以的，Object是所有类的爹。

###泛型接口:同上

###泛型方法:

![泛型方法](http://upload-images.jianshu.io/upload_images/3267534-beeaebe61351a122.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 方法可以独立于类而变化。无论何时，只要你能够做到，你就应该尽量使用泛型方法。在使用泛型类时我们创建对象需要去指定类型参数的值，而使用泛型方法的时候通常不需要明确指明，如上图，编译器会自动找出相应的值(type argument inference)。同样也可以显示指明类型:
            `response.f("123");`
    当然泛型方法与可变参数之间也是可以共存的：
 
 
public class Holder1 {
 
 
public static ArrayList test(T...a)
 {
 ArrayList result=new ArrayList<>();
 for(T item:a)
 {
 result.add(item);
 }
 return result;
 }
 
 
public static void main(String[] args) {
 System.out.println(test("123","234","345"));
 
 
}
 }
 
 
output:[123,234,345]

###擦除：
  尽管可以声明Arraylist.class但是无法声明ArrayList.class.

 
 
    Class class1=new ArrayList().getClass();
Class class2=new ArrayList().getClass();
System.out.println(class1==class2);

 
 
output:true

通过这种方式可以看的更清楚:

 
 
public class Holder1 {
 
 
class A{};
class B{};

 
 
public static void main(String[] args) {
 List list =new ArrayList();
 HashMap hashMap=new HashMap<>();
 System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
 System.out.println(Arrays.toString(hashMap.getClass().getTypeParameters()));
 }
 }
 
 
output:
[E]
[K, V]
Class.getTypeParameters()将返回一个TypeVariavle对象数组，表示有泛型声明所声明的类型参数。然而输出的只是标识符，所以可以得出以下结论：
 在泛型代码内部是无法获得任何有关泛型参数类型的信息。
       
尽管你知道类型参数标识符和泛型类型边界这类的信息--你却无法知道用来创建某个特定实例的实际类型参数。
        这就是擦除带来的弊端。比如说:

 
 
public class Holder1 {
 private T obj;
 public Holder1(T obj) {
 // TODO Auto-generated constructor stub
 this.obj=obj;
 }
 public void test()
 {
 //obj.test(); wrong
 }
 public T getObj()
 {
 return obj;
 }
 
 
public static void main(String[] args) {
 Holder1holder1=new Holder1(new Test());
 holder1.test();
 }
 }
 class Test{
 public void test()
 {
 System.out.println("sb");
 }
 }
 
 
由于擦除，这种调用在java中是无法实现的，而为了实现这种需求（obj需要调用f()）就有了extends关键字，也就是泛型的边界
extends:  
` public class Holder1`
声明T必须具有类型Test或者从Test导出的类型.也就是当前定义的泛型必须是Test或其子类.
   
 为什么通过这样就能成功实现我们的需求？因为泛型类型参数在运行时是擦除到它的第一个边界，编译器实际上会把类型参数替换为它的最后擦除类，所以当前的T在擦除后实际上是Test,等于做了一个替换。
  
  那么这么做的意义在哪里，和我这样去写的差别在哪：

 
 
public class Holder1 {
 private Test obj;
 public Holder1(Test obj) {
 // TODO Auto-generated constructor stub
 this.obj=obj;
 }
 public Test getObj() {
 return obj;
 }
 public void test()
 {
 obj.test();
 }
 }
 
 
根本原因是通过泛化，能让当前代码跨越多个类工作，它不明确定义某个字类型，在使用时能返回确切的类型信息。比如:

这里返回的就是我定义的Test1

 
 
public class Holder1 {
 private T obj;
 public Holder1(T obj) {
 // TODO Auto-generated constructor stub
 this.obj=obj;
 }
 public T getObj() {
 return obj;
 }
 public void test()
 {
 obj.test();
 }
 
 
public static void main(String[] args) {
 Holder1holder1=new Holder1(new Test1());
 holder1.getObj();//这里返回的就是我定义的Test1对象
 }
 }
 class Test{
 public void test()
 {
 System.out.println("sb");
 }
 }
 class Test1 extends Test
 {
 }
 
 
为什么会有擦除，而不能像C++一样实现完整的泛化机制：
>    这就是为了保证向前的兼容性，java早期并没有泛型的相关概念，并且能够减少JVM相关的改变，以及不破坏现有类库的前提下，以最小代价来实现相关概念。
      而这也使得泛型在java当中不是那么好用。所以在运行时期，所有泛型都将被擦除，替换成它们的非泛型上界，例如List这种将被擦除为List,而普通的类型变量在没定义边界的情况下被擦除为Object.

####擦除的代价：
不能用于显式地引用运行时类型的操作之中：转型(cast)、instanceof操作和new表达式。因为所有的参数类型信息在运行时期都会丢失，所以需要无时无刻提醒自己：参数的类型信息只是目前看起来拥有而已。最后只会留下它的上界。

###边界处的动作: 

 
 
public class Holder1 {
 private Class clazz;
 public Holder1(Class class1) {
 // TODO Auto-generated constructor stub
 clazz=class1;
 }
 
 
public T[] Test() {
  return (T[]) Array.newInstance(clazz, 2);//这里强转，并且有cast警告
}

 
 
public static void main(String[] args) {
 System.out.println(Arrays.toString(new Holder1(String.class).Test()));
 
 
}
 }
 
 
output:[null, null]

  这里即使clazz被存储为Class，但是由于擦除，实际上也只是Class,因此在运行时Array.newInstance内的clazz没有实际含义。接上文描述的：在泛型代码内部是无法获得任何有关泛型参数类型的信息。所以这里Array.newInstance实际上并未拥有clazz蕴含的类型信息（这里的T没有实际意义，不知道实际上是什么）。
     而另一个例子;     

 
 
public class Holder1 {
 private List list;
 public Holder1() {
 }
 public List maker(T t,int n)
 {
 Listresult=new ArrayList<>();
 for(int i=0;i {
 result.add(t);
 }
 return result;
 }
 
 
public static void main(String[] args) {
 Holder1 sHolder1=new Holder1<>();
 System.out.println(sHolder1.maker("asd", 6));
 }
 }
 
 
这个例子中，尽管在运行时会擦除所有T类型的相关信息，可是它仍旧可以确保在编译器你放置到Holder1当中的对象具有T类型，使其适合List,确保了在方法或类中的类型内部一致性，这也可以认为是一种规法。不过还是那句话，内部并不知道T的实际含义.只能确保类型的统一.
    
因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：对象进入和离开方法的地点。

 看下面两个例子:
1.不使用泛型

 
 
public class Holder1 {
 private Object object;
 
 
public Holder1() {  
}
public void setObject(Object object) {
    this.object = object;
}
public Object getObject() {
    return object;
}   

 
 
public static void main(String[] args) {
 Holder1 holder1=new Holder1();
 holder1.setObject("String");
 String string=(String) holder1.getObject();
 }
 }
 
 
 反编译后：  

 
 
D:>javap -c Holder1
 Compiled from "Holder1.java"
 public class Holder1 {
 public Holder1();
 Code:
 0: aload_0
 1: invokespecial #1 // Method java/lang/Object."":
 ()V
 4: return
 public void setObject(java.lang.Object);
 Code:
 0: aload_0
 1: aload_1
 2: putfield #2 // Field object:Ljava/lang/Object;
 5: return
 public java.lang.Object getObject();
 Code:
 0: aload_0
 1: getfield #2 // Field object:Ljava/lang/Object;
 4: areturn
 public static void main(java.lang.String[]);
 Code:
 0: new #3 // class Holder1
 3: dup
 4: invokespecial #4 // Method "":()V
 7: astore_1
 8: aload_1
 9: ldc #5 // String String
 11: invokevirtual #6 // Method setObject:(Ljava/lang/Obje
 ct;)V
 14: aload_1
 15: invokevirtual #7 // Method getObject:()Ljava/lang/Obj
 ect;
 18: checkcast #8 // class java/lang/String
 21: astore_2
 22: return
 }
 
 
 前面的一大部分省略,set和get都是针对Object操作，观察第18行得知，get之后会有一个checkcast类型检查，翻阅
Java Virtual Machine Online Instruction Reference：得知
>  checkcast:ensure type of an object or array, checks that the top item on the operand stack (a reference to an object or array) can be cast to a given type.

 翻译：确保一个Object或者Array的类型。检查操作数栈的最上层item（object或array的引用）是否能被转换成相应的类型。

 checkcast 实际上可以被认为是:

 
 
if (! (obj == null || obj instanceof )) {
 throw new ClassCastException();
 }
 // if this point is reached, then object is either null, or an instance of
 //  or one of its superclasses.
 
 

2.使用泛型:

 
 
public class Holder1 {
 private T object;
 
 
public Holder1() {  
}
public void setObject(T object) {
    this.object = object;
}
public T getObject() {
    return object;
}   

 
 
public static void main(String[] args) {
 Holder1 holder1=new Holder1<>();
 holder1.setObject("String");
 String string=holder1.getObject();
 }
 }
 
 
反编译后：


 
 
public static void main(java.lang.String[]);
 Code:
 0: new #3 // class Holder1
 3: dup
 4: invokespecial #4 // Method "":()V
 7: astore_1
 8: aload_1
 9: ldc #5 // String String
 11: invokevirtual #6 // Method setObject:(Ljava/lang/Obje
 ct;)V
 14: aload_1
 15: invokevirtual #7 // Method getObject:()Ljava/lang/Obj
 ect;
 18: checkcast #8 // class java/lang/String
 21: astore_2
 22: return
 }
 
 
11行setObject开始传入的就是Object，但是set()方法不需要类型检查，编译器已经检查过了，但是对get方法在18行checkcast还是进行了类型检查，只不过用了泛型以后由编译器自动插入，其实效果是一样的。
    
在泛型中所有动作发生在边界处---对传进来的值做额外的编译期检查，并由编译器插入传出去的值的转型。这都是在编译期间完成的。
    
###泛型数组:

 
 
class Gener
 {
 public void gg()
 {
 System.out.println("ASD");
 }
 }
 public class Holder1 {
 static Gener[] gia;
 
 
public Holder1() {  
    
}

 
 
public static void main(String[] args) {
 // gia=(Gener[]) new Object[10]; //编译器不会报错，但是运行会报错ClassCastException
 // gia[0].gg();
 gia=(Gener[]) new Gener[10];
 gia[0]=new Gener();
 gia[0].gg();
 }
 
 
}
 
 
那么既然数组无论它们持有的类型如何，都具有相同的结构，看起来是可以创建一个Object数组并将其转型为所希望的数组类型。事实上这样做会报错，为什么呢。


 通过编写下述代码，进行反编译 

 
 
public class TT {
 public static void main(String[] args) {
 int[] aa=new int[10];
 String[]bb=new String[10];
 }
 }
 
 
获得

 
 
public class TT {
 public TT();
 Code:
 0: aload_0
 1: invokespecial #1 // Method java/lang/Object."":
 ()V
 4: return
 public static void main(java.lang.String[]);
 Code:
 0: bipush 10 //push the int 10 onto the stack,将10放入堆栈中
 2: newarray int
 4: astore_1
 5: bipush 10
 7: anewarray #2 // class java/lang/String
 10: astore_2
 11: return
 }
 
 
这里有个newarray和anewarray就是创建数组,同样翻阅
Java Virtual Machine Online Instruction Reference：
>newarray:allocate new array for numbers or booleans.  
newarray is used to allocate single-dimension arrays of booleans, chars, floats, doubles, bytes, shorts, ints or longs.
    newarray pops a positive int, n, off the stack, and constructs an array for holding n elements of the type given by . Initially the elements in the array are set to zero. A reference to the new array object is left on the stack.
  
   翻译：newarray给numbers或者booleans分配一个新的数组。它被用来分配booleans, chars, floats, doubles, bytes, shorts, ints or longs. 的一维数组。
        newarray从堆栈中弹出一个正整数n,然后构造一个type是你定义的类型的数组。初始化数组当中所有的元素(都设置默认为0)。在堆栈上留下对新数组对象的引用.  
>anewarray:allocate new array for objects. is either the name of a class or interface, e.g. java/lang/String, or, to create the first dimension of a multidimensional array,  can be an array type descriptor, e.g. [Ljava/lang/String;  
        
        anewarray allocates a new array for holding object references. It pops an int, size, off the stack and constructs a new array capable of holding size object references of the type indicated by .
       
         indicates what types of object references are to be stored in the array (see aastore). It is the name of a class or an interface, or an array type descriptor. If it is java/lang/Object, for example, then any type of object reference can be stored in the array.  is resolved at runtime to a Java class, interface or array. See Chapter 7 for a discussion of how classes are resolved.
     
      A reference to the new array is pushed onto the stack. Entries in the new array are initially set to null.    

 翻译:给对象分配新的数组.可以是class或者interface的名称,比如说java/lang/String，   或者为了创建多维数组的第一维，可以是数组类型描述符，例如   [Ljava/lang/String;                              anewarray  分配一个新的数组去持有对象的引用。它从对战中弹出一个int类型的size（大小），并构造一个能够持有size个type对象引用的新数组。
     
  表示object引用在数组当中是以什么类型被存储的。它是class或者interface的名称或者数组类型的描述。比如说type是 java/lang/Object，那么任意object引用都能被存储进当前数组中，而在运行时将解析成java类，interface或者数组。
  
 一个新的数组引用将push到堆栈上，数组中所有条目都会被设置为null 
 
 从这里就可以看出，这里泛型数组的构建会调用anewarray，而anewarray需要明确的type,
那么这样就可以知道:
 1.在gia=(Gener[]) new Object[10];   中，即使gia看起来是转型为Gener[],但是这也只是在编译期，运行时他仍然是Object[],正是因为anewarray运行时已经将type定义为Object,你无法对底层的数组进行更改。所以强制转型会引起ClassCastException.

   2.根据Oracle的java文档来看，泛型属于Non_Reifiable type,而引起这部分的原因也是因为类型擦除Non_Reifiable type会在编译期被移除泛型信息，所以在运行时无法获取具体的类型信息。而java明确规定数组内的元素必须是reifiable的，所以类似T[] a=new T[10]这类型的无法通过编译。

参考例子：  

 
 
String[] strArray = new String[20];
 Object[] objArray = strArray;
 objArray[0] = new Integer(1); // throws ArrayStoreException at runtime
 
 
那么假如说泛型的数组可以直接创建:
ArrayList[] a=new ArrayList[];
那么随后也可以改为Object数组然后往里面放ArrayList，我们在随后的代码中可以把它转型为Object[]然后往里面放Arraylist实例。
这样做不但编译器不能发现类型错误，就连运行时的数组存储检查对它也无能为力，它能看到的是我们往里面放Arraylist的对象，我们定义的在这个时候已经被抹掉了.

 
 
//下面的代码使用了泛型的数组，是无法通过编译的
 GenTest genArr[] = new GenTest[2];
 Object[] test = genArr;
 GenTest strBuf = new GenTest();
 strBuf.setValue(new StringBuffer());
 test[0] = strBuf;
 GenTest ref = genArr[0]; //上面两行相当于使用数组移花接木，让Java编译器把GenTest当作了GenTest
 String value = ref.getValue();// 这里是重点！
 
 
最后一行中，根据之前讲到的泛型边界问题，取值的时候会是这样
(String)ref.getValue();所以会有ClassCastException.这个程序虽然看起来是程序员的错误，
而且也没有什么灾难性后果。但是从另一个角度看，泛型就是为了消灭ClassCastException出现的
而这个时候他自己却引发这个错误，这就矛盾了。通常来说如果使用泛型，只要代码编译时没有警告，那么就不会出现错误ClassCaseException。

  究竟泛型数组应该怎么用，我们可以参考ArrayList的源码

 
 
transient Object[] elementData; // non-private to simplify nested class access
 
 
它内部使用的就是Object[]

get方法对item使用了强转，才能让我们获取到正确的对象。

 
 
// Positional Access Operations
 @SuppressWarnings("unchecked")
 E elementData(int index) {
 return (E) elementData[index];
 }
 /**
 * Returns the element at the specified position in this list.
 *
 * @param index index of the element to return
 * @return the element at the specified position in this list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
 public E get(int index) {
 rangeCheck(index);
 return elementData(index);
 }
 
 
add方法涉及到向上转型

 
 
public boolean add(E e) {
 ensureCapacityInternal(size + 1); // Increments modCount!!
 elementData[size++] = e;
 return true;
 }
 
 
事实证明，ArrayList大量使用了强转去实现。
总的来说数组是协变的而泛型不是，如果 Integer扩展了 Number（事实也是如此），那么不仅 Integer是 Number，
而且 Integer[]也是 Number[]，在要求 Number[]的地方完全可以传递或者赋予 Integer[]。
这也是矛盾发生的根本原因.

###边界：
简单点就是 这样在擦除的时候T就会转换成Base,而在泛型类或方法中可以直接视同Base
的方法

 
 
public class Response {
 public void f(T t)
 {
 t.test();
 
 
}
 }
 class ABC{
 public void test()
 {
 System.out.println("asdasd");
 }
 }
 
 
另一种用法就是

 
 
interface has{
 void test();
 }
 public class Ges {
 T mT;
 public T getmT() {
 return mT;
 }
 public void setmT(T mT) {
 this.mT = mT;
 }
 
 
继承一个父类与多个接口的形式。和类继承的用法是一样的，不过class必须在第一个，接口跟在后面
同样，如果希望将某个类型限制为特定类型或特定类型的超类型，请使用以下表示法：


###通配符:
泛型没有内建的协变类型，有时候想要在两个类型之间建立某种类型的向上转型关系：这正是通配符允许的

 
 
public class Ges {
 public static void main(String[] args) {
 List list=new ArrayList();
 // list.add(new fruit());
 // list.add(new apple()); all wrong
 fruit fruit=list.get(0);//可以获取到fruit
 }
 }
 class fruit{
 
 
}
 class apple extends fruit{
 
 
}
 
 
尽管list类型是List但是这并不实际意味着List将持有任何类型的fruit。实际上你不能往这个list当中安全的添加对象。尽管他可以合法指向一个list，
你无法往里面丢任何对象。编译器只知道list内部的任何对象至少具有fruit类型，但是他具体是什么就不知道了。

每当指定add方法的时候，![](http://upload-images.jianshu.io/upload_images/3267534-3002ac82f9d98063.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)显示的都是null，由于不知道，所以干脆不接受任何类型的fruit。同样的编译器将直接拒绝对参数列表中
涉及通配符的方法的调用。

当然List list=new ArrayList();这种写法赋予了泛型一种协变性，
像之前提到过的:List list=new ArrayList()是无法通过的因为假如这么写，
那就意味着可以list.add(new Banana());这就破坏了list定义时的承诺，它是一个苹果列表。

那么针对这种情况(无法往内部添加)可以使用超类型通配符： ，有了超类型通配符，你就可以进行写入了：
![](http://upload-images.jianshu.io/upload_images/3267534-dd793ecf68699d44.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 这相当于定义了一个下界，无论你传入什么，最起码是apple,或者是他的子类，这样的类型传入是安全的.
这种写法也可以称之为逆变，同样的get方法返回的是Object.
###关于协变和逆变：
    
    什么是协变（逆变）：
>如果A和B是类型（T），f表示类型转换，≤表示子类型关系，（例如A≤B，表示A是B的子类）那么：
如果A≤B 则f(A) ≤ f(B) 那么 f是协变的 (假如说T和f(T)序关系一致，就是协变)
如果A≤B 则f(B) ≤ f(A) 那么 f 是逆变的(假如说T和f(T)序关系相反，就是逆变)
如果上面两种都不成立，那么f是无关的

例如：class List{...}，可以理解为输入一个类型参数T，通过类型转换(f)成为，List(f(T))
所以当A=Object,B=String，那么f(A)=List,f(B)=List,可是f(A)与f(B)不具备
任何关系，所以单纯的泛型不具备协变性。

所以ArrayList=ArrayList,(? extends fruit)<=fruit
，f(? extends fruit)=f(fruit),通过这种写法具备了协变性。

同样ArrayList=ArrayList,(? super fruit)>=fruit，
f(? extends fruit)=f(fruit),这就是逆变性。

#### 为什么要有协变逆变？优势在哪？
 而根据里氏替换原则:
 >派生类（子类）对象能够替换其基类（超类）对象被使用。当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

从例子来看:
 
 
public class f {
 // 定义三个类: Benz -> Car -> Vehicle，它们之间是顺次继承关系
 
 
// 测试函数
void test() {
    List vehicles = new ArrayList<>();
    List benzs = new ArrayList<>();
    Utils carUtils = new Utils<>();
    carUtils.put(vehicles, new Car());
    Car car = carUtils.get(benzs, 0);
    carUtils.copy(vehicles, benzs);
}

 
 
}
 class Vehicle {}
 class Car extends Vehicle {}
 class Benz extends Car {}
 // 定义一个util类，其中用到泛型里的协变和逆变
 class Utils {
 T get(List list, int i) {
 return list.get(i);
 }
 
 
void put(List list, T item) {
    list.add(item);
}

void copy(List to, List from) {
    for(T item : from) {
        to.add(item);
    }
}

 
 
}
 
 
Car car = carUtils.get(benzs, 0);可以看出 List对List进行了替换(协变)，

List的get方法返回Benz对象，而List返回的是Car对象，这符合替换原则，方法的后置条件（即方法的返回值）要比父类更严格。

carUtils.put(vehicles, new Car());List对List进行替换(逆变)，

List的put方法需要Vehicle对象作为形参，而List需要的是Car,这就满足替换原则
的前置条件需求.

最后一个copy体现的是协变与逆变的汇总，替换。所以总的来说泛型的协变与逆变定义上界与下界，同时也让程序
能够在某种程度上满足替换原则，通过良好的替换让程序更具拓展性。这也是为什么大量的框架中
例如rxjava，会在参数中大量使用这种形式的泛型写法。

参考:
 Thinking in java
 http://ybin.cc/programming/java-variance-in-generics/
 https://www.zybuluo.com/zhanjindong/note/34147
 http://www.cnblogs.com/en-heng/p/5041124.html
 http://colobu.com/2015/05/19/Variance-lower-bounds-upper-bounds-in-Scala/#Java中的协变和逆变
 http://blog.csdn.net/hopeztm/article/details/8822545
 https://zh.wikipedia.org/wiki/%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8D%A2%E5%8E%9F%E5%88%99
 https://www.ibm.com/developerworks/cn/java/j-jtp01255.html
 https://www.zhihu.com/question/20928981
 http://cs.au.dk/~mis/dOvs/jvmspec/ref-Java.html
 http://www.blogjava.net/deepnighttwo/articles/298426.html
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(预热：泛型)

        

            

                
    
                    
  • Java【泛型】
                        SkyrimCitadelValinor
Java基础java
                        
    Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
    
                    
    • 
                    
  • C# 开发教程-入门基础
                        天马3798
教程系列整理c#开发语言
                        
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
    
                    
    • 
                    
  • 终于搞懂TS中的泛型啦! | typescript 入门指南 04
                        程序员王天
TypeScript实践指南前端javascripttypescript
                        
    大家好，我是王天~今天分享的是《ts入门指南》系列中第四篇，主要讲解ts中的泛型应用泛型在ts中是比较重要的概念，我花挺长时间才搞明白，整理输出这篇文章，希望能帮助到大家~《ts入门指南》系列，点击下方蓝色字体即可访问TsvsJs谁适合前端开发？|TypeScript入门指南01详解tsconfig.json配置文件|TypeScript入门指南02必学！TypeScript语法类型基础|Type
    
                    
    • 
                    
  • Java泛型编程
                        shymoy
java开发语言
                        
    文章目录为什么需要泛型如何实现技术细节泛型数组泛型类型实现接口接收参数小结为什么需要泛型如果为每一种类型都写一个类来适配，会造成code冗长且难读，所以需要写一个同一的抽象的方法来实现，并让编译器自动的传入这些类型。如何实现通常放在类后面的尖括号里publicclassGenertic{}也可以指代多个publicclassGenertic{}这个类中的变量都可以用K和V来表示了泛型不仅可以应用在
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • 不念过往，不畏将来
                        一袖红尘

                        
    网图，侵删迎春送夏，历秋经冬，2020年走到了最后一天，未来的365天将属于2021年。道一声“再见”，说一句“你好”，过去和未来在今天擦肩而过！子在川上曰：逝者如斯夫！时间像一条河流，无声无息中冲淡了许多回忆，惟有文字，让渐行渐远的岁月犹有痕迹可循。庚子新春，疫情席卷，大江南北闻疫色变。除夕之夜，老公身着白色防护服走进了预热门诊，第一次没有陪我和女儿守岁，听诊器下病人的心跳是他听到的第一声新年钟
    
                    
    • 
                    
  • .NET常见面试题汇总
                        .Net Core 爱好者
.netc#
                        
    首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
    
                    
    • 
                    
  • Swift基本语法-简例
                        ☆MOON
移动互联网-iOS笔记python正则表达式爬虫
                        
    Swift基本语法简例安全类型?与!区别变量与常量字符串拼接多行字符串数组操作字典操作数组遍历控制条件判断switch语句循环遍历函数闭包对象枚举结构体协议扩展泛型get，set属性属性观察懒加载，重写方法回调及保护安全类型?与!区别?表示：返回值是一个可选类型，需要解包处理，如果有值就是相应类型的，如果没有值，就是“nil”，适用于不确定值的情形!表示：不需要解包处理（第一次赋值时编译器已自动解
    
                    
    • 
                    
  • 包装类&认识泛型
                        秃头的赌徒
JAVASEjavajvm开发语言
                        
    目录一、包装类1.1基本数据类型和对应的包装类1.2装箱和拆箱二、泛型2.1语法三、泛型类的使用3.1语法3.2示例3.3类型推导3.4裸类型四、泛型如何编译的4.1擦除机制4.2为何不能实例化泛型类型数组五、泛型的上界5.1语法5.2示例5.3复杂示例六、泛型方法6.1定义语法6.2示例一、包装类定义：在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给
    
                    
    • 
                    
  • flutter 泛型_Flutter入门——泛型
                        weixin_39627408
flutter泛型
                        
    在查看基本数组类型List的API文档，会看到该类型实际上是List。表示法将List标记为泛型(或参数化)类型-具有正式类型参数的类型。按照惯例，大多数类型变量都有单字母名称，例如E，T，S，K和V.为什么要使用泛型类型安全通常需要泛型，除了允许让代码运行之外，还可以：正确指定泛型类型会生成更好的代码。例如，可以使用List(字符串列表)，来表示列表中只包含字符串，这样编译器就会启用类型检查，非
    
                    
    • 
                    
  • 学做披萨
                        6be69e3690b9

                        
    今天我学习做披萨，这是一件很有趣的事情。碗中打入两颗鸡蛋，先再到半袋牛奶，再放点酵母，白糖、玉米油、糖、面粉搅拌以后加入部分适量牛奶，加入酵母，上面放鞋芝士，外围抹一层沙拉酱，发好的面，加入水果，烤箱预热五分钟，烤十五分钟左右，香喷喷的披萨就要出锅了，啊！味道太棒了！
    
                    
    • 
                    
  • Java 知识框架主要包括面向对象、集合框架、异常处理、泛型和多线程等知识
                        爱摄影的程序猿
JAVA面试java开发工具windowsjavaspringboot
                        
    Java知识框架主要包括面向对象、集合框架、异常处理、泛型和多线程等知识。下面将对每个知识点进行详解，并提供相关的案例和面试题解答。面向对象：面向对象是Java的核心思想，它将程序中的数据和操作封装成对象，并通过对象之间的交互实现程序的功能。在面向对象的思想中，包括类、对象、继承、多态等概念。案例：创建一个学生类，包含学生的姓名和年龄属性，以及获取学生信息和修改学生信息的方法。publicclas
    
                    
    • 
                    
  • 泛型和通配符
                        当归. z Z
java基础java
                        
    泛型所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值或参数的类型。这个类型参数将在使用时（例如，继承或实现这个接口、创建对象或调用方法时）确定（即传入实际的类型参数，也称为类型实参）。例如，集合类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK5.0之前只能把元素类型设计为Object，JDK5.0时Java引入了“参数化类型
    
                    
    • 
                    
  • Redis7_16 高阶篇 第七章 Redis中的缓存预热/缓存雪崩/缓存击穿/缓存穿透问题详解
                        孤尘Java
Redis从小白到精通缓存
                        
    大家好！欢迎来到“孤尘”的Java世界！️感谢认可！事不宜迟，一起尽情地畅享编程之旅吧！目录面试题(文末有答案)概念（是什么？）缓存预热缓存雪崩缓存击穿缓存穿透缓存预热定义怎么做？实现缓存雪崩定义引起缓存雪崩的原因规避/解决方案1.Redis中key设置为永不过期或过期时间错开2.Redis缓存集群实现高可用3.多缓存结合预防雪崩4.服务降级5.使用云服务缓存击穿定义引起缓存击穿的原因规避/解决方
    
                    
    • 
                    
  • 深入理解Redis原理：缓存雪崩/击穿/穿透/预热/降级
                        Hey 锡瑞
Redis缓存
                        
    目录1、缓存雪崩1.1、什么是缓存雪崩1.2、解决缓存雪崩2、缓存击穿2.1、什么是缓存击穿2.2、解决缓存击穿3、缓存穿透3.1、什么是缓存穿透3.2、解决缓存穿透3.3、基于RedisBloom实现布隆过滤器4、缓存预热4.1、什么是缓存预热4.2、解决缓存预热5、缓存降级5.1、什么是缓存降级下一篇：redis5种数据结构及底层实现原理1、缓存雪崩1.1、什么是缓存雪崩如果缓在某一个时刻出现
    
                    
    • 
                    
  • 缓存预热/雪崩/穿透/击穿
                        当归. z Z
Redis缓存
                        
    1.缓存预热预先将MySQL中的数据同步至Redis的过程2.缓存雪崩Redis主机出现故障，或有大量的key同时过期大面积失效导致Redis不可用Redis中key设置为永不过期，或者过期时间错开Redis缓存集群实现高可用多缓存结合预防雪崩服务降级3.缓存穿透每次请求数据Redis上都没有，导致MySQL压力增大，此时Redis形同摆设空对象缓存或者缺省值回写增强如果发生了缓存穿透，我们可以针
    
                    
    • 
                    
  • C++ 萃取技术——固定萃取技术
                        不是仙人的闲人
#C++模板与泛型编程c++开发语言
                        
    目录C++萃取技术——固定萃取技术1.萃取技术简介2.固定萃取技术2.1固定萃取常规范例2.2迭代器范例2.3通过容器（数组）类型萃取元素类型范例2.4引用类型的移除和增加2.5const修饰符的移除2.6退化技术总结C++萃取技术——固定萃取技术在C++的模板和泛型编程领域，“萃取”（trait）技术发挥着至关重要的作用。这种技术让程序能够在编译时对类型执行各种操作和计算，有效提取和利用类型信息
    
                    
    • 
                    
  • kotlin中Gson解析Json时对于泛型的应用
                        张子羽
安卓三分钟jsonkotlinandroid
                        
    Gosn解析Json我们都知道，在使用Gson解析json时，可以通过如下代码将json转为实体类valuser=Gson().fromJson(json,UserBean::class.java)实体类的定义而在开发过程中，我们也可能遇到这样的Json数据//一个登陆接口返回的数据{"data":{"admin":false,"chapterTops":[],"coinCount":10,"co
    
                    
    • 
                    
  • Kotlin reified改造JSON解析
                        折翅鵬
Kotlinkotlinjson开发语言
                        
    reified有什么用？funmyGenericFun(c:Class)在myGenericFun泛型函数体内，无法访问类型T，因为T只有在编译时可用，但在运行时就被擦除了，也就是泛型擦除，。因此，如果想在函数体中使用泛型类型作为普通类型使用，就需要显式将该类作为参数传递，如myGenericFun中所示。如果使用reifiedT创建内联（inline）函数，则就算在运行时也可以访问T的类型，因此
    
                    
    • 
                    
  • Java 类型擦除机制详解
                        项目笔记与工具库
java开发语言
                        
    Java的类型擦除机制（TypeErasure）是Java泛型中一个非常重要的特性。通过类型擦除，Java既实现了泛型功能，又能保持与旧版本的向后兼容性。本文将详细介绍Java类型擦除机制的工作原理、步骤、影响以及相关示例。什么是类型擦除？类型擦除是指在编译时，Java编译器会将泛型类型转换为原始类型（rawtype），并删除或替换与类型参数相关的类型信息。换句话说，在编译后的字节码中，泛型的具体
    
                    
    • 
                    
  • Redis 缓存深度解析：穿透、击穿、雪崩与预热的全面解读
                        加勒比海涛
Redis入门实践缓存redis数据库
                        
    Redis缓存深度解析：穿透、击穿、雪崩与预热的全面解读一.什么是缓存?二.使用Redis作为缓存三.缓存的更新策略3.1定期生成3.2实时生成四.缓存预热、缓存穿透、缓存雪崩、缓存击穿4.1缓存预热4.2缓存穿透4.3缓存雪崩4.4缓存击穿Hello,大家好,这个专栏给大家带来的是Redis系列!本篇文章给大家讲解的是Redis的缓存.在Redis缓存系统中,缓存穿透、缓存击穿、缓存雪崩和缓存预
    
                    
    • 
                    
  • Redis总结：缓存雪崩、缓存击穿、缓存穿透与缓存预热、缓存降级
                        南方葵籽
编程java面试缓存redisjava面试分布式
                        
    01缓存雪崩1.1什么是缓存雪崩？如果缓在某一个时刻出现大规模的key失效，那么就会导致大量的请求打在了数据库上面，导致数据库压力巨大，如果在高并发的情况下，可能瞬间就会导致数据库宕机。这时候如果运维马上又重启数据库，马上又会有新的流量把数据库打死。这就是缓存雪崩。1.2缓存雪崩问题分析造成缓存雪崩的关键在于同一时间的大规模的key失效，为什么会出现这个问题，主要有两种可能：第一种是Redis宕机
    
                    
    • 
                    
  • Scala教程之:静态类型
                        flydean程序那些事

                        
    Scala是静态类型的，它拥有一个强大的类型系统，静态地强制以安全、一致的方式使用抽象，我们通过下面几个特征来一一说明：泛类型型变类型上界类型下界内部类抽象类型复合类型自类型隐式参数隐式转换多态方法类型推断通过这些特性，为安全可重用的编程抽象以及类型安全的扩展提供了强大的基础。泛类型和java一样，Scala也有泛型的概念，在scala里面泛型是使用方括号[]来接受类型参数的。通常使用字母A来作为
    
                    
    • 
                    
  • Vue3异步请求的最佳实践：async/await 与 Promise.then()，Vue3请求接口数据，以及TypeScript中的泛型和任意类型（Vue3请求API，TS中的T 和 any）
                        北城笑笑
VueJS前端vue.js
                        
    前言在Vue3开发中，异步请求是非常常见的操作，特别是在与后端API交互时。虽然Vue.js自带了一些对异步数据的处理方式，但合理使用异步操作是确保应用顺畅运行的关键。这里我分享一下Vue3异步请求的最佳实践，并探讨async/await和Promise.then()两种处理异步操作的方式，简单记录一下1.请求接口的实现这里，我们使用一个请求接口callAskRecordList，它会从/gpt/
    
                    
    • 
                    
  • C# List用法 List介绍
                        光怪陆离的节日
C#c#list开发语言
                        
    #List泛型集合集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。为什么要用泛型集合？在C#2.0之前，主要可以通过两种方式实现集合：a.使用ArrayList直接将对象放入ArrayList，操作直观，但由于集合中的项是Object类型，因此每次使用都必须进行繁琐的类型转换。b.使用自定义集合类比较常见的做法是从CollectionBase抽象类继承一个自定义类，通过对
    
                    
    • 
                    
  • C# List定义和常用方法
                        語衣
C#知识补充c#list
                        
    栏目总目录List的定义列表（List）是一种常用的集合类型，它属于System.Collections.Generic命名空间。列表是一个有序集合，可以包含重复的元素，并且可以根据索引访问元素。ListList是一个泛型集合，它提供了比数组更灵活的方式来存储和操作数据。List继承自IList接口，并实现了许多用于添加、移除、搜索、排序等操作的方法。通过指定类型参数T来定义一个List。例如存储
    
                    
    • 
                    
  • Java基础 -- 05反射reflect
                        mmlz00
Java基础Java基础反射reflectProxy动态代理
                        
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
    
                    
    • 
                    
  • .NET/C#⾯试题汇总系列：集合、异常、泛型、LINQ、委托、EF！
                        微微的猪食小窝
c#.netlinq
                        
    1.IList接⼝与List的区别是什么?‌定义与继承关系‌：IList是一个接口，定义了一组对象的集合，这些对象可以通过索引进行访问，并且支持插入、删除和搜索等操作。它继承自ICollection和IEnumerable，以及它们的非泛型版本。List是一个类，实现了IList接口。它提供了接口中定义的所有方法的具体实现，并添加了一些额外的功能，如排序、搜索等。‌功能与灵活性‌：使用IList接
    
                    
    • 
                    
  • ToList()和ToArray()的区别
                        微微的猪食小窝
.Net进阶.net后端开发语言linqc#
                        
    以下是具体分析：1.返回类型ToList()：返回一个泛型列表List，其中T是列表中元素的类型。ToArray()：返回一个Object类型的数组。如果需要特定类型的数组，必须使用重载的ToArray(T[]a)方法，并传入一个该类型的数组作为参数。2.内部处理ToList()：直接创建一个新的List，并将元素添加到这个List中。ToArray()：根据传入的数组参数情况，可能会创建新数组或
    
                    
    • 
                    
  • ThreadLocal
                        血莲丹
JAVA基础java多线程内存泄漏ThreadLocal
                        
    简介  我们都知道，多线程情况下，是会有资源竞争问题。当并非访问某共享资源时，就会出现问题，尤其是写操作，程序猿一般通过同步锁机制来保证线程安全。而当我们需要为每一个线程都保存一份线程独有的数据时，即相当于将共享变量变为每个线程都有一份的私有变量，就可以使用到ThreadLocal。  ThreadLocal位于java.lang包下，是JDK提供的一个类，支持泛型的。该类的作用就如其名字一样，线
    
                    
    • 
                                
  • jvm调优总结（从基本概念 到 深度优化）
                                    oloz
javajvmjdk虚拟机应用服务器
                                    
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html 
 
  Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。 
    
                                
    • 
                                
  • 【Scala十六】Scala核心十：柯里化函数
                                    bit1129
scala
                                    
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 
A way to write functions with multiple parameter lists. For instance
def f(x: Int)(y: Int) is a 
    
                                
    • 
                                
  • HashMap
                                    dalan_123
java
                                    
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 
1、数据结构 
    在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
    
                                
    • 
                                
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容
                                    周凡杨
java更新swingJTextArea
                                    
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。

问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
    
                                
    • 
                                
  • servlet或struts的Action处理ajax请求
                                    g21121
servlet
                                    
    其实处理ajax的请求非常简单，直接看代码就行了： 
		//如果用的是struts
		//HttpServletResponse response = ServletActionContext.getResponse();
		// 设置输出为文字流
		response.setContentType("text/plain");
		// 设置字符集
		res
    
                                
    • 
                                
  • FineReport的公式编辑框的语法简介
                                    老A不折腾
finereport公式总结
                                    
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 
简单的说下自己感觉的公式要注意的几个地方： 
  
1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
    
                                
    • 
                                
  • linux mysql 数据库乱码的解决办法
                                    墙头上一根草
linuxmysql数据库乱码
                                    
    linux 上mysql数据库区分大小写的配置 
lower_case_table_names=1 1-不区分大小写 0-区分大小写 
  
修改/etc/my.cnf 具体的修改内容如下: 
  
[client] 
default-character-set=utf8 
  
[mysqld] 
datadir=/var/lib/mysql 
socket=/va
    
                                
    • 
                                
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想
                                    aijuans
Spring 3
                                    
    ApplicationContext能读取多个Bean定义文件，方法是： 
 
 
ApplicationContext appContext = new ClassPathXmlApplicationContext（

new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
    
                                
    • 
                                
  • mysql 基准测试之sysbench
                                    annan211
基准测试mysql基准测试MySQL测试sysbench
                                    
    1 执行如下命令，安装sysbench-0.5： 
 tar xzvf sysbench-0.5.tar.gz  
 cd sysbench-0.5  
 chmod +x autogen.sh  
 ./autogen.sh  
 ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
    
                                
    • 
                                
  • sql的复杂查询使用案列与技巧
                                    百合不是茶
oraclesql函数数据分页合并查询
                                    
      
本片博客使用的数据库表是oracle中的scott用户表; 
  
   
    -------------------  自然连接查询 
          查询 smith 的上司(两种方法) 
&
    
                                
    • 
                                
  • 深入学习Thread类
                                    bijian1013
javathread多线程java多线程
                                    
    一．             线程的名字 
下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 
同时，Thr
    
                                
    • 
                                
  • JSON串转换成Map以及如何转换到对应的数据类型
                                    bijian1013
javafastjsonnet.sf.json
                                    
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 
一.fastjson实例 
JsonUtil.java 
package com.study;

impor
    
                                
    • 
                                
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架
                                    bit1129
spring
                                    
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成 
  在
【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
    
                                
    • 
                                
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析
                                    bit1129
Mahout
                                    
    #!/bin/bash
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information re
    
                                
    • 
                                
  • nginx三种获取用户真实ip的方法
                                    ronin47

                                    
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 
实例环境： 用户IP 120.22.11.11 
    
                                
    • 
                                
  • java-判断二叉树是不是平衡
                                    bylijinnan
java
                                    
    参考了 
http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 
但是用java来实现有一个问题。 
由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass 
 
 

import ljn.help.*;
public class BalancedBTree {

    
                                
    • 
                                
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties
                                    诸葛不亮
PropertyUtilsBeanUtils
                                    
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  
作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
    
                                
    • 
                                
  • [金融与信息安全]最简单的数据结构最安全
                                    comsci
数据结构
                                    
     
 
      现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？ 
 
       从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
    
                                
    • 
                                
  • vi区段删除
                                    Cwind
linuxvi区段删除
                                    
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 
  
vi概述  
  
引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 
  
vi区段删除步骤： 
1. 在末行模式下使用:set nu显示行号 
非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
    
                                
    • 
                                
  • 清除tomcat缓存的方法总结
                                    dashuaifu
tomcat缓存
                                    
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 
出现这种现象的原因主要是tomcat缓存的原因。 
解决办法如下: 
在jsp文件头加上 
<meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
    
                                
    • 
                                
  • 不要盲目的在项目中使用LESS CSS
                                    dcj3sjt126com
Webless
                                    
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 
　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 
　　比如它的引用功能    
?        
.rounded_corners{   
    
    
                                
    • 
                                
  • [入门]更上一层楼
                                    dcj3sjt126com
PHPyii2
                                    
    更上一层楼 
通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 
本章将介绍一些有助于更好使用 Yii 的资源： 

    
                                
    • 
                                
  • Apache HttpClient使用详解
                                    eksliang
httpclienthttp协议
                                    
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
    
                                
    • 
                                
  • zxing二维码扫描功能
                                    gundumw100
androidzxing
                                    
    经常要用到二维码扫描功能 
现给出示例代码 
 
 

import com.google.zxing.WriterException;
import com.zxing.activity.CaptureActivity;
import com.zxing.encoding.EncodingHandler;

import android.app.Activity;
import an
    
                                
    • 
                                
  • 纯HTML+CSS带说明的黄色导航菜单
                                    ini
htmlWebhtml5csshovertree
                                    
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航 
  
在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： 
  
<!DOCTYPE html >
<html >
<head>
<title>HoverTree
    
                                
    • 
                                
  • fastjson初始化对性能的影响
                                    kane_xie
fastjson序列化
                                    
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。 
  
网上的说法： 
   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。 

    
                                
    • 
                                
  • 基于Mybatis封装的增删改查实现通用自动化sql
                                    mengqingyu
DAO
                                    
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 
2.支持自定义注解包括主键生成、列重复验证、列名、表名等 
3.支持批量插入、批量更新、批量删除 
 
 
<bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
    
                                
    • 
                                
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等)
                                    qifeifei
javascript js
                                    
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。   /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/          
funct
    
                                
    • 
                                
  • java 计时器应用
                                    tangqi609567707
javatimer
                                    
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int 
    
                                
    • 
                                
  • erlang输出调用栈信息
                                    wudixiaotie
erlang
                                    
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 
也可以用这个函数：erlang:get_s
    
                                
    •