【java】List接口和泛型

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

/**
 * List接口：
 *  1、List集合存储元素特点：有序可重复
 *          有序：List集合中的元素有下标。从0开始，以1递增。
 *  2、List为Collection接口的子接口，以下为List接口特有常用方法：
 *      void add(int index,Object element)  向集合中指定下标处添加元素
 *      Object get(int index)   根据下标获取元素
 *      int indexOf(Object o) 获取元素（对象）第一次出现的下标（索引）
 *      int lastIndexOf(Object o) 获取元素（对象）最后一次出现的下标（索引）
 *      Object remove(int index)  删除指定下标元素
 *      Object set(int index,Object element) 修改指定位置的元素
 */
public class ListTest01 {
    public static void main(String[] args) {
        List list = new ArrayList();//因为要使用List接口中的方法，所以这里要使用List创建对象。
        //添加元素
        list.add("A");//默认都是向集合末尾添加元素
        list.add("B");
        list.add("C");
        //向指定位置添加元素
        list.add(1,"haha");//向集合下标1的位置添加haha
        //迭代
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object a = it.next();
            System.out.println(a);
        }
        //获取元素
        Object f1 = list.get(0);//获取第一个元素
        //通过下标遍历（list接口特有方式）
        for (int i = 0; i < list.size(); i++) {
            Object element = list.get(i);
            System.out.println(element);
        }
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class ArrayListTest01 {
    public static void main(String[] args) {
        //默认初始容量为10
        List list = new ArrayList();
        //指定初始容量
        List list1 = new ArrayList(100);
        //创建一个HashSet集合
        Collection cl = new HashSet();
        cl.add(100);
        cl.add(400);
        cl.add(900);
        cl.add(29);
        //将HashSet集合转换称List集合
        List list2 = new ArrayList(cl);
        for (int i = 0; i < list2.size(); i++) {
            System.out.println(list2.get(i));
        }
    }
}

泛型：

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

/**
 * 关于泛型：
 *  优点：1、集合中存储的元素类型统一了。
 *       2、从集合中取出的元素类型是泛型指定的类型，不需要进行大量的转型！
 *  缺点：1、泛型使集合中存储的元素缺乏多样性
 */

public class GenericTest01 {
    public static void main(String[] args) {
        /*使用泛型之前
        List list = new ArrayList();
        Bird b = new Bird();
        Dog d = new Dog();
        list.add(b);
        list.add(d);
        Iterator it = list.iterator();
        while(it.hasNext()){
            //这里it.next()返回的值都是Object
            //若想使用Animal,Bird...这些类的方法需要向下转型
            Object o = it.next();
            if(o instanceof Animal){
                Animal b1 = (Animal) o;
                b1.move();
            }
        }  */
        //使用泛型之后
        //使用泛型List<Animal>后，表示List集合中只允许存储Animal类型的数据
        //用泛型来指定集合中存储的数据类型
        List<Animal> list = new ArrayList<>();
        Dog d = new Dog();
        Bird b = new Bird();
        list.add(d);
        list.add(b);
        //获取迭代器，表示这个迭代器迭代的是Animal类型
        Iterator<Animal> it = list.iterator();
        while(it.hasNext()){
            //使用泛型后，每一次迭代返回的类型都是Animal类型
            Animal animal = it.next();
            //此时调用Animal不需要强制类型转换，可直接调用
            //但是调用子类特有方法还是需要进行向下转型
            animal.move();
            if(animal instanceof Bird){
                Bird bird = (Bird)animal;
                bird.fly();
            }
            if(animal instanceof Dog){
                Dog dog = (Dog)animal;
                dog.eat();
            }
        }
    }
}

class Animal{
    public void move(){
        System.out.println("移动");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("飞");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("吃");
    }
}

自定义泛型：

/**
 * 自定义泛型
 */
public class GenericTest02<E> {  //这里<>里的为标识符，可自定义，但通常用E(Element)和T(Type)
    public void doSome(E o){    //这里方法中的E需要与类定义的<E>相同
        System.out.println(o);
    }
    public static void main(String[] args){
        //创建对象时的<>需要指定的类型，如Animal，String，Integer等等
        GenericTest02<String> gt = new GenericTest02<>();
        gt.doSome("括号里写的东西需要与创建对象时写泛型类型相同");
    }
}