第二阶段-day04_Generic

今天我们主要讲了List的子类：ArrayList, Vector, LinkedList 以及 JDK5 的一些特性：静态导入和泛型。

接昨天的练习：

Ex3:反转链表

 1 package com.cskaoyan.exercise;
 2 
 3 public class Ex1 {
 4     public static Node reverse(Node head) {
 5         if (head.next == null) return head;
 6         // 如果链表不止一个结点，反转head.next
 7         Node reversed = reverse(head.next);
 8         // 反转head结点
 9         head.next.next = head;
10         head.next = null;
11         return reversed;
12     }
13     public static void print(Node head) {
14         Node x = head;
15         while (x != null) {
16             System.out.print(x.value);
17             if (x.next != null) System.out.print(" --> ");
18             x = x.next;
19         }
20         System.out.println();
21     }
22 
23     public static void main(String[] args) {
24         Node head = new Node(3);
25         head = new Node(2, head);
26         head = new Node(1, head);
27         print(head);
28         head = reverse(head);
29         print(head);
30     }
31 }

数组VS链表

数组和链表的插入，删除，随机访问操作的时间复杂度刚好相反。

① 数组使用的是连续的内存空间，可以利用CPU的高速缓存预读数据。链表的内存空间不是连续的，不能有效预读数据。当然如果数组过大，系统没有足够的连续内存空间，会抛出OOM。

 

② 数组的缺点是大小固定，没法动态的调整大小。如果要存储一些对象，如果数组太大，浪费内存空间；如果数组太小，我们需要重新申请一个更大数组，并将数据拷贝过去，耗时。

 

③如果业务对内存的使用非常苛刻，数组更适合。因为结点有指针域，更消耗内存。而且对链表的频繁插入和删除，会导致结点对象的频繁创建和销毁，有可能会导致频繁的GC活动。

List子类

• ArrayList

底层数据结构是数组，查询快，增删慢
线程不安全，效率高

package com.cskaoyan.list;

import java.util.ArrayList;
import java.util.Collection;

/*
ArrayList
特性：
    底层数据结构是数组，增删慢，查找快。
    不同步, 线程不安全, 效率高。
    存储null元素
构造方法：
    ArrayList(): 默认初始大小为10
    ArrayList(int initialCapacity): 可以指定数组的初始大小
    ArrayList(Collection c)
API:
    void ensureCapacity(int minCapacity): 避免频繁扩容
    void trimToSize():慎用，确保元素不会在添加的情况下用。
 */
public class ArrayListDemo1 {
    public static void main(String[] args) {
        // ArrayList list = new ArrayList();
        // ArrayList list = new ArrayList(100);
        // System.out.println(list);

        Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");
        ArrayList list = new ArrayList(c);
        System.out.println(list);
        list.add(null);
        list.add(null);
        list.add(null);
        System.out.println(list);
    }
}

• Vector

底层数据结构是数组，查询快，增删慢
线程安全，效率低
Vector 特有的API
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

package com.cskaoyan.list;

import java.util.Vector;

/*
Vector
特性：
    底层是数组，增删慢，查找快
    同步, 线程安全, 效率比较低
    存储null元素
　　　　JDK1.0就已经有了
API：
    void addElement(E obj)                  -->     void add(E e)
    void copyInto(Object[] anArray)         -->     Object[] toArray()
    E elementAt(int index)                  -->     E get(int index)
    void insertElementAt(E obj, int index)  -->     void add(int index, E e)
    void removeAllElements()                -->     void clear()
    boolean removeElement(Object obj)       -->     boolean remove(Object obj)
    void removeElementAt(int index          -->     E remove(int index)
    void setElementAt(E obj, int index)     -->     E set(int index)
    Enumeration<E> elements()               -->     Iterator iterator()

    int capacity()
    void setSize(int newSize)
    E firstElement()
    E lastElement()
    int indexOf(Object o, int index)
    int lastIndexOf(Object o, int index)

    Enumeration<E> elements()
 */
public class VectorDemo1 {
    public static void main(String[] args) {

        Vector vector = new Vector();
        //  int capacity()
        /*System.out.println(vector.capacity()); // 10
        System.out.println(vector.size()); // 0
        System.out.println(vector);*/

        // void setSize(int newSize)
        /*vector.setSize(20);
        System.out.println(vector.capacity());
        System.out.println(vector.size());
        System.out.println(vector);*/
        vector.add("hello");
        vector.add("world");
        vector.add("java");
        /*System.out.println(vector.capacity());
        System.out.println(vector.size());
        System.out.println(vector);

        vector.setSize(1);
        System.out.println(vector.capacity());
        System.out.println(vector.size());
        System.out.println(vector);*/

        // vector.clear();
        //E firstElement()
        // System.out.println(vector.firstElement()); // NoSuchElementException
        //E lastElement()
        // System.out.println(vector.lastElement()); NoSuchElementException

        vector.add("hello");
        vector.add("hello");
        vector.add("hello");
        System.out.println(vector);
        // int indexOf(Object o, int index)
        // System.out.println(vector.indexOf("hello"));
       /* System.out.println(vector.indexOf("hello", 1));
        System.out.println(vector.indexOf("hello", 3));*/

        // int lastIndexOf(Object o, int index)
        /*System.out.println(vector.lastIndexOf("hello"));
        System.out.println(vector.lastIndexOf("hello", 3));
        System.out.println(vector.lastIndexOf("hello", 1));*/
    }
}

package com.cskaoyan.list;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

/*
Enumeration:                        -->     Iterator
    boolean hasMoreElements()       -->     boolean hasNext()
    E nextElement()                 -->     E next()
 */
public class VectorDemo2 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("hello");
        vector.add("world");
        vector.add("java");

        for(Enumeration e = vector.elements(); e.hasMoreElements(); ) {
            String s = (String) e.nextElement();
            System.out.println(s);
        }

        for(Iterator it = vector.iterator(); it.hasNext(); ) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

• LinkedList

底层数据结构是链表，查询慢，增删快
线程不安全，效率高
LinkedList 特有的API
      ① public void addFirst(E e)及addLast(E e)
      ② public E getFirst()及getLast()
      ③ public E removeFirst()及public E removeLast()

                                                                         栈和队列 

package com.cskaoyan.list;

import java.util.Iterator;
import java.util.LinkedList;

/*
Deque接口
    概述：双端队列，可以在两端插入和删除

LinkedList implements List, Deque
特性：
    底层数据结构是链表，增删快，查找慢
    不同步, 线程不安全, 效率高
    允许null元素
    实现了Deque这个接口，可以当作栈,队列和双端队列来使用

构造方法：
    LinkedList()
    LinkedList(Collection c)

API:
     Iterator<E> descendingIterator()
     boolean removeFirstOccurrence(Object o)
     boolean removeLastOccurrence(Object o)

在两端的操作
    boolean offerFirst
    boolean pollFirst
    boolean peekFirst

 */
public class LinkedListDemo1 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // Iterator<E> descendingIterator()
        /*for(Iterator it = list.descendingIterator(); it.hasNext(); ) {
            String s = (String) it.next();
            System.out.println(s);
        }*/

        /*list.addFirst(null);
        list.addLast(null);
        System.out.println(list);*/
        //  boolean removeFirstOccurrence(Object o)
        // list.removeFirstOccurrence(null);

        // boolean removeLastOccurrence(Object o)
        /*list.removeLastOccurrence(null);
        System.out.println(list);*/

        //  boolean offerFirst
        // list.offerFirst(null);
        // System.out.println(list);

        //  boolean pollFirst
        /*System.out.println(list.pollFirst());
        System.out.println(list);*/
        //  boolean peekFirst

        System.out.println(list.peekFirst());
        System.out.println(list);
    }
}

package com.cskaoyan.list;

import java.util.Deque;
import java.util.LinkedList;

/*
栈的API:
    void push(E e)
    E pop()
    E peek()
注意事项：Java中提供了Stack类，但是我们应该优先使用Deque, 而不应该使用Stack

为什么？
a. Stack同步的, 效率相对来说比较低。
b. Stack继承了Vector, 所以Stack拥有Vector中所有的方法, 使用起来不安全。

 */
public class LinkedListDemo2 {
    public static void main(String[] args) {
        Deque stack = new LinkedList();
        stack.push("hello");
        stack.push("world");
        stack.push("java");

        System.out.println(stack.peek());

        while (!stack.isEmpty()) {
            String s = (String) stack.pop();
            System.out.println(s);
        }

        System.out.println(stack.peek()); // null
    }
}

 

总结：

Iterable

　　|--Collection

　　　　|--List

　　　　　　|--ArrayList

　　　　　　|--Vector

　　　　　　　　|---Stack

　　　　　　|--LinkedList

　　　　|--Queue

　　　　　　|--Deque

　　　　　　　　|--LinkedList

　　　　|--Set

 

练习：

1.   去重
2.   请用ArrayList实现栈数据结构，并测试。
3.   集合的嵌套遍历
4.   获取10个1-20之间的随机整数，要求集合中的数不能重复。

 

 

Ex1:去重

 1 package com.cskaoyan.exercise;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 import java.util.ListIterator;
 7 
 8 /*
 9 1.去重
10 输入：[a, b, c, a, a, b, c]
11 输出：[a, b, c]
12 
13 思路1：
14 1. 新键一个List result = new ArrayList();
15 2. 遍历原来的list, 判断元素是否在result中存在
16    存在：不添加
17    不存在：添加
18 3. 遍历结束后, 返回result
19 
20 思路2：
21 1. 逆序遍历list
22 2. 获取元素, 截取从0到nextIndex的子列表，判断元素是否在子列表中存在
23    存在：删除元素
24    不存在：
25 3. 遍历结束后，完成去重
26  */
27 public class Ex2 {
28     public static List disctinct1(List list) {
29         List result = new ArrayList();
30         for(Iterator it = list.iterator(); it.hasNext(); ) {
31             Object obj = it.next();
32             if (!result.contains(obj)) result.add(obj);
33         }
34         return result;
35     }
36 
37     public static void disctinct2(List list) {
38         for(ListIterator it = list.listIterator(list.size()); it.hasPrevious(); ) {
39             Object element = it.previous();
40             List subList = list.subList(0, it.nextIndex());
41             if (subList.contains(element)) it.remove();
42         }
43     }
44 
45     public static void main(String[] args) {
46         // [a, b, c, a, a, b, c]
47         List list = new ArrayList();
48         list.add('a');
49         list.add('b');
50         list.add('c');
51         list.add('a');
52         list.add('a');
53         list.add('b');
54         list.add('c');
55         // List result = disctinct1(list);
56         disctinct2(list);
57         System.out.println(list);
58     }
59 }

 

 

Ex2:请用ArrayList实现栈数据结构，并测试。

package com.cskaoyan.exercise;

import java.util.ArrayList;
import java.util.EmptyStackException;

/*
a. 如果一个类持有某个类的成员，那么就能够"拥有"这个类的所有公共方法。
   但是我们可以对这些方法进行限制。
b. 组合还可以"加强"另一个类的方法。
c. 可以组合多个对象

"加强"一个方法
a. 继承
b. 组合

设计原则：
    优先使用组合，而不是继承

什么情况下，可以使用继承呢？
如果两个类之间有"is a"的关系，可以使用继承。

GO语言不支持继承。
 */
public class MyStack {
    private ArrayList list; //组合
    private String str;

    public MyStack(ArrayList list) {
        this.list = list;
    }

    public void push(Object obj) {
        list.add(obj);
    }

    public Object pop() {
        if (isEmpty()) throw new EmptyStackException();
        return list.remove(list.size() - 1);
    }

    public Object peek() {
        if (isEmpty()) throw new EmptyStackException();
        return list.get(list.size() - 1);
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }
}

package com.cskaoyan.exercise;

public class Node {
    int value;
    Node next;

    public Node(int value) {
        this.value = value;
    }

    public Node(int value, Node next) {
        this.value = value;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
}

 

 

JDK5的新特性

 

package com.cskaoyan.jdk5;

import java.util.Date;
import java.util.Map;
import static java.lang.Math.*;
/*
静态导入
导包
    必须导入到类这一级别
    作用：导入的类就好像定义在当前这个包下面。
静态导入：
    必须导入到方法这一级别，并且必须是静态方法。
    作用：导入的静态方法就好像定义在当前这个类中一样。
推荐：不要使用静态导入，可读性差

总结：static的用法有哪些？
a. 静态代码块：对类进行初始化，类加载的时候执行，并且只执行一次
b. 静态变量：该变量是类所有，被该类的所有成员共享
c. 静态方法
d. 静态内部类
e. 静态导入：导入静态方法
 */
public class StaticImportDemo1 {
    public static void main(String[] args) {
        // java.util.Date date = new java.util.Date();
        // Date date = new Date();

        System.out.println(sqrt(1.0));
        System.out.println(abs(-100));
        System.out.println(max(2, 3));
    }
}

泛型

 

泛型的引入

泛型的好处

package com.cskaoyan.jdk5;

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

/*
泛型的好处:
   a. 提高了程序的安全性
   b. 将运行期遇到的问题转移到了编译期
   c. 省去了类型强转的麻烦

设计原则：
    及早失败原则

对大家的要求：
a. 可以利用泛型操作集合
b. 能够看懂别人些的泛型代码

 */
public class GenericDemo1 {
    public static void main(String[] args) {
        /*List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add(1);
        doSomething(list);*/

        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        // list.add(1);
        doSomething(list);
    }

    private static void doSomething(List list) {
        /*for(Iterator it = list.iterator(); it.hasNext(); ) {
            String s = (String) it.next(); // ClassCastException
            s.toUpperCase();
        }*/

        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            String s = it.next();
            System.out.println(s.toUpperCase());
        }
    }
}

package com.cskaoyan.jdk5;
/*
泛型类：
    泛型定义在类上面
    作用域：整个类
    格式: public class 类名<泛型类型1,…>

泛型的命名规则：
    必须满足标识符的规则
业界规范：
    一般用大写字母表示
    T:type
    E:element
    K:key
    V:value
 */
public class Tool2<T> { // 定义泛型, T就是泛型, 类似于形式参数
    T obj; // 使用泛型

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

package com.cskaoyan.jdk5;
/*
如果创建对象的时候指定类型：
    默认是Object类型

JDK7特性：<>棱形操作符，可以利用类型推断机制。
 */
public class GenericDemo2 {
    public static void main(String[] args) {
        /*Tool2<String> tool2 = new Tool2<String>(); // String是参数化类型, 类似实参
        tool2.setObj("hello");
        // tool2.setObj(1);
        String s = tool2.getObj();
        System.out.println(s);*/

        Tool2<Object> tool1 = new Tool2();
        tool1.setObj("hello");
        Object obj = tool1.getObj();

        Tool2<String> tool2 = new Tool2<>();

        Tool2 tool3 = new Tool2<String>();

    }
}

 

泛型应用

泛型类

把泛型定义在类上
格式:public class 类名<泛型类型1,…>
注意:参数化类型必须是引用类型

 

泛型方法

把泛型定义在方法上
格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

package com.cskaoyan.jdk5;
/*
泛型方法：
    把泛型定义在方法上面
    作用域：方法签名上或者方法体内
    格式：public <泛型类型> 返回类型 方法名(泛型类型...)

为什么泛型要定义在返回值类型的前面呢？
    因为返回值类型也可以是泛型，泛型必须先定义才能使用

问题：
    有泛型方法的类一定是泛型类吗？ 不是

 */
public class Tool3 {

    /*public String echo(String s) {
        return s;
    }

    public Date echo(Date s) {
        return s;
    }*/

    /*public Object echo(Object obj) {
        return obj;
    }*/
    // T t;
    public <T> T echo(T t) {
        return t;
    }

    /*public void method(T t) {

    }*/
    // ...
}

package com.cskaoyan.jdk5;

public class GenericDemo3 {
    public static void main(String[] args) {
        /*Tool3 tool3 = new Tool3();
        Object obj = tool3.echo("hello");
        String s = (String) obj;
        System.out.println(s.toUpperCase());*/

        Tool3 tool3 = new Tool3();
        String s = tool3.echo("hello");
        System.out.println(s);
    }
}

泛型接口

把泛型定义在接口上
格式:public  interface 接口名<泛型类型1…>

package com.cskaoyan.jdk5;

/*
泛型接口：
    在接口上面定义放行
    作用域：接口内
    格式：格式:public  interface 接口名<泛型类型1…>

 */
public interface Auto<T> {
    T run(T t);
}

package com.cskaoyan.jdk5;
/*
泛型接口的实现类
a. 普通类
b. 泛型类
 */
public class Car implements Auto<String> {
    @Override
    public String run(String s) {
        return null;
    }
}

package com.cskaoyan.jdk5;

/*public class Bus<T> implements Auto<String> {
    @Override
    public String run(String s) {
        return null;
    }
}*/

public class Bus<T> implements Auto<T> {// Bus<T>是定义泛型T, Auto<T>是使用泛型T
    @Override
    public T run(T t) {
        return null;
    }
}

 

package com.cskaoyan.jdk5;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/*
数组：
问题1：String是Object的子类吗？ 是
问题2：String[]是Object[]的子类吗？ 不是
父类的引用变量可以指向子类的对象。

JVM对数组进行特殊"照顾",但是这样也会引入一些问题。
 */
public class GenericDemo4 {
    public static void main(String[] args) {
        /*String[] strs = {"hello", "world", "java"};
        Object[] objs = strs; // JVM对数组进行特殊"照顾"
        objs[1] = new Date(); // ArrayStoreException*/

        /*List<String> strs = new ArrayList<>();
        strs.add("hello");
        strs.add("world");
        strs.add("java");
        List<Object> objs = strs;*/
    }
}

泛型通配符：

① 泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
② ? extends E
向下限定，E及其子类
③ ? super E
向上限定，E及其父类

package com.cskaoyan.jdk5;

import java.util.ArrayList;
import java.util.Collection;

/*
泛型通配符：
    目的：提供类似数组的功能，但是不要引入数组中可能出现的问题。

① 泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
② ? extends E
向下限定，E及其子类
③ ? super E
向上限定，E及其父类

 */
public class GenericDemo5 {
    public static void main(String[] args) {
        // Collection<Object> c1 = new ArrayList<Object>();
        /*Collection<Object> c2 = new ArrayList<Animal>();
        Collection<Object> c3 = new ArrayList<Cat>();
        Collection<Object> c4 = new ArrayList<Dog>();*/

        /*Collection<?> c1 = new ArrayList<Object>();
        Collection<?> c2 = new ArrayList<Animal>();
        Collection<?> c3 = new ArrayList<Cat>();
        Collection<?> c4 = new ArrayList<Dog>();*/
        // c2.add(new Dog());
        // c2.add(new Animal());

        // Collection<? extends Animal> c1 = new ArrayList<Object>();
       /* Collection<? extends Animal> c2 = new ArrayList<Animal>();
        Collection<? extends Animal> c3 = new ArrayList<Cat>();
        Collection<? extends Animal> c4 = new ArrayList<Dog>();*/
        /*c3.add(new Animal());
        c3.add(new Dog());
        c3.add(new Cat());*/

        Collection<? super Animal> c1 = new ArrayList<Object>();
        Collection<? super Animal> c2 = new ArrayList<Animal>();
        // Collection<? super Animal > c3 = new ArrayList<Cat>();
        // Collection<? super Animal> c4 = new ArrayList<Dog>();
        c2.add(new Animal());
        c2.add(new Dog());
        c2.add(new Cat());
        // c2.add(new Object());
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}