集合学习02

集合

学习资源来源b站千峰教育、狂神说Java

Vector

• 数组结构实现，查询快、增删慢
• JDK1.0版本，运行效率慢、线程安全
• 不常用

public class Demo04 {
    public static void main(String[] args) {
        //创建集合
        Vector vector = new Vector<>();
        //添加元素
        vector.add("1");
        vector.add("2");
        vector.add("3");

        //用枚举器遍历
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            String s = (String) elements.nextElement();
            System.out.println(s);
        }

        //其他一些方法
//        vector.firstElement();//第一个元素
//        vector.lastElement();//最后一个元素
//        vector.elementAt(0);//用下标查元素
    }
}

---

LinkedList

• 链表结构实现，增删快，查询慢
• 双向链表

在源码中关于结点的介绍

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;
    }
}

• 除头结点外，每一个结点都有一个前驱；除尾结点外，每一个结点都有一个后继
• first只需头结点，last指向尾结点

---

ArrayLIst与LinkedList的区别

• 实现的方式不同

  • ArrayLIst开辟一段连续的空间
  • LinkedList是非连续空间，而是有指向的

• 速度不同

  • ArrayLIst查询快，增删慢
  • LinkedList查询慢，增删快，只需修改指向就能删除

---

泛型

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

• 常见形式：

  • 泛型类
  • 泛型接口
  • 泛型方法
  • 泛型集合

• 语法：

  • <T,…>T称为类型占位符，表示一种引用类型

• 好处：

  • 提高代码的重用性
  • 防止类型转换异常，提高代码的安全性

注意：在具体使用前，不能用泛型new对象，因为类型不确定

泛型类

//类名<T>
public class MyGeneric<T> {
        //泛型
        //创建变量
        T t;

        //泛型做参数
        public void show(T t){
            System.out.println(t);
        }

        //泛型做返回值
        public T getT(){
            return t;
        }
}
==============================================================
public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象,String
        MyGeneric<String> myGeneric = new MyGeneric<>();
        myGeneric.t = "你好世界";
        myGeneric.show("HelloWorld");
        String string = myGeneric.getT();
        System.out.println(string);

        //Integer
        MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
        myGeneric1.t = 0;
        myGeneric1.show(1);
        Integer integer = myGeneric1.getT();
        System.out.println(integer);
    }
}

• 泛型是概念，模板是泛型的实现

---

泛型接口

//接口名<T>
public interface MyInterface<T> {
    String name = "xxx";//接口中的常量默认是public static final修饰

    public T server(T t);
}
===========================================
//在开始时确定类型
public class MyInterfaceImpl1 implements MyInterface<String>{
    @Override
    public String server(String s) {
        System.out.println(s);
        return null;
    }
}
============================================
//在使用时确定类型
public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}
==========================================
public class TestGeneric {
    public static void main(String[] args) {
        MyInterfaceImpl1 impl1 = new MyInterfaceImpl1();
        impl1.server("yjj");

        MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<>();
        impl2.server(2021);
    }
}

---

泛型方法

public class MyGenericMethod {
    //<T> 返回值类型(也可以是泛型)
    public static <T> T show(T t){
        System.out.println(t);
        return t;
    }
}
====================================
public class TestGeneric {
    public static void main(String[] args) {
    
        //根据你传的参数类型决定泛型类型
        MyGenericMethod.show("Java");
        MyGenericMethod.show(520);

    }
}

---

泛型集合

不使用泛型时的集合，可能有多种类型存在，在类型转换时可能出错，而泛型集合将所有元素都保持一种类型，避免了一些错误

• 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
• 特点：
  • 编译时即可检查，而非运行时抛出异常
  • 访问时，不必类型转换(拆箱)
  • 不同泛型之间引用不能相互赋值，泛型不存在多态

简单地说，就是确定了集合的元素类型，因此不会出现类型转换异常的问题