aguangs
aguangs

Java泛型 总结

Java泛型是 jdk5.0 以后的版本才有的特性，也是 Sun 公司将 JDK1.5. 更名为 JDK5.0 的一个重要原因，因为历时 5 年的开发，是 JDK1.5 的功能更为健全和完善。
重用度高，安全系数高是Java 的追求的目标，而泛型的运用正是这一个内容的重要体现。在学习 Java 的过程当中 Java 泛型感觉有些晦涩难懂。起先以为自己的泛型学的还不错，可是在很长一段时间研究 Java 泛型毫无进展的情况下，开始有些崩溃了，于是硬着头皮看啊看，终于觉得有点感觉了，所以，今天在这里总结一些 Java 泛型的一些知识，希望以后自己以后开发生涯中能够用上今天的经验，写下来的原因确实很多，我不想在遇到同样的问题而束手无策，而且记忆了有时候并不是十分的可靠，所以我准备了 4 天的时间来写这篇总结。希望能详尽的表述出来，这个非常适用的机制，并方便以后读到这篇文章的读者，能够提出你们对泛型的一些看法，而不仅仅是一个“顶”字，我也相信你们有比这更好的学习泛型的经验和教训。

什么是泛型？ 泛型实质上是叫做泛型程序设计。运用泛型意味着编写的代码可以被很多类型不同的对象所 重用 。
为什么使用泛型？泛型是一种全新的程序设计手段，使用泛型的机制编写的程序代码，要比那些杂乱的使用Object 变量然后进行强制类型转化的代码明显的具有以下特点： 1 更好的安全性 2  更好的可读性。

了解这个两个问题才能从根本上了解泛型的好处，也才能真正的了解甚至熟练的运用Java 泛型。
先前受到c++ 模板的影响，所以一时还难以转过弯来。后来发现 C++ 的模板比 Java 的泛型做得好一些。一般情况下， Java 的特点是“懒加载”（源自 Hibernate 中的 lazy 这里只是为了说明），即运行时才动态的调用方法和生成新的类（除了 static 块和域）。所以 Java 并不知道你所指的泛型到底是什么类型。 Java 是一门纯面向对象的语言，所有的东西必须用类来表示（除了基本的数据类型外），所以类型可以泛化但是不能不让编译器始终不知道你所要泛化的东西是何种类型。因此有一定 C++ 基础的人千万要将模板和 Java 的泛型区分开来。
泛型最初的目的是希望类或者方法能够具备更加广泛的表达能力。了解泛型最主要的是要了解泛型的边界，以及它可以用来做什么，不能够做什么。我想这点是最重要的。
在此之前，我们用的最多的就是多态。所以经常性的让类来持有Object 类型的对象。
package  cn.ccsu.cooole.generics;
/**
  *   @author   CoolPrince
  *    这里讲的是一个类持有某一个类的对象本案例中用的是代理的机制
  *    即Holder_1类持有AObject的对象ao;
  *    这个通常情况下只能持有单个对象的类
  */
public   class  Holder_1 {
     private  AObject  ao  =  null ;
public  Holder_1(AObject ao) {
this . ao  = ao;
}
AObject  get(){ return   ao ; }
}
class  AObject{}
在举个例子（解释详见注释部分）：
package  cn.ccsu.cooole.generics;
/**
  *  
  *   @author   CoolPrince
  *   描述：此案例讲的是以前我们所用到过的动态绑定，此时只用了一个Holder_2的对象
  * 就实现了存储两个不同的类型的对象的功能。
  *   有些情况下我们主要运用泛型是将其运用到容器当中，告诉指定容器要持有什么样类型     * 的对象   由编译器来保证类型的正确性，举个简单的例子   List    list   =  
* new   ArrayList ();   此时前后的类型都为Integer才能保证数据的正确性.
  */
public   class  Holder_2 {
     private  Object  a   =  null ;
public  Holder_2(Object a ) {   this . a  = a; }
     public   void  set(Object a){ this . a  = a; }
     public   Object  get(){ return   a ; }
public   static   void  main(String[] args) {
Holder h =  new  Holder();
Holder_2 h2 =  new  Holder_2(h);
print ( "Test Holder result is ：" + h2.get());
String str =  new   String( "Name is \" String\"" );
h2.set(str);
print ( "Test String result is ：" + h2.get());

}
private   static   void  print(Object o){
System. out .println(o);
}
}
class  Holder{
public  String toString(){ return   "Name is \"Holder\"" ;}
}
以上便是使用Object 数据类型的来进行动态绑定，但是与其指定为 Object 还不如暂时不指定类型，然后决定具体使用何种类型。
下面就真正开始归纳泛型的基本用法和简要的总结：

package  cn.ccsu.cooole.generics;
/**
  *  
  *   @author   CoolPrince
  *   @param  
  *   泛型示例 主要是看简单泛型的基本语法格式
  */


 public   class  Holder_3 {

public  Holder_3(T a){ this . a  = a;}
public  T get(){ return   a ;}
public   void  set(T a){ this . a  = a;}


public   static   void  main(String[] args) {
Holder h =  new  Holder();
Holder_3   h3  =  new  Holder_3(h); 
System. out .println( h3 );
Holder hh =  h3 .get();
System. out .println(hh);
/* h3 .set("cooole"); //h3已经限定了其类型为Holder所以其他类型
h3 .set(new Integer(1));//比如String、Integer还是其他非Holder类   型
都是不允许传进来类型参数的
      */
}
private  T  a ;
}
    Java泛型的核心概念：告诉编译器像使用什么类型，然后编译器帮你处理一切细节。在使用泛型时只需要指定它们的名称和类型即可。

在通常的系统开发当中，我们一定会遇到经常使用一次方法调用，就能返回多个对象的情况。但是return 只能返回一个对象。因此解决办法就就是：创建一个对象用这个对象来持有想要返回的多个对象。当然在每次需要的时候就会专门创建这样的类。万一系统庞大，那么就会出现各种各样的问题，类就会过于庞大，同时也不能很好的体现 OOP 的思想。有一种好的设计思想就是利用泛型来一次性来解决问题，同时也可以利用泛型来在编译期间进行检查确保类型的安全，同时泛型也不是十全十美的会有一定的性能下降。
在学习泛型的时候要注意到元组的问题，实质上在通常的情况下可以这样来理解，元组就是类型的列表外加<> 。

泛型也可以运用到接口上这样的接口称为泛型接口。
public   interface   GenericsInterface {T method();} 是被允许的。
Java泛型“基本类型无法作为类型参数”的局限性已经是众所周知了，不过从 J2SE5
就具备了自动打包和解包的功能，所以基本的数据类型会也应该转换为对应的对象类型，再进行下一步的处理。
    
   泛型到现在的示例为止都是运用于整个类。但是从实际开发的过程中的规范或者说是好的习惯来看， 在能力的范围内，能用泛型方法代替泛型类的就应该尽量代替 。所以在这里就要讲到泛型方法的基本语法结构和一些必须非常熟悉的基本原理，这样才能站在更高的层次上来理解Java 泛型。
    先介绍语法：
package  cn.ccsu.cooole.generics;

/**
  *   @author   CoolPrince
  *   本案例的输出情况：
  *   SampleName:    String    |    Name:    java.lang.String
  *   SampleName:    Float    |    Name:    java.lang.Float
  *   SampleName:    Integer    |    Name:    java.lang.Integer
  *   SampleName:    Integer    |    Name:    java.lang.Integer
  *   从输出情况可以了解到两个重要的点：
  *   1:从i0和i1这两个地方我们就能很清晰地看到： Java泛型“基本类
  *      型无法作为类型参数”的局限性已经是众所周知了，不过从J2SE5就具
  *      备了自动打包和解包的功能，所以基本的数据类型会也应该转换为对应
  *      的对象类型，再进行下一步的处理。
  *    2:定义泛型方法只需要将泛型   参数列表   至于返回值之前
  */
public   class  GenericsMethods {
// 简单的示例输出对应的类名
public    void  method(T x) {
System. out .println( "SampleName:  "  +  x.getClass().getSimpleName()
+  "  |  Name:  "  + x.getClass().getName());
}

public   static   void  main(String[] args) {
GenericsMethods gm =  new  GenericsMethods();
String s =  "cooole" ;
int  i0 = 23;
Integer i1 = 13;
gm.method(s);
gm.method(10.F);
gm.method(i0);
gm.method(i1);
}

}


 值得特别注意的是： 如果static 方法需要使用泛型能力，就必须使其成为泛型方法。
当使用泛型类时，必须在创建对象的时候指定参数的值，而使用泛型方法时，通常不必指明参数的类型，因为编译器有个功能叫做：类型参数推断，此时编译器会为我们找出具体的类型。
     类型参数推断举例：
package  cn.ccsu.cooole.generics;

import  java.util.ArrayList;
import  java.util.HashMap;
import  java.util.LinkedList;
import  java.util.List;
import  java.util.Map;

/**
  *   @since   2009 - 7
  *   @author   CoolPrince
  *   @describe :
  *   该示例展示的是类型参数推断的一个简单的示例
  *   以及泛化方法的基本形式
  *   泛型方法使得该方法能够独立于类而产生变化，先辈给的一个经验就是：
  *   无论何时何地，只要你能做到的，就应该使用泛型的方法。也就是说能够将
  *   用泛型方法取代整个类的就应该使用泛型方法。这样做会使得事情更加清晰明了。
  *   另外值得注意的是：对于一个static的方法而言，无法访问泛型类的类型参数，
  *   所以如果static方法需要使用的能力，就必须使其成为泛型方法。
  *   就类型参数推断而言，那这个例子来讲，假设用户不知道GuessParaType中的方法
  *   或者说是隐含的功能，花的时间也没有减少。工作效率也没有得到提升
  *  
  *   需要特别特别注意的是：   类型推断只对赋值操作有效，其他时候并不起作用
  *   （比如作为参数传递给方法）。   所以function(GuessParaType.list())
  *   的用法编译时候无法获得通过。  
  *   如果是定义在该方法类的内部就需要使用this而静态方法则需要添加类名。
  */
public   class  GuessParaType {
public   static  Map  map(){
return   new  HashMap();
}
public   static  List list(){
return   new  ArrayList();
}
public   static  LinkedList linkedList(){
return   new  LinkedList();
}
public   static   void  function(List s){
System. out .println(s.getClass());
}
public   static   void  main(String[] args) {
@SuppressWarnings ( "unused" )
Map>  sls = GuessParaType. map ();
@SuppressWarnings ( "unused" )
List  l = GuessParaType. list ();
@SuppressWarnings ( "unused" )
LinkedList  ll = GuessParaType. linkedList ();
System. out .println(sls.getClass());
//function(GuessParaType.list());//此中用法不能用上面有说明
function (GuessParaType. list ()); //显示的类型说明
}

}
class  Holder_T  extends  Holder{}
     
和c++ 一样 Java 也具有可变参数列表：
package  cn.ccsu.cooole.generics;

import  java.util.ArrayList;
import  java.util.List;

/**
  *  
  *   @author   CoolPrince
  *   @描述   ：
  *   可变参数的泛型
     *   输出：
  *   [,   a,   b,   c,   d,   e,   f,   g,   h,   j,   k,   l,   m,   n,   o,   p,   q,   r,   s,   t,   u,   * v,   w,   x,   y,   z]
  */
public   class  GenericVarargs {

    public   static    List  makeList(T ...args){
   List t =  new  ArrayList();
    for (T item : args )
   {
   t.add(item);
   }
    return  t;
   }
public   static   void  main(String[] args) {

     List  list =  makeList ( "abcdefghjklmnopqrstuvwxyz" .split( "" ));
     System. out .println(list);
}

}
    
泛型运用于接口当中，只要泛型方法在参数声明为接口，都可以用到该接口的泛型实现的类的对象。方法的泛型在运用于接口的同时也可以运用到内部类当中来，甚至是匿名的类当中。比如一个非常经典的例子银行出纳员服务的问题（这是一个典型的泛型匿名类）：
return   new  Generator(){

public  Teller next() {
return   new  Teller();
}
};


 "好你个擦除，尽然让我这番折腾。 "在学习泛型一章的时候，最感到晕的就是擦除，这个是 Java 泛型的难点，也是泛型的重点的重点。竟然没弄清这个感觉就是学习 Java 遇到了一个大大的障碍。学这个的时候很晕，可以这样说吧，以前很少见到这种情况，主要是没有什么实践经验，这个内容很抽象，初一看，看不出什么名堂，但是硬着头皮学完了这个泛型，就可以说才真正的开始了解（我的实战项目很少，到目前为止觉得自己连菜鸟还不算，也就是一个还为成鸟的蛋，所以不敢大言熟练）。 " 好你个擦除！ " 。
首先擦除初一看很神秘，在一看的确很神秘，作死的看还是能解开她的一层神秘的面纱。
探秘擦除：
1：了解先决条件。什么是擦除？在使用泛型的这个场景的时候，任何具体的类型信息都无法看到，而你唯一知道的就是你在使用一个对象。这个是我个人的理解，可以想象一下，为什么叫擦除。从这问题出发，我个人觉得，就是这个 T 会被别的类型反复的覆盖，主要原因是 Java 运行的是 .class  字节码文件。而且又是一门纯面向对象的语言。因而会产生引用的现象，然而有些时候我们只需要运用到这个通用的方法（只是参数是不定的可以被反复运用），在同一个方法中的同一个参数列表的位置，每执行一次对其后续的传入对象的影响，每个对象的引用传进来时也不受先前的对象的引用的影响，所以就把参数列表的参数进行一次擦除。而在这个过程当中参数列表中的参数只是占了个符号进行标识。（这个是我个人的理解，术语还欠专业，只是为了讲明白这个意思）。
2：分析需求。为什么要用擦除？擦除的目的实质上时很简单了，从 JDK1.4 到 JDK1.5  的版本内容飞跃， Sun 公司历时 5 年将类库和虚拟机进行完善的这个角度上来分析，也可以从将 JDK1.5 改名为 JDK5.0 。或者从微软的 windows 操作系统来对比。就不难看出，擦除的最初目的就是为了 向后兼容 。因为此前也开发了不少产品，擦除的目的就是让泛型和非泛型进行结合。而擦除的机制使得先后迁移或者说是兼容成为可能，到目前为止也是最好的一种解决方案，以后的话或许还是最好的，但是就不敢说绝对最好了，毕竟技术还在前进。
3：分析优缺点缺点。擦除有哪些好的理由让它存在比成为设计类库的一个重要机制？还有擦除有哪些实际的问题？先回答第一个：擦除的优点上面 2 有讲到，主要从非泛化到泛化的转变过程，以及在不破坏现有的类库的情况下，将泛型融入到 Java 里边来。擦除使得现有的非泛化的客户端代码能在不改变的情况下继续使用，直到客户端重写了这些代码。例子很容易举，假设有家银行系统是 Java 的非泛型写的，但是它系统又要运行，对于银行的客户或者其他不同权限的系统使用者来讲，要不改变原来的东西，但是在升级的时候将代码重写时就适当运用泛型进行一个过渡。再是第二个问题：擦除的代价也是显而易见的，泛型不能显示的运用于运行时的类型当中。因为此时所有的关于参数类型的信息已经丢失。
讲到这先看个具体示例：验证擦除后的类型信息的获取。
  /**
  *   @author   CoolPrince
  *   @since   2009 - 7
  *   @描述   ：擦除的神秘之处
  *   output:~
  *   c1   =    class   java.util.ArrayList
  *   c2   =    class   java.util.ArrayList
  *   c1==   c2?true
  *   class   java.util.ArrayList
  *   :~
  *   形式可以是：Class   c2   =   new   ArrayList ().getClass();
  *   虽然可以申明为：ArrayList.class
  *   但是不能为   Class   c2   =   new   ArrayList ().class;
  *   也不能为ArrayList .class();
  */
public   class  ErasedTypeEquivalence {

/**  
  *   @param   args
  */
public   static   void  main(String[] args) {
Class c1 =  new  ArrayList().getClass();
Class c2 =  new  ArrayList().getClass();
     print ( "c1 =  " + c1);
     print ( "c2 =  " + c2);
     print ( "c1== c2? " + (c1== c2));    
     print (ArrayList. class );
}

public   static   void  print(Object  o){
System. out .println(o);
}
}


 从上面的注释可以看到，c1 和 c2 的 class 都是 java.util.ArrayList ,所以关于参数 String 和 Integer 的类型信息已经丢失。

在c++ 模板当中会有这样的几句话：
template
{
    T  object;
     public  mothod(){object.f();}
};
在c++ 中只管定义，在调用的时候会自动检查 T 类型是否拥有 f() 方法如果没有就会发出异常。
而在Java 中不能支持这种形式，编译器报错。这个也是 c++ 在类型的参数化方面比 Java 强大的主要原因之一。
那么Java 中如何实现上述的 C++ 内容呢？具体请看代码及其注释。

package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince
  *   @param  
  *  
  *   在这个示例当中首先要告诉编译器T是什么类型，下面两句  
  *   FunMethodExtendsClass   fmec=   new   FunMethodExtendsClass();  
  *   new   HasFunMethod (fmec);
  *   其中传入参数fmec告诉编译器其传的是FunMethodExtendsClass
  *  
  *   如果将public   HasFunMethod(T   x){object   =   x;}去掉的话
  *   并且将构造器改为默认的，那么调用hf.testFun()编辑器不能检查到错误
  *   但是运行的时候就会有空指针异常(java.lang.NullPointerException)
  */
public   class  HasFunMethod {

private  T  object ;

public   void  testFun() {
object .fun();
}

public  HasFunMethod(T x) {
object  = x;
}

public   static   void  main(String[] args) {
FunMethodExtendsClass fmec =  new  FunMethodExtendsClass();
HasFunMethod hf = 
new  HasFunMethod(fmec);
hf.testFun();

fmec.fun();
}
}

class  FunMethodClass {
public   void  fun() {
System. out .println( "fun()" );
}
}

class  FunMethodExtendsClass  extends  FunMethodClass {}

     验证泛型数据的擦除后类型的一致性：
package  cn.ccsu.cooole.generics;

import  java.util.ArrayList;
import  java.util.List;

/**
  *   @author   CoolPrince
  *  
  *   @param  
  *  
  *   将对象传入List   尽管编译器无法知道有关create()中的T的任何类型的信息，
  *   但是它仍然可以确保   *   你放位置到list的对象具有T类型，使其适合
  *   ArrayList ,因此,即使擦除在方法或者类的内部移除了有关实际的类型信息，
  *   编译器仍然可以确保在方法或者类中   使用的类型的内部一致性。
  *  
  */
public   class  FillList {

public  List create(T t,  int  n) {
List list =  new  ArrayList();
for  ( int  i = 0; i < n; i++) {
list.add(t);
}
return  list;
}

public   static   void  main(String[] args) {
FillList stringMake =  new  FillList();

List list = stringMake.create( "cooole" , 4);
System. out .println(list);
FillList make =  new  FillList();
List list1 = make.create( new  Make(), 3);
System. out .println(list1);
}

}

class  Make {
@Override
public  String toString() {
return   "make" ;
}
}


 既然擦除有类型信息丢失的现象，我们是否有补救措施？答案当然是有。
下面是通过引入类型标签解决判定是否可以动态的实例化类的对象。
package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince
  *  
  *   输出结果：
  *   true
  *   true
  *   false
  *   true
  *  
  *   描述：泛型因为擦除的原因其类型信息就已经擦除了，然而在引入类型标签的话，
  *   就可以转而使用动态的isInstance()来进行类型的实例化的判断。编译器将确保
  *   类型标签可以匹配泛型参数。
  *
  */
public   class  ClassTypeCapture {

Class  kind ;
public  ClassTypeCapture(Class kind){
this . kind  = kind;
}
public   boolean  f(Object o){
return   kind .isInstance(o);
}
public   static   void  main(String[] args) {
ClassTypeCapture  ctc1 =  new  ClassTypeCapture(Building. class );
System. out .println(ctc1.f( new  Building()));
System. out .println(ctc1.f( new  House()));

ClassTypeCapture ctc2 =  new   ClassTypeCapture(House. class );
System. out .println(ctc2.f( new  Building()));
System. out .println(ctc2.f( new  House()));

}

}
class  Building{}
class  House  extends  Building{} 
     
    既然判定对象的是否可以实例化的问题已经解决下面的问题就是实例化对象的操作。
package  cn.ccsu.cooole.generics;

public   class  ClassInstantiateGenericType {
public  ClassInstantiateGenericType() {
}

public   static   void  main(String[] args) {
@SuppressWarnings ( "unused" )
ClassAsFactory fe =  new  ClassAsFactory(
Employee. class );
System. out
.println( "new ClassAsFactory(Employee.class)   is Succeeded" );
try  {
@SuppressWarnings ( "unused" )
ClassAsFactory fi =  new  ClassAsFactory(
Integer. class );
}  catch  (Exception e) {
System. out
.println( "new ClassAsFactory(Integer.class)  is failed" );
}
}
}

class  ClassAsFactory {
T  x ;
public  ClassAsFactory(Class kind) {
try  {
kind.newInstance();
}  catch  (Exception e) {
throw   new  RuntimeException(e);
}
}
}

class  Employee {
}

这个示例运解决的是一个Java 创建类型实例的一个运用例子，这个是工厂模式。
而工厂的对象就是Class 对象，所以使用类型标签是十分合理的，而此时只需要将 new Intstance()来实例化并创建这个类型的新对象。
Java泛型的参数要求所传递类型的构造器是公有默认的构造器。而上面示例 Integer 类没有默认的构造器。 会报J ava.lang.InstantiationException 的错误。  而这个错误并不是在编译期间捕获的所以不建议使用这种方式，下面是这个示例的改良。

   package  cn.ccsu.cooole.generics;
/**
  *  
  *   @author   CoolPrince
  *   描述：显示工厂的方法解决Java进行泛型类的实例化的问题。
  *  
  *   主要是限定其类型使得只能接受实现了这个工厂的类
  *   此时已经获得了编译期间的检查。所以也是比较稳定和安全的
  */


public   class  FactoryConstaint {
public   static   void  main(String[] args) {
new   Foo2( new  IntegerFactory());
new  Foo2< Widget >( new   Widget .Factory());
}

}
interface  FactoryInterface{
T create();
}
class  Foo2{
@SuppressWarnings ( "unused" )
private  T  x ;
public  > Foo2(F factory){
x  = factory.create();
}
}
class  IntegerFactory  implements  FactoryInterface{
public  Integer create() {
return   new  Integer(10);
}

}
class   Widget {
public   static   class  Factory  implements  FactoryInterface< Widget >{
public   Widget  create() {
return   new   Widget ();
}

}
}

   既然显示工厂可以解决此问题，那么还有其他的解决途径没有？模板方法设计模式。
package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince
  *   模板模式解决Java泛型类额实例化问题
  *   通过这种方式可以获取类型的信息
  */
public   class  CreatGenerics {


public   static   void  main(String[] args) {
Createor c =  new  Createor();
c.f();
}
}
abstract   class  GenericWithCreate{
final  T  elements ;
GenericWithCreate(){ elements  = create();
}
abstract  T create(); 
}
class  ClassX{}
class  Createor  extends  GenericWithCreate{
@Override
ClassX create() {
return   new  ClassX();
}
public   void  f(){
System. out .println( elements . getClass ().getSimpleName());
}

}


 泛型在数组中的运用: 一般的解决方案都是在任何想要创建泛型数组的地方都用 ArrayLis 进行替代。这样既能获得数组的行为也能获得由编译器提供的编译器类型的安全。
  直接创建数组不会发出任何警告。却也永远无法创建这个确切的数据类型数组，直接进行转化就会抛出异常。
 有一种方式。也是唯一的一中方式就是：利创建一个被擦除类型的新数组。然后转型。
具体示例见下文：
private  T[]  array ;
public  GenericsArray( int   size ){
array  = (T[])  new  Object[size];
}
这种形式是不行的尽管它在初学者看来和直观，当其对返回值进行转型的时候就会有一个叫做ClassCastException; 此时实际运行的是 Object[];
因为有了擦除，数组的运行时类型就只能是Object[], 如果我们立即将其转型为 T[], 那么编译期间的实际类型就会丢失，而编译器可能会错过某些潜在的错误检查。所以最好的方式是在集合内部使用 Object[], 然后当你使用数组元素的时候，添加一个 T 的转型。
package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince
  *
  *   @param  
  *  
  *   输出：   [Ljava.lang.Object;@de6ced
  *   所以还是存在类型的丢失问题，当调用这个gai.getArray()的其他方法的时候
  *   编译器也会报告异常。
  */


public   class  GenericsArray2 {
private  Object[]  array ;

@SuppressWarnings ( "unchecked" )
public  GenericsArray2( int  size){
array  = (T[])  new  Object[size];
}
@SuppressWarnings ( "unchecked" )
public  T[] getArray(){
return  (T[]) array ;
}
public   void  put( int  index, T  item){
array [index]  = item;
}
public   static   void  main(String[] args) {
GenericsArray2 gai =  new  GenericsArray2(10);
for ( int  i = 0;i<10;i++){
gai.put(i, i);
}
    System. out .println(gai.getArray());

}

}

   难道真的没有其他办法来解决这一难题。
先看看下面的反射再说：
    package  cn.ccsu.cooole.generics;

import  java.lang.reflect.*;

/**
  *   @author   CoolPrince
  *
  *   @param  
  *  
  *   输出结果：
  *    class   [Ljava.lang.Integer;
  *    0   1   2   3   4   5   6   7   8   9
  *   
  *    类型标记Class 被传送到构造器中，以便恢复，使得我们可以创建需要的实际的类型的数组
  *    尽管@SuppressWarnings("unchecked")压制警告，一旦获得实际的类型就可以进行返回
  *   
  */  
public   class  GenerArrayWithTypeToken {
@SuppressWarnings ( "unused" )
private  T[]  array ;
@SuppressWarnings ( "unchecked" )
public  GenerArrayWithTypeToken(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[] getArray(){
return  (T[]) array ;
}
public   static   void  main(String[] args) {
GenerArrayWithTypeToken gawti =  new   GenerArrayWithTypeToken(
Integer. class , 10);
for ( int  i = 0;i<10;i++){
gawti.put(i, i);
}
Integer [] ia  = gawti.getArray();
System. out .println( ia .getClass());
for ( int  i = 0;i<10;i++){
   System. out .print( " " +  ia [i]);
}        
}
}

既然Java 的泛型可以如此神通广大，我们有什么方法对其进行一定的限制提高它的性能呢 ? 答案便是边界！
package  cn.ccsu.cooole.generics;

import  java.awt.Color;

/**
  *   @author   CoolPrince
  *
  *   @param  
  *  
  *这个事例主要是分析边界及其继承关系的相关理论。
  *   边界实质上就是在泛型上设置限制条件。这个限制强制了所要使用的类型范围
  *   但是一个潜在的好处就是可以按照自己定义的边界来调用方法。比如说：
  *   int   weigth(){
  * return   item.weigth();
  * }
  *在此时已经保障了inem.weigth()的存在性。   因为这条语句
  *
  *要求必须实现Weight接口
  *这个地方也有个小的策略，就是先将类放到extends的后面然后就是接口口，尽量将方
* 法多的，
  *或者是子类放到靠前面一些这样就会有一定的效率提高，其次限制时没有implements
 * 而是将
  *extends代替，这个是Java的设计者考虑到extends能够更好的表意所以统一采用这种 * 形式
  *此时的extends和平时的用法是完全不同的。
  */
public   class  GenericInheritBaseBounds {
public   static   void  main(String[] args) {
@SuppressWarnings ( "unused" )
Solid sb =  new  Solid( new  Bounded());
System. out .println(sb.getX());
System. out .println(sb. weigth ());
System. out .println(sb.getItem().getClass());
}
}
interface  HasColor{java.awt.Color  getColor();}
interface  Weigth{ int  weigth();}
class  HoldItem{
T  item ;
HoldItem(T item){ this . item  = item;}
T getItem(){ return   item ;}
}
class  Dimension{ public   int   x , y , z ;}

class  Colored  extends  HoldItem{
Colored(T item){ super (item);}
}
class  ColorDimension  extends  Colored{
ColorDimension(T item) { super (item);}
int  getX(){ return   item . x ;}
}
class  Solid  extends  ColorDimension{
Solid(T item) { super (item);}
int   weigth (){
return   item .weigth();
}
}
class  Bounded  extends  Dimension  implements   HasColor,Weigth{

public  Color getColor() {

return  Color. black ;
}
public   int  weigth() {
return  10;
}
}


泛型通配符：
泛型一个主要目标是将运行时可以发现插入不正确的数据类型的错误信息检测移入到编译期。
下面的几个示例就是讨论通配符的相关的问题：主要是总结那些情况下可以用，那些情况下有缺陷，哪些情况下可以进行优化。
首先简述数组的一种特殊的行为：可以向导出类型的数组赋予基类型数组引用。假设有这样一种情况：基类蔬果(Fruit), 其有两个子类苹果（ Apple ）、桔子（ Orange ） , 另外又有苹果类又有一个子类 --- 李子苹果（ PlumApple ）的杂交苹果。
Fruit []  fruit  =  new  Apple[10]; 那么 fruit[0] =  new  Apple();
fruit[0] =  new  PlumApple(); 都是合法的因为他们都是Apple 的子类，然而 new   Fruit (),或者是非苹果的子类都会报告数组存储错误的异常。为什么会有这种情况的出现呢？虽然有个 Fruit []  fruit 数组的引用，在编译期间就算你new Orange() 也不会报告异常，但是在运行期间 Java 还是会根据数组的基本机制将其处理成 Apple[], 因此在数组中放入异构型的数组时就会有异常。数组有一个重大的好处就是他可以保留有关他们的包含的对象的类型的信息规则。一般这样说，数组对其持有的对象是有意识，因此在编译期间一定要做检查，否则就会造成滥用的情况的发生。那么用 List f =  new   ArrayList (); 来可以吗？不行两个泛化的参数必须一致， List 的对象将持有所有 Fruit 的所有的Fruit 对象也包括 Apple 。但是这里的情况 List 的对象和 List< Apple > 的对象时不同的，这个地方和多态是有区别的，从多态的单个来讲 Fruit f = new Apple(); 是可以的允许的而且此时持有的也是 Apple 的对象，加了个 List 容器就不同了。为什么这样讲呢？理论上时这样讲的：这里是讲的容器的类型而不是容器所持有的类型。也就是上面那句话所描述的那样。
现在假设有另一种情况假设缴入了边界的限制又会怎样呢？形式如 List = new ArrayList();又能行吗？你先自己编一下。答案告诉我们这种方式是行不通的。此时定义为 new ArrayList() ，如果可以的话那么  new ArrayList() 也是安全可行的，但是这样的话岂不是很混乱。在不知道 List 持有什么样的类型时候是不能向其中添加任何对象的（除了 null ）。所以必须明确 List 持有对象的类型。那么这样的形式岂不是毫无用处。实际上也不补完全是这样，如果你调用 Fruit 类的方法还是不会报异常，也是安全的，因为此时在 List 持有的对象中至少具有 Fruit 的类型，此时编译器是允许这样做的。就拿 List 来说，编译器并不知道是Fruit 的具体的哪个类。 ?  extends  Fruit 意味着可以是任何类型的事物，同时编译器又无法验证它的安全性。这个地方还是有严格限制的。
说白了泛型要知道具体的持有的对象的参数，至少也要通过反射来告诉编译器是个什么东东，在泛化的过程中利用类型标签来实现工厂模式，模板模式来解决泛型是非常有用的。

既然有继承的统配符是否有超类的通配符来进行类型的限定？
超类的通配符的语法, 是上界，而超类的通配符就是我们所说的下界。另外还有个叫无界 , 下面也将讲到。
package  cn.ccsu.cooole.generics;

import  java.util.Arrays;
import  java.util.List;

/**
  *  
  *   @author   CoolPrince
  *
  *   输出：
  *   fun1()   f.getClass():   class   cn.ccsu.cooole.generics.Apple
  *   fun1()   a.getClass():   class   cn.ccsu.cooole.generics.Apple
  *   fun2()   f.getClass():   class   cn.ccsu.cooole.generics.Fruit
  *   fun3()   f.getClass():   class   cn.ccsu.cooole.generics.Fruit
  *   fun3()   a.getClass():class   cn.ccsu.cooole.generics.Apple
  *  
  *   先从输出来对其原理进行深层次分析：
  *   fun1()中调用的readExact();参数已经进行类限制，并没有进行通配
  *   此时编译编译器就会根据实际的类型进行调用和传参，只是此时在编译期间
  *   进行强制的类型检查，避免了许多的错误，而不会出现可以是任何事物的
  *   情况而使得编译器不知道如何处理。
  *   在fun2()中由于Reader    fruitReader   =   new   Reader ();
  *   的限制而无法将Apple   作为类型进行检查，此时的注释部分是不能运行的（编译期
  *   间就有错误）。
  *   在fun3()中则运用了？extends进行通配   此时只要是Fruit的子类就可以传进来只
  *   要将其返回值为Fruit就行，其实此时已经是Apple的引用。故而有上述的显示结果。
  */
public   class  GenericReading {

static   class  CovariantReader {
T readCovariant(List list) {
return  list.get(0);
}
}

static   class  Reader {
T readExact(List list) {
return  list.get(0);
}
}

static  List  apples  = Arrays. asList ( new  Apple());

static  List  fruits  = Arrays. asList ( new  Fruit());

static   void  fun1() {
@SuppressWarnings ( "unused" )
Apple a =  readExact ( apples );
Fruit f =  readExact ( fruits );
f =  readExact ( apples );
System. out .println( "fun1() f.getClass(): "  + f.getClass());
System. out .println( "fun1() a.getClass(): "  + a.getClass());
}

static   void  fun2() {
Reader fruitReader =  new  Reader();
Fruit f = fruitReader.readExact( fruits );
System. out .println( "fun2() f.getClass(): "  + f.getClass());
// Fruit a = fruitReader.readExact(apples);
}

static   void  fun3() {
CovariantReader crf =  new  CovariantReader();
Fruit f = crf.readCovariant( fruits );
Fruit a = crf.readCovariant( apples );
System. out .println( "fun3() f.getClass(): "  + f.getClass());
System. out .println( "fun3() a.getClass():"  + a.getClass());
}

public   static   void  main(String[] args) {
fun1 ();
System. out .println();
fun2 ();
System. out .println();
fun3 ();
}

static  T readExact(List list) {
return  list.get(0);
}

}


可以笨认为是一种装饰，但是它仍然具有一定的实际价值，在实际看来： " 我想用Java 的泛型编写这段代码 , 我这里并不是要用原生类型，但是在当前的情况下泛型可以持有任何类型。 "
     泛型通配符，以List 为例 List 与 List 是有区别的， List 实际上时表示 " 持有任何 Object 类型的原生 List", 而 List 表示 " 具有某种特定类型的非原生List 只是我们不知道那种类型是什么。 "
    当泛型过于受限的时候就应该考虑通配符，这主要取决于泛型的参数中返回类型确定的返回值。
因此运用确切类型来替代通配符的好处是：可以用泛型的参数来处理更多的事情，但是使用通配符使得你必须接受范围更加宽的参数化类型作为参数。
那么什么时候使用通配符比使用原生的更好或者说是更加需要。那就是我们通常所说的捕获转换这个还真的是非常需要。
捕获转化的定义: 如果向一个使用 的方法传递原生类型，那么是对于编译器来说，可能会推断出实际的类型参数 ( 运用反射就可以得到 ) ，使得这个方法可以回转并调用另一个使用这个确切类型的方法（事实上泛型参数擦除的是第一边界，这个情况是一定的）。
下面这个例子足以对其进行说明( 详见上面一段话结合程序进行理解，也对注释特别留意，并慢慢体会 ) 。
package  cn.ccsu.cooole.generics;
/**
  *  
  *   @author   CoolPrince
  *   @param  
  *   泛型示例  
  */
public   class  Holder_3 {

public  Holder_3(T a){ this . a  = a;}
public  T get(){ return   a ;}
public   void  set(T a){ this . a  = a;}
public  Holder_3(){}

public   static   void  main(String[] args) {
Holder h =  new  Holder();
Holder_3  h3 =  new  Holder_3(h); 
System. out .println(h3);
Holder hh = h3.get();
System. out .println(hh);
/*h3.set("cooole"); //h3已经限定了其类型为Holder所以其他类型
  h3.set(new Integer(1));//比如StringInteger还是其他非Holder类   型都是不允许传进来类型参数的
      */
}
private  T  a ;
}


package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince
  *   捕获转化举例：
  *   先看输出结果：
  *   Integer
  *Integer
  *Object
  *Double
  *   再看   main方法：
  *   Holder_3   h3t   =   new   Holder_3 (23);
  *   定义一个Holder_3   h3t   类型参数为Integer
  *   此时调用方法method1();就会输出类型名：Integer
  *   调用方法menthod2()的时候里面传进来方法method1   的参数
  *   此时就会被擦除从而带入到method2中，故而会有上面的结果。
  *   这个过程通过参数的传递来进行捕获转化。此时的通配符就派上了用场
  *  
  */
public   class  CaptureConversion {
static     void  method1(Holder_3 holder){
T t = holder.get();
System. out .println(t.getClass().getSimpleName());
}
static   void  method2(Holder_3 holder){
method1 (holder);
}

@SuppressWarnings ( "unchecked" )
public   static   void  main(String[] args) {
Holder_3 h3t =  new  Holder_3(23);
method1 (h3t);
method2 (h3t);
Holder_3 h3t2 =  new  Holder_3();
h3t2.set( new  Object());
method2 (h3t2);

Holder_3 wildcard =  new  Holder_3(23.0);
method2 (wildcard);
}
}

泛型没有消除对对象转型的需要。
package  cn.ccsu.cooole.generics;

public   class  FixedStack {

private   int   index   = 0;
private  Object[]  storage ;
public  FixedStack( int  size){ 
storage  =  new  Object[size];
}
public   void  push(T item){
storage [ index ] = item;
index ++;
}
@SuppressWarnings ( "unchecked" )
public  T pop(){
return  (T)  storage [ index --];
}
public   static   void  main(String[] args) {
FixedStack  ii =  new  FixedStack(11);
for ( int  i = 1;i<=10;i++){
ii.push(2*i);
}
 ii.pop();
System. out .println(ii.pop().getClass().getSimpleName());
}
}

泛型没有消除对对象转型的需要，从pop ()中的强制转化，没转化前还是 Object 。

    实现参数化接口：
interface  Payable{}
class  Emplyee  implements  Payable{}
c lass   Hourly   extends  Emplyee  implements  Payable< Hourly >{}
在这个实例当中最后一条语句由于擦除的原因，这两个变体会成为相同的借口而产生冲突。如果将 Payable 的参数类型移除就能够通过编译。
对于泛型重载，由于擦除的缘故，重载类型的方法将产生类型相同的签名，当被擦除的参数不能产生唯一的参数列表时，必须提供有明显区别的方法名。
Java自限定类型：
package  cn.ccsu.cooole.generics;


/**
  *  
  *   @author   CoolPrince
  *   自限定的基本语法如同：
  *   class   SelfBounded>
  *   自限定限制只能强制作用于继承关系，如果使用自限定就必须了解这个
  *   类所用的类型参数将与使用这个参数的类具有相同的基类型。
  *  
  */
public   class  SelfBounding {

public   static   void  main(String[] args) {
A a =  new  A();
System. out .println(a.getClass());
a.set( new  A());
System. out .println(a.getClass());
a = a.set( new  A()).get();
System. out .println(a.getClass());
B b =  new  B(); 
System. out .println(b.getClass());
C c =  new  C();
c = c.setAndGet( new  C());
System. out .println(c.getClass());
}
}
class  SelfBounded>{
T  element  ;
SelfBounded set(T  arg ){
element  =  arg ;
return   this ;
}
T get(){ return   element ;}
}
class  A  extends  SelfBounded{}
class  B  extends  SelfBounded{}
class  C  extends  SelfBounded{
C setAndGet(C arg){ 
set(arg);
return  get();
}
}
    其实Java 的自限定类型的价值在于他们可以产生协变参数类型——方法参数类型会随着子类而进行变化（类型雨来与严格也就是擦除第一边界所引起的），自限定类型还可以产生于基类类型相同的返回类型。
   
package  cn.ccsu.cooole.generics;

/**
  *  
  *   @author   CoolPrince   输出结果：  
  *   cn.ccsu.cooole.generics.ImplmentsGetter@61de33
  *   cn.ccsu.cooole.generics.ImplmentsGetter@61de33
  *  
  *   cn.ccsu.cooole.generics.ImplmentsGetter_1@ca0b6
  *   cn.ccsu.cooole.generics.ImplmentsGetter_1@ca0b6
  *  
  *   此时从输出可以见到我们所谓的动态绑定的效果
  *   这个时候就可以看到参数协变的效果。
  *   和普通的继承一样了，不信得话可以讲类型数去掉后在去观察结果
  *   已经重载了方法get();
  */
public   class  GenericsAndReturnType {

public   static   void  main(String[] args) {
ImplmentsGetter ig =  new  ImplmentsGetter();
test (ig);
System. out .println();
ImplmentsGetter_1 ig1 =  new  ImplmentsGetter_1();
test (ig1);

}

static   void  test(Getter g) {
@SuppressWarnings ( "unused" )
Getter res = g.get();
System. out .println(res);
@SuppressWarnings ( "unused" )
GenericGetter gg = g.get();
System. out .println(gg);
}
}

interface  GenericGetter> {
T get();
}

interface  Getter  extends  GenericGetter {
}

class  ImplmentsGetter  implements   Getter  {

public  Getter  get () {
return   this ;
}
}

class  ImplmentsGetter_1  extends  ImplmentsGetter {
}


动态类型安全问题分析：
    受检查的容器在你试图插入类型不正确的数据时就会，抛出ClassCastExcption, 这与泛型之前的原生的容器形成了鲜明的对比，对于后者来说，当你将对象从容器中取出的时候才会通知你出现了问题，此时尽管你直到出现了问题但是你不知道问题在哪，如果使用受检查的容器就会在编译期间发现插入不良的对象。
 
既然泛型在编译期间的安全问题自行可以解决，那么在运行期间的异常又该如何处置呢？
可以采用这种方式：
 Class TestClass{
   public  void f() throws E{}
}
当然参数E 也可以是其他自定义继承非 Throwable 的类。
其他的和上面的基本相同。

   在擦除忘记其比本类型，所以泛型类不能直接继承自一个泛型的参数。
故而产生了另外一种解决方案，说白了就是用类来继承混合接口的实现，来实现混型的机制。
例子很简单，只是代码稍微有些长：
  package  cn.ccsu.cooole.generics;

import  java.util.Date;
/**
  *   @author   CoolPrince
  */
public   class  Mixins {

public   static   void  main(String[] args) {
Minin minin1 =  new  Minin(), minin2  =  new  Minin();
minin1.set( "测试 String 1" );
minin2 .set( "测试 String 2" );
System. out .println(minin1.get()+ " " +minin1.getSerialNumber()+minin1.getStamped());
System. out .println( minin2 .get()+ " " + minin2 .getSerialNumber()+ minin2 .getStamped());

}

}
interface  TimeStamped{ public   long  getStamped();}
interface  SerialNumbered{ public   long  getSerialNumber();}
interface  Basic{
public  String get();
public   void  set(String val);
}
class  TimeStampImp  implements  TimeStamped{

private   final   long   timeStamp ;
TimeStampImp(){
timeStamp  =   new  Date().getTime();
}
public   long  getStamped() {
return   timeStamp ;
}
}
class  BasicImp  implements  Basic{
   
String  value ;
public  String get() {
return   value ;
}
public   void  set(String val) {
value  = val;
}
}
class  SerialNumberedImp  implements  SerialNumbered{

private   static   long   counter = 1;
public   long  getSerialNumber() {
return   SerialNumber ;
}
private   final   long   SerialNumber  =  counter ++;

}
/**
  *  
  *   @author   CoolPrince
  *   典型的混型代理
  */
class  Minin  extends  BasicImp  implements  TimeStamped,SerialNumbered{

private  TimeStamped  timeStamp  =  new  TimeStampImp(); 
private  SerialNumberedImp  serialNumberedImp  =  new  SerialNumberedImp();
public   long  getStamped() {
return   timeStamp .getStamped();
}
public   long  getSerialNumber() {
return   serialNumberedImp .getSerialNumber();
}

}

 似乎从上面的这个例子就好像与泛型搭不上边了，在这里先要特别注意泛型是数据类型的一个基本要素，下面介绍一下与泛型或者混型有关的几个基本的设计模式：
1：装饰器模式（这个模式在类库里用的非常多，不知你对装饰器有无了解，其中一个重要的库的主要思想就是装饰器模式，在尚学堂的视频里讲的那个管道就是装饰器模式的一种说法，我也是后来看源码才知道的），那就先不分析那些 Buffered 和 Data ，留到下篇文章讲 I/O 的时候来分析部分源码来讲解装饰器模式。
先看个简单的例子：
      package  cn.ccsu.cooole.generics.decorator;

import  java.util.Date;

/**
  *  
  *   @author   CoolPrince   这个就是一个典型的装饰器设计模式的运用  
  *            仔细看是不是一层套一层。
  *           装饰器模式是使用的分层对象来态透明的向单个对象中添加责任。装饰器指定  
  *           包装在最初的对象的周围所有的对象具有相同的接口。某些事物是可以装饰的
  *           可以通过将其他类包装在可装饰的对象的四周，来将其分层。所以无论对象是  
  *           否有装饰你都可以拥有一个可以向对象发送公共消息集。当然装饰类也可以
  *           添加新的方法，但是这也是受限的。   混型和装饰器模式及其类似但是装饰器
  *           并不需要装饰器的继承结构（运用代理）
  *  
  */
public   class  DecorationMode {
public   static   void  main(String[] args) {
TimeStamped t =  new  TimeStamped( new  Basic());
TimeStamped t2 =  new  TimeStamped( new  SerialNumbered( new  Basic()));
SerialNumbered s =  new  SerialNumbered( new  Basic());
SerialNumbered s2 =  new  SerialNumbered( new  TimeStamped( new  Basic()));
System. out .println(t);
System. out .println(t2.getStamp());
System. out .println(s.getSerialNumber());
System. out .println(s2);
}

}

/**
  *  
  *   @author   CoolPrince   基类型
  */
class  Basic {
private  String  value ;

public   void  set(String val) {
value  = val;
}

public  String get() {
return   value ;
}
}

/**
  *  
  *   @author   CoolPrince   注意   protected这个修饰符表示的是具有包以及继承层次的子类拥有访问权限
  *           这个地方Decrator拥有类Basic   属于代理
  */
class  Decrator  extends  Basic {
protected  Basic  basic ;

public  Decrator(Basic basic) {
this . basic  = basic;
}

public   void  set(String val) {
basic .set(val);
}

public  String get() {
return   basic .get();
}
}


/**
  *  
  *   @author   CoolPrince   必须拥有构造器   getStamp()是新添加的   这个地方TimeStamped拥有类Decrator   属于代理
  */
class  TimeStamped  extends  Decrator {
public  TimeStamped(Basic basic) {
super (basic);
time  =  new  Date().getTime();
}

public   long  getStamp() {
return   time ;
}

private   final   long   time ;
}

class  SerialNumbered  extends  Decrator {

public  SerialNumbered(Basic basic) {
super (basic);
}

private   static   long   counter  = 1;

public   long  getSerialNumber() {
return   SerialNumber ;
}

private   final   long   SerialNumber  =  counter ++;

}

Java  并不支持潜在的类型机制，所以看上去不是非常的泛化。在c++ 中即便是一个不知道的类型  T  也可以调用它的方法只不过在传入类型参数的时候会进行检查看是否具有该方法。而 Java 对这个并不支持。它主要还是通过实现接口来继承类来实现这个机制的功能。尽管 Java 缺乏潜在类型的机制，但是还是有多种补救的措施： 反射 。上面也讲过通过反射来进行类型标签。
第二个就是将一个方法运用于序列（略）
适配器模式举例：
package  cn.ccsu.cooole.generics;

import  java.util.*;

/**
  *  
  *   @author   CoolPrince
  *   适配器模式举例：
  *   运行结果：
  *   Adpter.num   =   0
  *   Adpter.num   =   1
  *   Adpter.num   =   2
  *   Adpter.num   =   3
  *   Adpter.num   =   4
  *   Adpter.num   =   5
  *   Adpter.num   =   6
  *   Adpter.num   =   7
  *   这个例子主要是通过Collection来进行适配
  *  
  */
public   class  AdapterMode1 {

public   static   void  main(String[] args) {
         List li =  new  ArrayList();
         Fill2. fill ( new  AddableCollectionnAddapter(li), AdpterTmp. class , 4);
         Fill2. fill (Adapter. collectionAdapter (li), AdpterTmp. class , 5);
          for (AdpterTmp i:li){
          System. out .println(i);
         }         
}

}
interface  Addable{ void  add(T t);}

class  Fill2{
public   static    void  fill(Addable addable,Class classToken, int  size){
for ( int  i = 0; itry  {
addable.add(classToken.newInstance());
}  catch  (Exception e) {
    throw   new  RuntimeException(e);
}
}
}
}
class  AddableCollectionnAddapter  implements  Addable{

private  Collection  c ;
AddableCollectionnAddapter(Collection c){
this . c  = c;
}
public   void  add(T t) {
c .add(t);
}
}
class  Adapter{
public   static    Addable  collectionAdapter(Collection c){
return   new  AddableCollectionnAddapter(c);
}
}
class  AdpterTmp{
static   int   counter  = 0; 
private   final   int   num  =  counter ++;
public  String toString(){
return   "Adpter.num = " +  num ;
}

}
这个例子描述了适配器创建了真正泛化的代码。

策略设计模式

package  cn.ccsu.cooole.generics;

import  java.math.BigDecimal;
import  java.math.BigInteger;
import  java.util.ArrayList;
import  java.util.Iterator;
import  java.util.*;
import  java.util.concurrent.atomic.AtomicLong;

 

/**
  *  
  *   @author   CoolPrince
  *   策略设计模式：
  *  
  */
public   class  StrategyModel {


public   static  T reduce(Iterable seq,Combiner combiner){
Iterator it = seq.iterator();
T result =  null ;
if (it.hasNext()){
result = it.next();
while (it.hasNext()){
result = combiner.combine(result, it.next());
}

}
return  result;
}
public   static  Collector forEach(Iterable seq, Collector func){
for (T t:seq){
func.function(t);
}
return  func;
}
public   static  List tansform(Iterable seq,UnaryFunction func){
List result =  new  ArrayList();
for (T t:seq){
result.add(func.function(t));
}
return  result;
}
public   static  List filter(Iterable seq,UnaryPredicate pred){
List result =  new  ArrayList();
for (T t:seq){
if (pred.test(t)){
result.add(t);
}
}
return  result;
}

static   class  IntegerAdder  implements  Combiner{
public  Integer combine(Integer x, Integer y) {
return  x+y;
}

}
static   class  IntegerSubtracter  implements  Combiner{

public  Integer combine(Integer x, Integer y) {
return  x-y;
}   
}

static   class  BigDecimalAdder  implements  Combiner{

public  BigDecimal combine(BigDecimal x, BigDecimal y) {
return  x.add(y);
}
}

static   class  BigIntegerAdder  implements  Combiner{

public  BigInteger combine(BigInteger x, BigInteger y) {
return  x.add(y);
}
}
static   class  AtomicLongAdder  implements  Combiner{

public  AtomicLong combine(AtomicLong x, AtomicLong y) {
return   new  AtomicLong(x.addAndGet(y.get()));
}
}
static   class  BigDeimalUlp  implements  UnaryFunction{
public  BigDecimal function(BigDecimal x) {
return  x.ulp();
}
}
static   class  Greaterthan>  implements  UnaryPredicate{
private  T  bound ;
public  Greaterthan(T bound){
this . bound  = bound;
}
public   boolean  test(T x) {
return  x.compareTo( bound ) > 0;
}
}
static   class  MultiplyingIntegerCollector  implements  Collector{
private  Integer  val  = 1;
public  Integer function(Integer x){
val *= x;
return   val ;
}
public  Integer result() {
return   val ;
}
}

public   static   void  main(String[] args) {
          List  list = Arrays. asList (1,2,3,46);
          Integer res =   reduce (list, new  IntegerAdder());
          System. out .println(res);
          
          res =  reduce (list,  new  IntegerSubtracter());
           print (res);
          
           print ( filter (list, new  Greaterthan(4)));
          
           print ( forEach (list, new  MultiplyingIntegerCollector()).result());
           print ( forEach ( filter (list, new  Greaterthan(4)), new  MultiplyingIntegerCollector()).result());
           print ( "" );

}
public   static   void  print(Object obj){
System. out .println(obj);
}

}
interface  Combiner {T combine(T x,T y);}
interface  UnaryFunction{ R function(T x);}
interface  Collector  extends  UnaryFunction{T result();}
interface  UnaryPredicate{ boolean  test(T x);}

 

后话： Java 的泛型机制最吸引人的地方就是在使用容器类的地方，泛型的核心是重用和解决一些多态无法解决的问题，泛型的表达意识很强，所以又很好的可读性。泛

你可能感兴趣的:(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
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 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分别代
  • 关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
  • 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的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 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
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor yangshangchuan 信息抽取HtmlExtractor精准抽取信息采集
    HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。   HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。 如
  • java编程思想 -- 多态 百合不是茶 java多态详解
    一: 向上转型和向下转型 面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
  • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系 comsci dp
          对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长....       首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
  • storm 自定义 日志文件 商人shang stormclusterlogback
    Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 1. 想要进行一些调试信息的输出 2. 调试信息或者业务日志信息想要输出到一些固定的文件中   不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
  • Extjs3 SpringMVC使用 @RequestBody 标签问题记录 21jhf
    springMVC使用 @RequestBody(required = false) UserVO userInfo 传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下： （由于使用了父类aaa
  • 一些排错方法 文强chu 方法
    1、java.lang.IllegalStateException: Class invariant violation at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) at o
  • Swing中文件恢复我觉得很难 小桔子 swing
           我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！        用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
  • php 文件操作 aichenglong PHP读取文件写入文件
    1 写入文件 @$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); if(!$fp){ echo "open file error" ; exit; } $outputstring="date:"." \t tire:".$tire."
  • MySQL的btree索引和hash索引的区别 AILIKES 数据结构mysql算法
    Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。     可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
  • JAVA的抽象--- 接口 --实现 百合不是茶
    抽象 接口 实现接口   //抽象 类 ,方法   //定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 抽象的定义使用abstract   abstract class A 定义一个抽象类 例如： //定义一个基类 public abstract class A{     //抽象类不能用来实例化，只能用来继承 //
  • JS变量作用域实例 bijian1013 作用域
    <script> var scope='hello'; function a(){ console.log(scope); //undefined var scope='world'; console.log(scope); //world console.log(b);
  • TDD实践（二） bijian1013 javaTDD
    实践题目：分解质因数 Step1： 单元测试： package com.bijian.study.factor.test; import java.util.Arrays; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import com.bijian.
  • [MongoDB学习笔记一]MongoDB主从复制 bit1129 mongodb
    MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。   事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。 本文介绍MongoDB的主从复制模式，需要指明
  • 【HBase五】Java API操作HBase bit1129 hbase
    import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.ha
  • python调用zabbix api接口实时展示数据 ronin47
    zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
  • jsp取得绝对路径 byalias 绝对路径
    在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下： 一、使用${pageContext.request.contextPath} 　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。
  • Java定时任务调度：用ExecutorService取代Timer bylijinnan java
    《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是： 如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
  • SQL 优化原则 chicony sql
    一、问题的提出 　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
  • java 线程弹球小游戏 CrazyMizzz java游戏
    最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善 这里是提纲 1.线程弹球游戏实现 1.实现界面需要使用哪些API类 JFrame JPanel JButton FlowLayout Graphics2D Thread Color ActionListener ActionEvent MouseListener Mouse
  • hadoop jps出现process information unavailable提示解决办法 daizj hadoopjps
    hadoop jps出现process information unavailable提示解决办法   jps时出现如下信息： 3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 --
  • PHP图片水印缩放类实现 dcj3sjt126com PHP
    <?php class Image{ private $path; function __construct($path='./'){ $this->path=rtrim($path,'/').'/'; } //水印函数，参数：背景图，水印图，位置，前缀,TMD透明度 public function water($b,$l,$pos
  • IOS控件学习：UILabel常用属性与用法 dcj3sjt126com iosUILabel
    参考网站： http://shijue.me/show_text/521c396a8ddf876566000007 http://www.tuicool.com/articles/zquENb http://blog.csdn.net/a451493485/article/details/9454695 http://wiki.eoe.cn/page/iOS_pptl_artile_281
  • 完全手动建立maven骨架 eksliang javaeclipseWeb
    建一个 JAVA 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=App [-Dversion=0.0.1-SNAPSHOT] [-Dpackaging=jar] 建一个 web 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=web-a
  • 配置清单 gengzg 配置
    1、修改grub启动的内核版本 vi /boot/grub/grub.conf 将default 0改为1 拷贝mt7601Usta.ko到/lib文件夹 拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹 拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan 拷贝wifiget.sh到bin文件夹，chm
  • Windows端口被占用处理方法 huqiji windows
    以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
  • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！ 天梯梦 mobile
    CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
  • 简单工厂设计模式 hm4123660 java工厂设计模式简单工厂模式
           简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
  • maven笔记 zhb8015 maven
    跳过测试阶段： mvn package -DskipTests 临时性跳过测试代码的编译： mvn package -Dmaven.test.skip=true   maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。   指定测试类 mvn test
  • 非mapreduce生成Hfile，然后导入hbase当中 Stark_Summer maphbasereduceHfilepath实例
    最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
  • jsp web tomcat 编码问题 王新春 tomcatjsppageEncode
    今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： <Connector port="8080" protocol="HTTP/1.1" connectionTi