Java 泛型

参考

泛型的本质是参数化类型,也就是可以在使用时指定方法/类的参数类型,而不是在定义时指定。

泛型方法

泛型方法的规则:
  • 所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的)。
  • 每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
  • 类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。
  • 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。
public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组: Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}
有界的类型参数

使用 extends implements 来定义有界的参数类型,这样接收的参数只能是其子类。

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

泛型类

在正常的类声明后添加类型参数,即声明泛型类;

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

类型通配符

通配符在泛型的参数传递时使用,例如下例中List<?>:

public static void getData(List<?> data) {
	System.out.println("data :" + data.get(0));
}

方法可以传递List<String>List<Integer> 等所有List类型。

通配符的上限

public static void getUperNumber(List<? extends Number> data) {
	System.out.println("data :" + data.get(0));
}

通配符的下限

public static void getUperNumber(List<? super Number> data) {
	System.out.println("data :" + data.get(0));
}

Java 中InputStreamOutputStream

参考

之前的理解中,一直以内存作为主体来看,Input即读取到内存,Output即从内存中取出。这样的理解在文件读取,网络读取时都没有什么问题,今天看LZMA压缩算法,Java版算法在压缩时构建了一个outputStream,而在解压时通过一个inputStream来实现,顿时有点崩溃了。

于是从新查了一下Java 中InputStream 和OutputStream的理解,找到如上参考文章,将stream 想象成水龙头。

  • InputStream 相当于一个水龙头出口,你可从中获取数据;
  • OutputStream 相当于水龙头入口,将数据写入其中;

顿时有种豁然开朗的感觉,Input 和Output不必纠结于内存和硬盘,只在stream 中。

后记

公司搬家之后一直从 横穿马路的那条街安装了隔离栏,话说我们刚刚搬家半个月,有必要这么针对吗!!!