Collection,泛型,Map

1.Collection集合

集合和数组的区别？

• 数组的长度是固定的， 集合的长度是可变的
• 数组中存储的数据都是同一类型的数据。集合存储的是对象，而且对象的类型可以不一致

集合框架

单列集合

java.util.Collection

Collection：单列集合的跟接口，用于存储一系列的规则的元素

两个子接口：

• java.util.List: List中元素是有序，元素可重复
  • 实现类：java.util.ArrayList, java.util.LinkedList
• Java.util.Set: Set中元素无序，不重复
  • 实现类：java.util.HashSet, java.util.TreeSet

Collection集合的常用功能

Collection是所有单列集合的父接口，因此定义了一些通过方法

• public boolean add(E, e):添加元素到集合中

• public void clear():清空集合中所有的元素

• public boolean remove(E, e):删除指定的元素

• public boolean contains(E, e):判断当前集合是否存在给定的元素

• public boolean isEmpty():判断当前集合是否为空

• public int size():返回集合中元素的个数

• public Object[] toArray():把集合的元素存储到数组中

  import java.util.ArrayList;
  import java.util.Colleaction;
  
  public class Demo{
    public static void main(String[] args){
      // 创建集合对象，使用多态
      Collection<String> coll new ArrayList<String>();
      //使用方法
      // 添加
      coll.add("杨幂").add("刘亦菲").add("唐嫣").add("胡珺");
      System.out.println(coll);
      // 判断是否在集合中
      System.out.println("判断胡珺是否在集合中"+coll.contains("胡珺"));
      // 判断集合是否为空
      System.out.println(coll.isEmpty());
      // 集合中有多少个元素
      System.out.println(coll.sixe());
      // 删除指定的元素
      coll.remove("胡珺");
      // 集合存储到数组中
      Object[] object = coll.toArray();
      //遍历数组
      for(int i=0;i<object.length;i++){
        System.out.println(i);
      }
      // 清空集合
      coll.clean();
    }
  }
  

2.Iterator迭代器

迭代

• 在集合中获取元素之前进行判断集合中有没有元素，如果有取出来，继续进行判断，继续取出来，知道集合元素全部取出

Iterator的常用方法

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

public class Demo{
  public static void main(String[] args){
    //使用多肽创建集合
    Collection<String> coll = new ArrayList<String>();
    // 添加元素
    coll.add("杨幂").add("胡珺").add("程锐");
    //使用迭代器进行遍历
    Iterator<String> it = coll.iterator();
    // 泛型值得是： 迭代出来的数据类型
    while(it.hasNext()){//判断是否有迭代元素
      String s = it.next(); //获取迭代的元素
      System.out.println(s);
    }
  }
}

增强for

格式：

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

它用于变量Collection和数组， 不要在遍历的时候对集合元素进行曾删操作

public class Demo{
  public static void main(String[] args){
    int[] arr = {1,2,3,4,5};
    for(int i:arr){
      System.out.println(i);
    }
  }
}

public class Demo{
  public static void main(String[] args){
    Collection<String> coll = new ArrayList<String>();
    coll.add("112");
    coll.add("113");
    coll.add("114");
    for(String s:coll){
      System.out.println(s);
    }
  }
}

只针对Collection和数组， 用于遍历

3.泛型

在从集合中存取数据，数据将被提升为Object类型，当我们取出一个的对象，进行操作，这个时候需要类型转换

• 泛型：可以再类或者是方法中预支的使用未知的数据类型

  一般在创建对象是，当没有指定类型的时候，默认是Object类型

泛型好处

• 将运行售后的ClassCastException,转移到了编译时期变成编译失败
• 避免了类型强转的麻烦

public class Demo{
  public static void main(String[] args){
    collection<String> coll = new ArrayList<String>();
    coll.add("abd");
    coll.add("aaa");
    //coll.add(5); 当集合明确类型后， 存放类型不一致就会编译错误
    // 集合已经明确的具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样知道具体遍历元素类型
    Iterator<String> it = coll.iterator();
    while(it.hasNext()){
      //当使用Iterator控制的元素类型之后，就不要强转了，获取的元素就是String类型
      String str = it.next();
      System.out.println(str);
    }
  }
}

泛型是数据泛型的一部分，我们将类名和泛型合并起来一起看做数据类型

泛型的定义与使用

我们在集合中通常使用到了泛型

泛型，用来灵活的将数据类型应用到不同的类，方法，接口当中。将数据类型作为参数进行传递

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量>{}

demo

ArrayList集合;
public class ArrayList<E>{
  public boolean add(E e){}
  public E get(int index){}
  ....
}

使用泛型：即什么时候确定泛型

在创建对象的时候使用泛型

例如：ArrayList list = new ArrayList();

此时就可以理解变量E的值就是String类型，那么理解为

public class ArrayList<String>{
  public boolean add(String e){}
  public String get(int index){}
}

再例如，ArrayList list = new ArrayList();

此时理解为E的值就是Integer

public class ArrayList<Integer>{
  public boolean add(Integer e){}
  public Integer get(int index){}
}

demo

public class MyGenericClass<MVP>{
  //没有MVP类型，在这里带变得是一种未知类型， 传递什么类型就是什么类型
  private MVP mvp;
  public void setMVP(MVP mvp){
    this.mvp = mvp;
  }
  public MVP getMVP(){
    return mvp;
  }
}

使用

public class GenericClassDemo{
  public static main(String[] args){
    // 创建一个泛型为Integer的类
    MyGenericClass<Integer> myNum = new MyGenericClass<Integer>();
    myNum.setMVP(124);
    Integer mvpNum = myNum.getMVP();
    System.out.println(mvpNum);
    
    //创建一个泛型为String的类
    MyGenericClass<String> myStr = new MyGenericClass<String>();
    myNum.setMVP("哈哈");
    String mvpStr = myStr.getMVP();
    System.out.println(mvpStr);
  }
}

含有泛型的方法

定义格式：

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

例如

public class MyGenericMethod{
  public <MVP> void show(MVP mvp){
    System.out.println(mvp.getClass());
  }
  public <MVP> MVP show2(MVP mvp){
    return mvp;
  }
}

使用格式： 调用方法时，确定泛型的类型

public class GenericMethodDemo{
  public static void main(String[] args){
    //创建对象
    MyGenericMethod mm = new MyGenericMethod();
    //演示看方法提示
    mm.show("aaa");
    mm.show(12);
  }
}

含有泛型的接口

定义格式：

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

例如

public interface MyGenericInterFace<E>{
  public abstract void add(E e);
  public abstract E getE();
}

使用格式：

1.定义类是确定泛型的类型

例如

public class MyImpl implements MyGenericInterFace<String>{
  @Override
  public void add(String e){
    //...
  }
  @Override
  public void getE(){
    return null;
  }
}
//此时泛型E的值就是String类型

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

例如

public class MyImpl<E> implements MyGenericInterFace<E>{
  @Override
  public void add(E e){
    //...
  }
  @Override
  public void getE(){
    return null;
  }
}

确定泛型：

public class GenericInterFace{
  public static void main(String[] args){
    MyImpl<String> my = new MyImpl<String>();
    my.add("aaa");
  }
}

泛型通配符

当我们使用泛型或者是接口的时候，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符之后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用。

通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用？？表示未知通配符

此时只接受数据，不能再集合中存储数据

例子：

public class Demo{
  public static void main(String[] args){
  	Collection<Integer> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
	}
  public static void getElement(Collection<?> coll){
    // ? 代表可以接受任意类型
  }
}

泛型不存在继承关系，Collection