List

List

特点：有序，有下标，元素可以重复

package com.zhang.oop.Coll;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加信息（添加数字数据会有一个自动装箱处理）
        list.add("华为");
        list.add("小米");
        list.add("苹果");
        //删除元素（输出数据的话填的是下标，或者是list.remove(new Integer(20)）
        //补充subList：返回子集合，含头不含尾。例：1，2，3，4  subList(1,3) 输出：2，3
        list.remove("苹果");
        System.out.println(list);
        //for循环遍历
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //增强for遍历
        for (Object o : list) {
            System.out.println(o);
        }
        //迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //列表迭代器，和Iterator的区别，ListIterator可以向前或向后遍历，添加，删除，修改元素
        ListIterator lit = list.listIterator();
        //从前往后（遍历完成后光标在最后一个元素那里）
        while(lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        //从后往前
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
    }
}

ArrayList:查询快，增删慢，运行效率快，线程不安全

LinkedList: 增删快，查询慢（使用方法和ArrayList一样）

//重写equals方法
public boolean equals(Object obj) {
        //判断是不是同一个对象
        if(this==obj){
            return true;
        }
        //判断是否为空
        if (obj==null){
            return false;
        }
        //判断是否是Student类型
        if (obj instanceof Students){
            Students s = (Students)obj;
            //比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //不满足条件返回false
        return false;
    }

package com.zhang.oop.Coll;
import java.util.ArrayList;
public class Demo03 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        Students s1 = new Students("张三",22);
        Students s2 = new Students("李四",33);
        Students s3 = new Students("王五",43);
        //添加信息
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println(arrayList);
        //删除信息
        //arrayList.remove(s2);
        arrayList.remove(new Students("李四",33));//本质：equals(this==obj)  重写equals方法
        System.out.println(arrayList);
        //使用迭代器遍历和上面一样
    }
}

泛型类

泛型类只能使用引用类型，不同泛型类型之间不能相互赋值

package com.zhang.oop.Coll;
public class MyGeneric<T> {
    T t;
    public void show(T t){
        System.out.println(t);
    }
    public T getT(){
        return t;
    }
}

package com.zhang.oop.Coll;
public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t="hello";
        myGeneric.show("大家好");
        String string = myGeneric.getT();

        MyGeneric<Integer> myGeneric1 = new MyGeneric<Integer>();
        myGeneric1.t=33;
        myGeneric1.show(55);
        Integer integer = myGeneric1.getT();
    }
}

泛型接口

package com.zhang.oop.Coll;
public interface MyInterface<T> {
    String name = "张三";
    T server(T t);
}

package com.zhang.oop.Coll;
public class MyInterfaceImp1 implements MyInterface<String> {
    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

MyInterfaceImp1 imp1 = new MyInterfaceImp1();
imp1.server("dasd");

第二种方法

package com.zhang.oop.Coll;
public class MyInterfaceImp2<T> implements MyInterface<T> {
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

MyInterfaceImp2<Integer> imp2 = new MyInterfaceImp2();
imp2.server(200);

泛型方法

package com.zhang.oop.Coll;
public class MyGenericMethod {
        public <T> T show(T t){
            System.out.println("泛型方法"+t);
            return t;
        }
}

MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("ningao");
myGenericMethod.show(200);

泛型：本质是参数化类型，把类型作为参数传递

好处：提高代码的重用性。防止类型转换异常，提高代码的安全性。

泛型集合

特点：访问时，不必类型转换（拆箱）

不同泛型之间引用不能相互赋值，泛型不存在多态。

package com.zhang.oop.Coll;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("zhangsan");
        arrayList.add("lisi");
        arrayList.add("wangwu");
        System.out.println(arrayList);
        
        ArrayList<Students> arrayList1 = new ArrayList<>();
        Students s1 = new Students("张三",22);
        Students s2 = new Students("李四",33);
        Students s3 = new Students("王五",43);
        arrayList1.add(s1);
        arrayList1.add(s2);
        arrayList1.add(s3);
        Iterator<Students> it = arrayList1.iterator();
        while (it.hasNext()){
            Students s = it.next();
            System.out.println(s);
        }
    }
}