java 声明泛型集合 java泛型与集合

一、集合与数组的区别
数组:长度固定，能存储基本数据类型和对象
例：int[] arr1 = new int[10]
Student[] arr2 = new Student[10]
集合：长度可变，只能存对象，而且对象的类型可以不一致

二、集合的体系图

collect集合的父接口中的常用方法： 
              1、 public boolean add(E e) :把给定的对象添加到当前集合中 
              2、public void clear() :清空集合中所有的元素
              3、public boolean remove(E e) : 把给定的对象在当前集合中删除
              4、public boolean contains(E e) : 判断当前集合中是否包含给定的对象
              5、public boolean isEmpty() : 判断当前集合是否为空
              6、public int size() : 返回集合中元素的个数
              7、public Object[] toArray() : 把集合转换成数组
              8、public Iterator iterator() : 获取迭代器实现类对象，用来遍历集合中的元素的
              
         迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个
                          元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出

        Iterator接口的常用方法：
                          a、public boolean hasNext() :如果仍有下一个元素可以迭代，则返回 true
                          b、public E next() :返回迭代的下一个元素
                          c、default void remove()：移除元素
        


  list集合：有索引、可以存储重复元素且有序
        该集合的实现类：
                    ArrayList:底层是一个数组实现的，查询快，增删慢，默认扩充为原来的1.5倍，但线程不安全      
                    vector:底层是一个数组实现的，查询和增删都很慢，默认扩充为原来的2倍，但线程安全，因为使用了synchronized关键字     
                    LinkeList:底层是一个链表实现的，查询慢，增删快
 
   set集合：无索引，不可以存储重复元素且无序
         该集合的实现类：
                    HashSet:底层是哈希表+（红黑树实现的）,无索引，不可以存储重复元素且无序
                    linkeHashSet:底层是哈希表+链表实现的，无索引，不可以存储重复元素，但可以保证存储顺序
                    TreeSet:底层是使用二叉树实现的，一般用于排序

三、 迭代器的原理

四、增强for

public class CollectionTest {
public static void main(String[] args) {
    Collection<Person> cl = new ArrayList<>();
    cl.add(new Person(1,"秦问天",12));
    cl.add(new Person(2,"莫倾城",15));
    cl.add(new Person(3,"青儿",16));
    cl.add(new Person(4,"幽篁",18));

    List<Integer> ids = cl.stream().map(n->n.getId()).collect(Collectors.toList());
    Iterator<Integer> id = ids.iterator();
    while(id.hasNext()){
        System.out.println(id.next());
    }
    System.out.println("....增强for....");
    for (Integer personId : ids) {
        System.out.println(personId);
    }
}

}

五、 泛型：可以在类或方法中预支地使用未知的数据类型
注意：一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
使用泛型的好处：
a、将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
b、避免了类型强转的麻烦。

泛型的使用与定义
              a、泛型类：在创建对象的时候确定泛型
                    定义格式：修饰符 class 类名<代表泛型的变量> { }
                    例子：
                          public class GenericityClass<E> {
                              private E name;

                              public E getName() {
                                  return name;
                          }

                              public void setName(E name) {
                                  this.name = name;
                            }
                          }
                          
               b、泛型方法：调用方法时，确定泛型的类型
                    定义格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
                    例子：
                          public class GenericityMethod{
                             public <T> void show(T t){
                                 System.out.println("自定义泛型方法："+t);
                             }
                             public <T> T show1(T t){
                                 return t;
                             }
                          }

               c、泛型的接口：1、定义类时确定泛型的类型 2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
                    定义格式：修饰符 interface接口名<代表泛型的变量> {  }
                    例子：
                          public interface GenericityInterface<E> {
                                 public abstract void add(E e);
                                 public abstract void get(E e);
                          }

                          public class MyGenericityInterface implements GenericityInterface<String> {
                              @Override
                              public void add(String s) {}

                              @Override
                              public void get(String s) {}
                          }

六、泛型的上限和下限
泛型的上限：
格式： 类型名称 <? extends 类 > 对象名称
意义： 代表使用的泛型只能接受【E类型及子类】
泛型的下限：
格式： 类型名称 <? super 类 > 对象名称
意义： 代表使用的泛型只能接收【E类型及其父类型】