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类型及其父类型】

posted @ 2020-08-07 19:16 jock_javaEE 阅读(169) 评论(0) 编辑收藏举报

刷新页面返回顶部

暮尘时雨

java基础之集合与泛型

公告