（Collection, List, 泛型）JAVA集合框架一

Java集合框架部分细节总结一

Collection

List 有序，有下标，元素可重复

Set 无序，无下标，元素不可重复

以上为Collection接口

以ArrayList为实现类实现遍历：增强for 和迭代器

for (Object object : collection) {
    System.out.println(object);
}

Iterator it = collection.iterator();
while(it.hasNext()){
    Student st1 = (Student) it.next();
    System.out.println(st1.toString());
}

it.next()为object类，故输出时需要进行类型转换

Iterator有三种方法：

hasNext() boolean型，确定是否具有下一个元素进行迭代

next() object型，获取下一个元素

remove() void，删除当前元素

在迭代器迭代的过程中，不能修改collection元素，例如不能用collection.remove();但是可以通过iterator.remove来修改

List

实现类 ArrayList Vector LinkedList

list中存储的对象为包装类，若存int型，则为Integer

subList 返回一个子集合，（int,int）含头不含尾

ListIterator 有set可直接替换当前next或previous

List实现类

ArrayList 数组结构实现，查询快，增删慢，线程不安全（效率快）

Vector 数组结构实现，查询快，增删慢，线程安全（效率慢）；有elements的几个接口

LinkedList 链表结构实现，增删快，查询慢

ArrayList 源码中可看出，数组空间初始最低容量为10，超过10之后为x+1/2x（此为1/2向下取整）

Vector 多了一个枚举器，后来的版本中多用迭代器了

Enumeration enumeration = vector.elements();
while(enumeration.hasMoreElements()){
    String s = enumeration.nextElement().toString();
    System.out.println(s);
//判断 contains
/*
vector.firstElement();
vector.lastElement();
vector.elementAt();
*/
}

建立一个Student类

private String name;
private int age;

建立一个实现类为ArrayList的集合

Student s1 = new Student("xiaomign",11);
Student s2 = new Student("xiaohong",12);
Student s3 = new Student("xiaolan",13);
collection.add(s1);
collection.add(s2);
collection.add(s3);

若直接remove(new Student("xiaolan",13));不会成功，因为equals里判断为

this == object;

故需重写Student类中的equals

@Override
public boolean equals(Object obj) {
    if(this == obj)
        return true;
    if(obj == null)
        return false;
    if(obj instanceof Student){
        Student s = (Student)obj;
        if(this.name.equals(s.getName()) && this.age == s.getAge())
            return true;
    }
    return false;
}

泛型类

• 若建立泛型类，

public class Mygeneric<T>{
    T t = new T(); //不可以！！！
}

不能直接实例化，需引用类型

• 通常有4种占位符

Mygeneric <T>  类名<>  T type E element  K key V value

• 泛型类3种使用方法：创建变量，传参，返回值

public class demo1<T> {
    //Mygeneric <T>  类名<>  T type E element  K key V value
    //创建变量
    T t;
    //传参
    public void show(T t){
        System.out.println(t);
    }
    //返回值
    public T getT() {
        return t;
    }
}

• 建立泛型之后的使用过程举例：

demo1<Integer> mygeneric = new demo1<Integer>();
mygeneric.t = 1;
System.out.println(mygeneric.getT());

注意：

1. 泛型只能使用引用类型
2. 不同泛型类型不能相互赋值，同类型可以

泛型接口

可直接利用泛型生成接口，以便重写

public interface genericInterface<T> {
    T serve(T t);
}

• 重写部分（确定引用类型）如下：

public class interfaceImp implements genericInterface<String>{
    @Override
    public String serve(String s) {
        System.out.println(s);
        return null;
    }
}

重写过程不是必须引用类型，以下举例

• 重写部分（不确定类型）如下：

public class interfaceImp2<T> implements genericInterface<T>{
    @Override
    public T serve(T t) {
        System.out.println(t);
        return null;
    }
}

在实例化过程中需要引用类型

interfaceImp2<String> s2 = new interfaceImp2();
s2.serve("xxx");

泛型方法

Java 不允许把对象放进一个未知类型的集合里，Collection<?> c

修饰符 <> 返回值类型 方法

举例

public <T> void show(T t){
    System.out.println("泛型方法"+t);
}

返回值类型也可用泛型，在调用该方法时以传入参数的类型为主

泛型可以实现类似重载的功能，提高代码重用性，防止类型转换异常

public static void main(String[] args) {
    ArrayList arrayList = new ArrayList();
    arrayList.add("xxx");
    arrayList.add("yyy");
    arrayList.add(12);

    for(Object object : arrayList){
        String str = (String)object;
        System.out.println(str);
    }
}

增强for部分将出现类型异常

Integer cannot be cast to class java.lang.String

sout(object)不会出现异常是因为pritln之内调用了.Tostring

Collection<T> t = new Collection<>();

可以保证集合t中全为同一种类型