目录
1.集合的概述
集合、数组都是对多个数据进行存储操作的结构,简称Java容器
- 说明:此时的存储,指的是内存层面的存储,不涉及到持久化的存储
集合和数组既然都是容器,它们有啥区别呢?
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储基本数据类型值,也可以存储对象
int []arr = new int[10];
Student []arr = new Student[10];
- 集合只能存储对象,而且对象的类型可以不一致,而对于基本类型可以使用它的包装类存储。在开发中一般当对象多的时候,使用集合进行存储。
ArrayList<Student>
//对于基本类型,可以使用它的包装类来存储
ArrayList<Integer>
- 数组中提供的方法非常有限,对于添加、删除、插入数据、获取数组中实际元素的个数的需求等都没有现成的属性和方法可用
- 数组中存储数据的特点是:有序(按照索引有顺序的存放),可重复(元素可以相同),对于无序、不可重复的需求,不能满足
集合应用的简单场景举例:
2.集合框架图
说明:下图来源于http://www.cnblogs.com/xiaoxi/p/6089984.html
所有集合类都位于java.util包下,集合按照其存储结构可以分为两大类,分别是
- 单列集合
java.util.Collection
- 双列集合
java.util.Map
3.Collection接口
Collection是所有单列集合的父接口,Collection接口有两个主要的子接口List和Set,注意Map不是Collection的子接口
(1)常用方法
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(): 把集合中的元素,存储到数组中。
public Iterator<E> iterator():返回在此 collection 的元素上进行迭代的迭代器。(在后文中演示)
(2)方法使用演示
package Collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
//创建集合对象,可以使用多态
Collection<String> coll =new ArrayList<>();
System.out.println(coll); //重写了toString方法
//1.演示add
System.out.println("-----------1.演示add---------");
boolean b1=coll.add("张三");
System.out.println(b1);
coll.add("李四");
coll.add("王五");
System.out.println(coll);
//2.演示remove
System.out.println("-----------2.演示remove---------");
boolean b2=coll.remove("王五");
System.out.println(b2);
boolean b3=coll.remove("李五");
System.out.println(b3);
//3.演示contains
System.out.println("-----------3.演示contains---------");
boolean b4=coll.contains("赵四");
System.out.println(b4);
//4.演示isEmpty
System.out.println("-----------4.演示isEmpty---------");
boolean b5=coll.isEmpty();
System.out.println(b4);
//5.演示size
System.out.println("-----------5.演示size---------");
int size=coll.size();
System.out.println("size:"+size);
//6.演示toArray
System.out.println("-----------6.演示toArray---------");
Object[] arr=coll.toArray();
for (int i = 0; i <arr.length ; i++) {
System.out.println(arr[i]);
}
//7.演示clear
coll.clear();
System.out.println(coll);
System.out.println(coll.isEmpty());
}
}
4.Iterator接口
集合有很多种,每种集合的存储方式不同,取出元素的方式不一样,于是就出现了迭代器,迭代器是一种通用的取出集合中元素的方式
注意,在Java中迭代器是仅仅是Collection集合元素的通用获取方式,不能用于Map,因为Collection实现了Iterable接口,而Iterable就是定义的就是返回迭代器的方法
在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
注意:Iterator是一个接口,我们无法直接使用,需要使用Iterator实现类对象,我们可以使用Collection的iterator返回一个迭代器的实现类对象
Iterator接口的常用方法如下:
public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代,则返回 true。
迭代器的使用演示:
package Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* java.util.Iterator接口
*/
public class IteratorDemo1 {
public static void main(String[] args) {
Collection<String> coll=new ArrayList<>();
coll.add("Jack");
coll.add("Mark");
coll.add("LiLy");
coll.add("Lucy");
//1.使用Collection的方法iterator()来获取迭代器的实现类对象,使用Iterator接口接收(多态),并且迭代器是有泛型的,
//迭代器的泛型跟着集合的泛型走
Iterator<String> iter= coll.iterator();
//2.使用Iterator接口中的方法hasNext()判断有没有下一个元素
while(iter.hasNext())
{
//3.使用Iterator接口中的方法next()取出集合中的下一个元素
String e=iter.next();
//注意next函数每被调用一次都会让迭代器的指针向后迭代1,所以不要在循环中多次使用next函数
//当后面要多次使用下一个元素的值时,应该先用一个局部变量保存next()的返回值,
// 再操作局部变量,而不是在使用时每次调用next函数
System.out.println(e);
}
/*
//for循环的使用方式
for(Iterator iter=coll.iterator();iter.hasNext();)
{
String s=iter.next();
System.out.println(s);
}
*/
}
}
迭代器的原理剖析:
注意:在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发java.util.NoSuchElementException没有集合元素的错误。
5.增强for循环
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
格式:
for(元素的数据类型 变量 : Collection集合or数组)
{
//写操作代码
}
可以看到只要实现了Iterable对象,就可以使用增强for循环遍历,
从前文中可以看到Collection实现了Iterable,所以所有的单列集合即Collection以及其实现类对象就可以使用增强for循环遍历
总结:增强for循环只能用来遍历数组和单列集合
遍历数组示例:
......
int[] arr={1,2,3,4,5};
for(int i:arr)
{
System.out.println(i);
}
......
遍历集合示例:
......
Collection<String> coll=new ArrayList<>();
coll.add("Jack");
coll.add("Mark");
coll.add("LiLy");
coll.add("Lucy");
for(String s:coll)
{
System.out.println(s);
}
......
6.泛型
(1)什么是泛型
泛型是一种未知的数据类型,当我们不知道使用什么数据类型的时候,可以使用泛型
泛型是将数据类型参数化,可以看成是一个形参变量,在给它传参的时候只能传递数据类型
注意:泛型只能是引用类型,不能是基础类型
示例:
如下,ArrayList在定义的时候不知道集合中都会存储什么类型的数据,所以类型使用泛型
//E:未知的数据类型
public class ArrayList<E>
{
public boolean add(E e){}
public E get(int index){}
}
创建集合对象的时候,就会确定泛型的数据类型
(2)创建集合对象时使用和不使用泛型的对比
创建时不使用泛型:
- 好处:
- 集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
- 弊端:
- 不安全,会引发异常
package Generic;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo1 {
public static void main(String[] args) {
show01();
}
/*
创建集合对象,不使用泛型
好处:
集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
弊端:
不安全,会引发异常
*/
private static void show01() {
ArrayList list = new ArrayList();
list.add("abc");
list.add(1);
//使用迭代器遍历list集合
//获取迭代器
Iterator it = list.iterator();
//使用迭代器中的方法hasNext和next遍历集合
while(it.hasNext()){
//取出元素也是Object类型
Object obj = it.next();
System.out.println(obj);
//想要使用String类特有的方法,length获取字符串的长度;不能使用 多态 Object obj = "abc";
//需要向下转型
//会抛出ClassCastException类型转换异常,不能把Integer类型转换为String类型
String s = (String)obj;
System.out.println(s.length());
}
}
}
创建时使用泛型:
- 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
package Generic;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo1 {
public static void main(String[] args) {
show01();
}
/*
创建集合对象,使用泛型
好处:
1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
弊端:
泛型是什么类型,只能存储什么类型的数据
*/
private static void show01() {
ArrayList<String> list = new ArrayList<>();
list.add("abc");
//list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)
//使用迭代器遍历list集合
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s+"->"+s.length());
}
}
}
注意:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
(3)泛型的定义和使用
1)泛型类的定义和使用
定义格式:
修饰符 class 类名<代表泛型的变量> { }
示例:
package Generic;
public class GenericDemo2 {
public static void main(String[] args) {
//不写泛型默认为Object类型
GenericClass gc = new GenericClass();
gc.setName("只能是字符串");
Object obj = gc.getName();
//创建GenericClass对象,泛型使用Integer类型
GenericClass<Integer> gc2 = new GenericClass<>();
gc2.setName(1);
Integer name = gc2.getName();
System.out.println(name);
//创建GenericClass对象,泛型使用String类型
GenericClass<String> gc3 = new GenericClass<>();
gc3.setName("小明");
String name1 = gc3.getName();
System.out.println(name1);
}
}
class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
2)含有泛型的方法定义和使用
定义格式:
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}
示例:
package Generic;
/*
测试含有泛型的方法
*/
public class GenericDemo3 {
public static void main(String[] args) {
//创建GenericMethod对象
GenericMethod gm = new GenericMethod();
/*
调用含有泛型的方法method01
传递什么类型,泛型就是什么类型
*/
gm.method01(10);
gm.method01("abc");
gm.method01(8.8);
gm.method01(true);
gm.method02("静态方法,不建议创建对象使用");
//静态方法,通过类名.方法名(参数)可以直接使用
GenericMethod.method02("静态方法");
GenericMethod.method02(1);
}
}
/*
定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
格式:
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}
含有泛型的方法,在调用方法的时候确定泛型的数据类型
传递什么类型的参数,泛型就是什么类型
*/
class GenericMethod {
//定义一个含有泛型的方法
public <M> void method01(M m){
System.out.println(m);
}
//定义一个含有泛型的静态方法
public static <S> void method02(S s){
System.out.println(s);
}
}
3)泛型接口的定义与使用
示例:
定义一个含有泛型的接口
package Generic;
/*
定义含有泛型的接口
*/
public interface GenericInterface<E> {
public abstract void method(E e);
}
实现方式1:
package Generic;
/*
含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
public interface Iterator<E> {
E next();
}
Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
public final class Scanner implements Iterator<String>{
public String next() {}
}
*/
public class GenericInterfaceImpl1 implements GenericInterface<String>{
@Override
public void method(String s) {
System.out.println(s);
}
}
实现方式2:
package Generic;
/*
含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
public interface List<E>{
boolean add(E e);
E get(int index);
}
public class ArrayList<E> implements List<E>{
public boolean add(E e) {}
public E get(int index) {}
}
*/
public class GenericInterfaceImpl2<E> implements GenericInterface<E> {
@Override
public void method(E e) {
System.out.println(e);
}
}
测试类:
package Generic;
/**
* 测试含有泛型的接口
*/
public class GenericDemo4 {
public static void main(String[] args) {
GenericInterfaceImpl1 geninter1=new GenericInterfaceImpl1();
geninter1.method("字符串");
GenericInterfaceImpl2<Integer> geninter2=new GenericInterfaceImpl2<>();
geninter2.method(100);
GenericInterfaceImpl2<Double> geninter3=new GenericInterfaceImpl2<>();
geninter3.method(12.1);
}
}
(4)泛型通配符的使用
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
1)通配符基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。
示例:
package Generic;
import java.util.ArrayList;
import java.util.Iterator;
/*
泛型的通配符:
?:代表任意的数据类型
使用方式:
不能创建对象使用
只能作为方法的参数使用
*/
public class GenericDemo5 {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(2);
ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("b");
printArray(list01);
printArray(list02);
//定义泛型的时候不能使用泛型通配符
//ArrayList<?> list03 = new ArrayList<?>();
}
/*
定义一个方法,能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型
注意:
泛型没有继承概念的,Collection list = new ArrayList();这种是错误的。
*/
public static void printArray(ArrayList<?> list){
//使用迭代器遍历集合
Iterator<?> it = list.iterator();
while(it.hasNext()){
//it.next()方法,取出的元素是Object,可以接收任意的数据类型
Object obj = it.next();
System.out.println(obj);
}
}
}
2)通配符高级使用----受限泛型
上述在使用泛型时传递给泛型的数据类型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中使用泛型时可以指定一个泛型的上限和下限。
泛型的上限:
- 格式:
类型名称 <? extends 类 > 对象名称
- 意义:
只能接收该类型及其子类
泛型的下限:
- 格式:
类型名称 <? super 类 > 对象名称
- 意义:
只能接收该类型及其父类型
示例:
package Generic;
import java.util.ArrayList;
import java.util.Collection;
public class GenericDemo6 {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement1(list1);
//getElement1(list2);//报错
getElement1(list3);
//getElement1(list4);//报错
//getElement2(list1);//报错
//getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
/*
类与类之间的继承关系
Integer extends Number extends Object
String extends Object
*/
}
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
}