Collection集合

集合框架

• Collection接口：所有单列集合最顶层接口

  • List接口：单列集合中的一种

    是有序的集合，允许储存重复的元素，有索引，可以使用普通for循环遍历

    • ArrayList集合：底层是数组实现的，查询快，增删慢
    • LinkedList集合：底层是链表实现的，查询慢，增删快
    • Vector集合

  • Set接口：单列集合中的一种

    不允许储存重复元素，没有索引，不能使用普通for循环遍历

    • HashSet集合：底层是哈希表（+红黑树）实现的，无序集合
    • LinkedHashSet集合：底层是哈希表+链表实现的，有序集合
    • TreeSet集合：底层是二叉树实现，一般用于排序，无序集合

• Collection单列集合共性方法：

  boolean add(E) //增加元素
  boolean contains(E) //判断是否存在某个元素
  boolean remove(E) //删除元素
  boolean isEmpty() //判断集合是否为空
  int size() //获取大小
  Object[] toArray() //集合转换为数组
  void clear() //清空
  

集合遍历

迭代器

• 迭代：集合元素通用获取方式，取出元素前先判断集合中有没有元素，如果有就把该元素取出来，再继续，直到取出所有元素

• 使用Iterator接口对集合进行遍历

  • Iterator迭代器是一个接口，无法直接使用，需要使用Iterator接口的实现类对象

  • Collection接口中有一个方法是Iterator()，返回的是Iterator接口的实现类对象

• 使用步骤：

  • 使用集合中Iterator()方法获取迭代器实现类对象，使用Iterator接口接收（多态）

  • 使用Iterator接口中的hasNext方法判断有没有下一个元素

  • 使用Iterator接口中的Next方法取出集合中的下一个元素

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    //Iterator迭代器
    public class IteratorDemo01 {
        public static void main(String[] args) {
            Collection<String> collection = new ArrayList<>();
            collection.add("hello");
            collection.add("java");
            collection.add("100");
    
            //获取迭代器
            Iterator<String> iterator = collection.iterator();
            //使用Iterator接口中的hasNext方法判断有没有下一个元素，返回boolean值
            while (iterator.hasNext()){
                //使用Iterator接口中的Next方法取出集合中的下一个元素
                System.out.println(iterator.next());
            }
        }
    }
    

增强型for循环

• 底层使用的也是迭代器，使用for循环的格式简化

• 所有单列集合都可以使用增强for循环

• 增强for循环可以用来遍历集合和数组

  for(数据类型 变量名 : 集合名){ // }

  //增强for循环
  for(String s : collection){
      System.out.println(s);
  }
  

泛型

• 泛型是一种未知的数据类型，当不知道使用什么数据类型的时候可以使用泛型，如E

• 创建集合对象的时候就会确定泛型的数据类型

  ArrayList<Student> list = new ArrayList<>();

• 定义含有泛型的类和方法：

  方法格式：修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ //方法体; }

  //定义含有泛型的类
  public class GenericClassDemo<E> {
      private E name;
  
      public E getName() {
          return name;
      }
  
      public void setName(E name) {
          this.name = name;
      }
      
      //定义含有泛型的普通方法
      public <E> void method1 (E e){
          System.out.println(e);
      }
  
      //定义含有泛型的静态方法
      public static <E> void method2(E e){
          System.out.println("静态方法，输入数据："+e);
      }
      
      public static void main(String[] args) {
              //创建一个泛型为Integer的对象
              GenericClassDemo<Integer> list1 = new GenericClassDemo<>();
              list1.setName(200);
              Integer name1 = list1.getName();
              System.out.println(name1);
          	list1.method1(100);//调用方法时确定泛型
  
              //创建一个泛型为String的对象
              GenericClassDemo<String> list2 = new GenericClassDemo<>();
              list2.setName("小明");
              System.out.println(list2.getName());
          
          	//调用静态方法
         	    GenericClassDemo.method2("200");
          }
  }
  

• 含有泛型的接口：

  //定义含有泛型的接口
  public interface GenericInterface<E> {
      public abstract void method(E e);
  }
  
  ////////////////////////////////////////
  
  /*
  方法一：实现类实现接口，并指定接口泛型，此时覆盖重写和调用方法时默认泛型为指定类型
   */
  public class GenericInterfaceImpl01 implements GenericInterface<Double>{
      @Override
      public void method(Double d) {
          System.out.println("方法一覆盖重写，输入数据："+d);
      }
  }
  
  /*
  方法二：接口用什么泛型，实现类就用什么泛型，创建对象的时候确定泛型类型
   */
  public class GenericInterfaceImpl02<E> implements GenericInterface<E>{
      @Override
      public void method(E e) {
          System.out.println("方法二覆盖重写，输入数据："+e);
      }
  }
  
  ////////////////////////////////////////
  
  public class GenericClassMain {
      public static void main(String[] args) {
          GenericInterfaceImpl01 list3 = new GenericInterfaceImpl01();
          list3.method(8.8);//泛型已经默认为Double
          GenericInterfaceImpl02<String> list4 = new GenericInterfaceImpl02<>();
          list4.method("garen");//创建对象的时候确定泛型类型
      }
  }
  

• 泛型通配符：<?> 表示，代表了任意数据类型

  • 不能创建对象使用

  • 只能作为方法参数使用

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class GenericWildcard {
        public static void main(String[] args) {
            ArrayList<String> list1 = new ArrayList<>();
            list1.add("garen");
            list1.add("temmo");
    
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(100);
            list2.add(200);
    
            arrayPrint(list1);
            arrayPrint(list2);
        }
    
        //定义一个方法能遍历所有类型的ArrayList集合
        //此时不知道泛型类型，用泛型通配符
        public static void arrayPrint(ArrayList<?> list){
            Iterator<?> iterator = list.iterator();//获取迭代器
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            
    //        for(Object o: list){
    //            System.out.println(o);
    //        }
        }
    }