2 集合，泛型

2019-05-24  本文已影响0人  Teemo_fca4

数组在存储多个数据方面的缺点：

Collection

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
对于remove 和contains 方法，内部会去调用ArrayList的equals方法，所以我们使用contains方法时，需要重写自定义类的equals方法

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(new Person("Jerry",20));
        System.out.println(coll.contains(new Person("Jerry",20)));
    }

使用 Arrays.asList方法时，注意 不要使用int[]类型，可以使用其包装类类型

    @Test
    public void test4(){
        List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//2
    }

使用Iterator来操作Collection

        //错误使用iterator的情况：集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
        //默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());
        }

List接口及其实现类ArrayLisyt,LinkedList,Vector

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

LinkedList,其内部节点为Node结构，体现了双向。

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

Set
Set：存储无序的、不可重复的数据

根据以上hashset原理做这个题(已经重写equals()和hashcode())

    @Test
    public void test3(){
        HashSet set = new HashSet();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");

        set.add(p1);
        set.add(p2);
        System.out.println(set); // 输出 [Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]

        p1.name = "CC";
        set.remove(p1);
        System.out.println(set); // 输出 [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
        set.add(new Person(1001,"CC"));
        System.out.println(set); // [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
        set.add(new Person(1001,"AA"));
        System.out.println(set);// [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
    }

LinkedHashSet：可以按照添加的顺序遍历

    public static void main(String[] args) {
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(129);
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
//        输出结果如下
//        456
//        123
//        AA
//        CC
//        129
    }

TreeSet
可以按照添加对象的指定属性，进行排序。

Map
以HashMap为例子

LinkedHashMap数据节点

        static class Entry<K,V> extends HashMap.Node<K,V> {
             Entry<K,V> before, after;//能够记录添加的元素的先后顺序
             Entry(int hash, K key, V value, Node<K,V> next) {
                super(hash, key, value, next);
             }
         }

TreeMap ： 按照key进行排序：默认排序 、定制排序

泛型

泛型类

public class Order<T> {

    String orderName;
    int orderId;
    T orderT;

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }
}

使用泛型类

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
        order1.setOrderT("AA:hello");
    }

泛型方法

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系。
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static <E>  List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }

在泛型的继承中

        //数组中是可以这么操作的
        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

但是泛型是不允许这样做的，虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。

        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
//        list1 = list2;

但是：类A是类B的父类，A<G> 是 B<G> 的父类,这样是可以的
通配符?的使用

    @Test
    public void test3(){
        //类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;
        list = list1;
        list = list2;
        //使用通配符之后  可以读但是不能写
        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list = list3;
        //添加(写入)：对于List<?>就不能向其内部添加数据。
        //除了添加null之外。
//        list.add("DD");
        list.add(null);
        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
    }

extend和super

    @Test
    public void test4(){
        //这里的 Student是extends  Person的
        List<? extends Person> list1 = null; //? extends Person 表示Person类或者Person类的子类
        List<? super Person> list2 = null;   //? super Person 表示Person类或者Person类的父类

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
    }
上一篇下一篇

猜你喜欢

热点阅读