2022-03-17

Day16

List 的子类ArrayList，Vector，LinkedLis
ArrayList
　　用法跟List相同

Vector
Vector的特有功能：
添加功能
　　public void addElement(Object obj)---------被add()替代
获取功能
　　public Object elementAt(int index)-----------被get()替代
　　public Enumeration elements()---------------被Iterator iterator()迭代器替代
　　boolean hasMoreElements()------------------被hasNext()替代
　　Object nextElement()----------------------------被next()替代

LinkedList
添加功能
　　public void addFirst(Object e) 在第一个位置添加元素
　　public void addLast(Object e) 在最后一个位置添加元素
获取功能
　　public Object getFirst() 获取第一个元素
　　public Obejct getLast()获取最后一个元素
删除功能
　　public Object removeFirst()删除第一个元素并返回第一个元素
　　public Object removeLast()删除最后一个元素并返回最后一个元素

注意：contains()方法的底层依赖的是equals()方法

/*ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 分析：
*      创建集合对象
*      添加多个字符串元素(包含内容相同的)
*      创建新集合
*      遍历旧集合,获取得到每一个元素
*      拿这个元素到新集合去找，看有没有
*          有：不搭理它
*          没有：就添加到新集合
*      遍历新集合
*/
import java.util.ArrayList;
public class SanGe {
   public static void main(String[] args) {
       //创建集合对象
       ArrayList al = new ArrayList();

       //添加多个字符串元素(包含内容相同的)
       al.add("he");
       al.add("nihao");
       al.add("nihao");
       al.add("he");
       al.add("nihao");
       al.add("world");
       al.add("world");
       //创建新集合
       ArrayList newAl = new ArrayList();

       //遍历旧集合,获取得到每一个元素
       for (int i = 0; i < al.size(); i++) {
           //拿这个元素到新集合去找，看有没有
           if (!newAl.contains(al.get(i))){
               //没有：就添加到新集合
               newAl.add(al.get(i));
           }
       }
       //遍历新集合
       for (int i = 0; i < newAl.size(); i++) {
           System.out.println(newAl.get(i)+" ");
       }
   }
}

ArrarList去重升级版

/*
 * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
 * 要求：不能创建新的集合，就在以前的集合上做
 */
public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 添加多个字符串元素(包含内容相同的)
        al.add("he");
        al.add("nihao");
        al.add("nihao");
        al.add("he");
        al.add("nihao");
        al.add("world");
        al.add("world");
        // 由选择排序思想引入，我们就可以通过这种思想做这个题目
        // 拿0索引的依次和后面的比较，有就把后的干掉
        // 同理，拿1索引...
        for (int i = 0; i < array.size() - 1; i++) {
            for (int j = i + 1; j < array.size(); j++) {
                if (array.get(i).equals(array.get(j))) {
                    array.remove(j);
                    j--;
                }
            }
        }

        // 遍历集合
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

泛型
　　是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型，参数化类型，把类型当作参数一样的传递
格式：
　　<数据类型>
　　此处的数据类型只能是引用类型
好处：
　　把运行时期的问题提前到了编译期间
　　避免了强制类型转换
　　优化了程序设计，解决了黄色警告线
泛型在哪些地方使用，看API，如果类，接口，抽象类后面跟的有就说要使用泛型，一般来说就是在集合中使用

public class GenericDemo {
    public static void main(String[] args) {
        // 创建
        ArrayList array = new ArrayList();

        // 添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        // 遍历
        Iterator it = array.iterator();
        while (it.hasNext()) {
            // String s = (String) it.next();
            //因为Iterator后边跟了String，默认就是String类型，不需要强转
            String s = it.next();
            System.out.println(s);
        }
    }
}

泛型应用
　泛型类
　　把泛型定义在类上
　　格式:public class 类名<泛型类型1,…>
注意:泛型类型必须是引用类型
　泛型方法
　　把泛型定义在方法上
　　格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
泛型接口
　　把泛型定义在接口上
　　格式:public interface 接口名<泛型类型1…>
泛型类

/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}
/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        // ObjectTool ot = new ObjectTool();
        //
        // ot.setObj(new String("张三"));
        // String s = (String) ot.getObj();
        // System.out.println("姓名是：" + s);
        //
        // ot.setObj(new Integer(30));
        // Integer i = (Integer) ot.getObj();
        // System.out.println("年龄是：" + i);

        // ot.setObj(new String("李四"));
        // // ClassCastException
        // Integer ii = (Integer) ot.getObj();
        // System.out.println("姓名是：" + ii);

        System.out.println("-------------");

        ObjectTool ot = new ObjectTool();
        // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
        ot.setObj(new String("张三"));
        String s = ot.getObj();
        System.out.println("姓名是：" + s);

        ObjectTool ot2 = new ObjectTool();
        // ot2.setObj(new String("李四"));//这个时候编译期间就过不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年龄是：" + i);
    }
}

泛型方法

/*
 * 泛型方法：把泛型定义在方法上
 */
public class ObjectTool {
    //谁调用就传谁的类型给show方法
    public  void show(T t) {
        System.out.println(t);
    }
}
public class ObjectToolDemo {
    public static void main(String[] args) {
        // 定义泛型方法后
        ObjectTool ot = new ObjectTool();
        ot.show("hello");//String调用,show就接受String类型
        ot.show(100);
        ot.show(true);
    }
}

泛型接口

/*
 * 泛型接口：把泛型定义在接口上
 */
public interface Inter {
    public abstract void show(T t);
}
//实现类在实现接口的时候
//第一种情况：已经知道该是什么类型的了

//public class InterImpl implements Inter {
//
//  @Override
//  public void show(String t) {
//      System.out.println(t);
//  }
// }

//第二种情况：还不知道是什么类型的
public class InterImpl implements Inter {

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
//测试类
public class InterDemo {
    public static void main(String[] args) {
        // 第一种情况的测试
        // Inter i = new InterImpl();
        // i.show("hello");

        //  第二种情况的测试
        Inter i = new InterImpl();
        i.show("hello");

        Inter ii = new InterImpl();
        ii.show(100);
    }
}

泛型高级(通配符)
　　?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
　　? extends E:向下限定，E及其子类
　　? super E:向上限定，E极其父类

public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确的写的时候，前后必须一致
        Collection