luliyu-javaday11

Collection、List、泛型

• 集合：集合是java中提供的一种容器，可以用来存储多个引用数据类型的数据。

集合和数组既然都是容器，它们有什么区别呢？

• 数组的长度是固定的。集合的长度是可变的。
• 集合存储的都是引用数据类型。如果想存储基本类型数据需要存储对应的包装类类型。

单列集合常用类的继承体系

Collection：是单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口,分别是

• java.util.List: List的特点是元素有序、元素可重复 ;
  • List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，
• java.util.Set: Set的特点是无序, 元素不可重复。
  • Set接口的主要实现类有java.util.HashSet和java.util.LinkedHashSet，java.util.TreeSet。
    
    注意:上面这张图只是我们常用的集合有这些，不是说就只有这些集合。

单列集合常用类的继承体系:
	Collection集合:接口,是所有单列集合的顶层父接口,该集合中的方法可以被所有单列集合共享
    	List集合: 接口,元素可重复,元素有索引,元素存取有序
        	ArrayList集合: 实现类,查询快,增删慢
            LinkedList集合: 实现类,查询慢,增删快

        Set集合: 接口, 元素不可重复(唯一),元素无索引
            HashSet集合: 实现类,元素存取无序
            LinkedHashSet集合:实现类,元素存取有序
            TreeSet集合:实现类,可以对集合中的元素进行排序

Collection 常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中

package com.claire.day11.collect;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test1 {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<>(); // 多态

        col.add("小鲁班");
        col.add("妲己");
        col.add("后羿");

        System.out.println("Collection = " + col);

        col.remove("妲己");
//        col.clear();
        System.out.println("Collection remove = " + col);

        System.out.println(col.contains("后羿"));
        System.out.println(col.contains("妲己"));
        System.out.println(col.isEmpty());
        System.out.println(col.size());  // 元素个数

        Object[] array = col.toArray();
        String[] arr1 = new String[6];
        System.out.println(array);
        System.out.println(Arrays.toString(array));

    }
}

Iterator迭代器

迭代的概念

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Collection集合提供了一个获取迭代器的方法：
Iterator iterator(); 获取集合对应的迭代器，用来遍历集合中的元素的。

Iterator接口的常用方法

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

public static void main(String[] args) {
        Collection<String> col = new ArrayList<>(); // 多态

        col.add("小鲁班");
        col.add("妲己");
        col.add("后羿");
        Iterator<String> iterator = col.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.print(s +"\t");
        }

    }

增强for

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

for(元素的数据类型  变量 : Collection集合or数组){ 
  	//写操作代码
}

package com.claire.day11.collect;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test3 {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<>(); // 多态

        col.add("小鲁班");
        col.add("妲己");
        col.add("后羿");

        for(String hero:col){
            System.out.println(hero);
        }

        int[] arr = {1, 2, 3, 4, 45, 5};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("++++++++++++++++");
        for (int num: arr){
            System.out.println(num);
        }

    }
}

泛型

• 定义的时候表示一种未知的数据类型,在使用的时候确定其具体的数据类型。

tips:泛型的作用是在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object

定义和使用含有泛型的类

定义含有泛型的类

修饰符 class 类名<代表泛型的变量> {  }
代表泛型的变量: 可以是任意字母  例如: T,E...

public class ArrayList<E>{
  public boolean add(E e);
}

泛型在定义的时候不具体类型，使用的时候才具体类型。在使用的时候确定泛型的具体数据类型。

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}
 Collection<String> col = new ArrayList<>(); 
E 此时就是 String

定义和使用含有泛型的方法

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

public static <T>T method2(T t){
      return t;
  }
String s = method2("haha");
System.out.println(s);

定义和使用含有泛型的接口

修饰符 interface接口名<代表泛型的变量> {  }

定义实现类时确定泛型的类型

接口

public interface IA<E>{
    public void method1(E e);
    public default E method2(E e){
        return e;
    }
}

实现类
实现的时候就确定类型

public class Impl1 implements IA<String>{

    @Override
    public void method1(String s) {
        System.out.println(s);
    }
}

始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class Impl2<E> implements IA<E>{

    @Override
    public void method1(E e) {
        System.out.println(e);
    }

    public static void main(String[] args) {
        // 创建对象 的时候再确定
        Impl2<String> impl2 = new Impl2<>();
        impl2.method1("哈哈");
    }
}

泛型是一种未知的数据类型，定义在类上的泛型，使用类的时候会确定泛型的类型，定义在方法上的泛型，会在使用方法的时候确定泛型，定义在接口上的泛型，需要使用接口的时候确定泛型。

小结

泛型：定义的时候表示一种未知的数据类型,在使用的时候确定其具体的数据类型。
使用含有泛型的类: 创建该类对象的时候,指定泛型的具体数据类型
使用含有方向的方法: 调用该方法的时候,确定泛型的具体数据类型
使用含有泛型的接口:
1.创建实现类实现接口的时候,指定泛型的具体数据类型
2.创建实现类实现接口的时候,不知道泛型的具体数据类型,而是创建实现类对象的时候指定泛型的具体数据类型