java.util.Collections学习

可变参数：

public class T {
    public static void t(String... args){//String ... args ok!
        System.out.print(args.length);
        for (String string : args) {
            System.out.print(string);
        }
    }
    public static void main(String[] args) {
        t();
        System.out.println("\n--");
        t("a","b","c");
    }
}

import java.io.PrintStream;
public class T
{
  public static void t(String[] args)
  {
    System.out.print(args.length);
    String[] arrayOfString = args; 
    int j = args.length; 
    for (int i = 0; i < j; i++) { 
      String string = arrayOfString[i];
      System.out.print(string); }
  }


  public static void main(String[] args) {
    t(new String[0]);
    System.out.println("\n--");
    t(new String[] { "a", "b", "c" });
  }
}

使用时的一些注意：

（1）、只能出现在参数列表的最后，仅支持一个参数为可变参数类型； 

（2）、...位于变量类型和变量名之间，前后有无空格都可以；

（3）、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

3.1  在调用方法的时候，如果能够和固定参数的方法匹配， 也能够与可变长参数的方法匹配，则选择固定参数的方法 。

一个方法只能有一个可变长参数，并且这个可变长参数必须是该方法的最后一个参数

public class T {
public void print(String... args) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
public void print(String test, String... args) {
System.out.println("----------");
}
public static void main(String[] args) {
T test = new T();
test.print("hello");//error
test.print("hello", "alexia");//error
}
}
如果要调用的方法可以和两个可变参数匹配，则出现错误.

避免带有可变长参数的方法重载：如3.1中，编译器虽然知道怎么调用，但人容易陷入调用的陷阱及误区

别让null值和空值威胁到变长方法

public void print(String test, Integer... is) {
        
    } public void print(String test,String...args ){
          
    } public static void main(String[] args) {
        VarArgsTest1 test = new VarArgsTest1();
        test.print("hello");
        test.print("hello", null);
    }

调用者隐藏了实参类型

 public static void main(String[] args) {
        VarArgsTest1 test = new VarArgsTest1();
        String[] strs = null;
        test.print("hello", strs);
    }

package com;


public class VarArgsTest2 {


    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 向上转型
        Base base = new Sub();
        base.print("hello");
        
        // 不转型
        Sub sub = new Sub();
        sub.print("hello");
    }


}


// 基类
class Base {
    void print(String... args) {
        System.out.println("Base......test");
    }
}


// 子类，覆写父类方法
class Sub extends Base {
    @Override
    void print(String[] args) {
        System.out.println("Sub......test");
    }
}

第一个能编译通过，这是为什么呢？事实上，base对象把子类对象sub做了向上转型，形参列表是由父类决定的，当然能通过。而看看子类直接调用的情况，这时编译器看到子类覆写了父类的print方法，因此肯定使用子类重新定义的print方法，尽管参数列表不匹配也不会跑到父类再去匹配下，因为找到了就不再找了，因此有了类型不匹配的错误。

这是个特例，覆写的方法参数列表竟然可以与父类不相同，这违背了覆写的定义，并且会引发莫名其妙的错误。

这里，总结下覆写必须满足的条件：

（1）重写方法不能缩小访问权限；

（2）参数列表必须与被重写方法相同（包括显示形式）；

（3）返回类型必须与被重写方法的相同或是其子类；

（4）重写方法不能抛出新的异常，或者超过了父类范围的异常，但是可以抛出更少、更有限的异常，或者不抛出异常。

<? super T> 作参数
<? extends T> 作返回类型

• ? 通配符类型
• <? extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类
• <? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object

小结

extends 可用于的返回类型限定，不能用于参数类型限定。
super 可用于参数类型限定，不能用于返回类型限定。
带有super超类型限定的通配符可以向泛型对易用写入，

带有extends子类型限定的通配符可以向泛型对象读取。——《Core Java》

java.util.Collections

public static <T> boolean addAll(Collection<? super T> c, T... elements) {
        boolean result = false;
        for (T element : elements)
            result |= c.add(element);
        return result;
}return true if the collection changed as a result of the call：只要有一个添加成功就返回true

java.util.Collection

boolean add(E e);

boolean addAll(Collection<? extends E> c);这个方法没有上面的效率高。