集合

Collection集合

概述

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

集合与数组的区别

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值，也可以存储对象。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

java.util.Collection类是所有单列集合的根接口；

集合框架

JAVASE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用哪个类，以及类之间如何彼此合作，从而达到灵活应用。

学习集合的目标

1.会使用集合存储数据

2.会遍历集合，把数据取出来

3.掌握每种集合的特性

集合框架示意图

Java集合类主要是由两个根接口Collection和Map派生出来的。

Collection接口定义的是所有单列集合中共性的方法；所有单列集合都可以使用共性的方法；没有的带索引的方法。

• List接口：有序的集合（存储和取出元素顺序相同）；允许有重复的元素；有索引，可以使用普通的for循环遍历。
• Set接口：不允许存储重复的元素；没有索引，不能使用普通的for循环遍历。TreeSet和HashSet是无序的集合（存储和取出元素顺序可能不同），LinkedHashSet是有序的集合。

集合框架的学习方式：

学习顶层：学习顶层接口/抽象类中共性的方法，所有子类可以使用；

使用底层：顶层不是接口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用。

Collection集合常用功能 (共性方法)

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

• 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(): 把集合中的元素，存储到数组中。

代码演示

package cn.shenzc.java.demo05;

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

public class TestCollection {
    public static void main(String[] args) {
        //使用多态创建一个Collection对象
        Collection<String> list = new ArrayList<>();
        //打印ArrayList对象，重写了toString方法
        System.out.println(list);
        //isEmpty方法判断该集合是否为空，如果为空，则返回true；不为空，则返回false
        System.out.println(list.isEmpty());
        //通过add方法向集合中添加元素，添加成功返回true，添加失败返回false。一般都是添加成功
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("田七");
        //添加完元素后再次判断集合是否为空
        System.out.println(list.isEmpty());
        //用size方法得到集合中元素的个数
        System.out.println(list.size());
        System.out.println(list);
        //用remove方法删除集合中对应的元素，如果存在该元素则删除该元素返回true；否则返回false
        list.remove("赵六");
        System.out.println(list);
        System.out.println(list.remove("赵四"));
        //用cotains方法判断集合中是否包含指定元素，包含则返回true，否则返回false
        System.out.println(list.contains("赵四"));
        //用toArray方法将集合转为对象数组
        Object[] arr = list.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //用clear方法，清空集合
        list.clear();
        System.out.println(list.size());
        System.out.println(list);
    }
}

Iterator接口

接口介绍

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

• public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

下面介绍一下迭代的概念：

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

常用方法

boolean hasNext()：Returns true if the iteration has more elements.
E next()：Returns the next element in the iteration.

Iterator是一个接口，我们无法直接使用，需要使用Iterator的实现类来创建对象使用。但是获取实现类的方法比较特殊，我们可以利用Collection接口中的interator方法的返回值来创建一个Iterator接口的实现类对象。

迭代器的使用步骤

1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）；(Iterator也是有泛型的，集合是什么泛型，Iterator就是什么泛型)

2、使用Iterator接口中的方法hasNext判断集合中是否还有下一个元素；
3、使用Iterator接口中的方法next取出集合中的下一个元素

当没有下一个元素,执行next方法会报NoSuchElementException

代码演示

package cn.shenzc.java.demo06;

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

public class TestIterator {
    public static void main(String[] args) {
        //用多态创建一个Collection对象
        Collection<String> coll = new ArrayList<>();
        //向集合中添加一些元素，可以使用Collection的add方法
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        //用Collection接口中的iterator()方法创建一个Iterator接口的实现类对象
        //迭代器的泛型与Collection的泛型一致
        Iterator<String> iterator = coll.iterator();
        //用Iterator接口中的hasNext方法判断集合中是否还有下一个元素，再用next方法获取下一个元素
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

增强for循环

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

格式

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

//其他操作

}

代码演示

package cn.shenzc.java.demo07;

public class TestForEach {
    public static void main(String[] args) {
        //定义一个整形数组
        int[] arr1 = {1,2,3,4,5,6};
        //利用增强for循环遍历数组
        for(int i : arr1){
            System.out.print(i + " ");
        }
        System.out.println();
        //定义一个字符串数组
        String[] arr2 = {"hello","java"};
        //用增强for循环遍历
        for(String s : arr2){
            System.out.print(s + " ");
        }
    }
}

泛型

泛型概述

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储到集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

大家观察下面代码：

public class GenericDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}

程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？ Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预支地使用未知的类型。

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

使用泛型的好处

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

弊端

集合只能存取特定类型的数据

定义和使用含有泛型的类

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

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }

    public MVP getMVP() {
        return mvp;
    }
}

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

泛型定义在方法的修饰符和返回值之间

格式：

修饰符 <泛型> 返回值类型 方法名 （参数列表（使用泛型））{

}

含有泛型的方法，在调用方法时确定泛型的类型

package space.buercheng.java.demo01;

public class GenericMethod {
    public <M> void method(M m){
        System.out.println(m);
    }

    public static void main(String[] args) {
        GenericMethod ge = new GenericMethod();
        ge.method(4);
        ge.method("abc");
    }
}

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

定义

格式

修饰符 interface 接口名<泛型>{}

例如：

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

使用

1.定义类时确定泛型类型

package space.buercheng.java.demo02;
//在定义类时确定泛型的类型
public class GenericInterfaceImpl1 implements MyGenericInterface<String>{
    @Override
    public void add(String s) {

    }
}

2.接口是什么泛型，实现类就是什么泛型，在实现类创建对象时确定泛型类型

package space.buercheng.java.demo02;
//接口是什么泛型，实现类就是什么泛型，在实现类创建对象时确定泛型类型
public class GenericInterfaceImpl2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
    }
}

package space.buercheng.java.demo02;

public class TestGenericInterface {
    public static void main(String[] args) {
        GenericInterfaceImpl1 ge1 = new GenericInterfaceImpl1();
        ge1.add("abc");
        GenericInterfaceImpl2<String> ge2 = new GenericInterfaceImpl2<>();
        ge2.add("CDD");
        GenericInterfaceImpl2<Integer> ge3 = new GenericInterfaceImpl2<>();
        ge3.add(2);
    }
}

泛型的通配符

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

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

package space.buercheng.java.demo03;

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

public class Wildcard {
    public static void main(String[] args) {
        Collection<String> coll1 = new ArrayList<>();
        Collection<Integer> coll2 = new ArrayList<>();
        method(coll1);
        method(coll2);
    }

    public static void method(Collection<?> coll){
        
    }
}

通配符高级使用—-受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

package space.buercheng.java.demo03;

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

public class LimitedWildcard {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();
        method1(list1);
        method1(list2);
        method1(list3);
        method1(list4);
        
        method2(list1);
        method2(list2);
        method2(list3);
        method2(list4);
    }

    public static void method1(Collection<? extends Number>coll){}
    public static void method2(Collection<? super Number>coll){}
}