集合框架(集合的由来及集合继承体系图)
集合的由来:
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,Java就提供了集合类。
数组和集合的区别
-
长度区别:数组的长度是固定的而集合的长度是可变的
-
存储数据类型的区别:数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
-
内容区别:数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
集合继承体系图:
package org.westos.demo;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 14:15
*/
public class MyTest {
public static void main(String[] args) {
//需求:我有3个学生,请把这个3个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息。
Student s1 = new Student("a", 30);
Student s2 = new Student("b", 20);
Student s3 = new Student("c", 30);
//定义数组
Student[] students = {s1, s2, s3, new Student("d", 34)};
//Object[] objects = {"str", Integer.valueOf(10), 100};
//遍历输出
for (int i = 0; i < students.length; i++) {
Student student = students[i];
System.out.println(student.getName() + "==" + student.getAge());
}
}
}
class Student {
private String name; //成员变量
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override //之前说过,将Object类中的toString方法进行重写
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
关于上面的一行代码 //Object[] objects = {"str", Integer.valueOf(10), 100};
,虽然被注释掉了,但是还是要在这里讲解一下
- 为什么要引入列表,因为数组的长度不可变,而且数组只能存储一种数据类型的元素,但是列表却具有数组没有的一些优点,比如长度可变,可以存储多种数据类型的元素,这里可以直接调用
ArrsyList
类来创建一个列表, - 但是也可以创建一个
Object
类的数组,因为Object
类是所有类的顶层父类,所以该数组中可以存储多种数据类型的数据,但是在使用里面的元素时要注意要向下转型,而且它毕竟是数组,长度依然不能变 - 通过上图可以看到,在调试的时候,
object[1]
是Integer
类型的,这没的说,因为使用了手动装箱,但是object[2]
为什么也是Integer
类型,因为使用到了自动装箱,也就是说在Object
类的数字中,也是只能存储引用数据类型 - 那么如果我要定义一个列表,之中存放的是我自己自定义的一个类的数据类型,但是Java不知道我这个列表之中存放的是什么类,所以就将
ArrayList
所创建的列表中的所有对象定义为Object
类,因为Object
类是所有子类的顶层父类 - 但是使用
ArrayList
定义一个列表时会存在一个问题,不允许使用基本数据类型,只能用引用数据类型(数组、类、接口)也就是说如果我想在列表中存放int
型无法实现,所以必须对基本数据类型进行包装,包装为Integer
类型,也就是包装类(字符串String是个类)之后才能放进这个列表中中 - 也就是说从
ArrayList
定义的列表中取出的每一个元素都会被默认为使Object
类,要使用列表中的元素时要注意向下转型
集合框架(Collection集合的功能概述)
Collection
接口的功能概述(通过API查看即可得到)
- 添加功能:
-
boolean add(Object obj)
:添加一个元素,因为在这里Java不知道我想给列表中添加的内容是什么类型,所以就会将参数设置为Object
类 -
boolean addAll(Collection c)
:添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
- 删除功能
-
void clear()
:移除所有元素 -
boolean remove(Object o)
:移除一个元素 -
boolean removeAll(Collection c)
:移除一个集合的元素(移除一个以上返回的就是true
),移除的元素是两个集合的交集元素,如果没有交集元素 则删除失败 返回false
- 判断功能
-
boolean contains(Object o)
:判断集合中是否包含指定的元素 -
boolean containsAll(Collection c)
:判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含,才返回true
) -
boolean isEmpty()
:判断集合是否为空
-
长度功能
int size()
:元素的个数 -
交集功能
boolean retainAll(Collection c)
:获取两个集合的交集元素(交集:两个集合都有的元素) -
把集合转换为数组
Object[] toArray()
集合框架(Collection集合的基本功能测试)
代码演示1:
package org.westos.java;
import java.util.ArrayList;
import java.util.Collection;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 14:26
*/
public class MyTest {
public static void main(String[] args) {
//多态
Collection collection = new ArrayList();
//往容器中添加元素
collection.add("a");
collection.add("b");
collection.add(1);
System.out.println(collection);
}
}
在上述代码中,我们新建了一个列表,由于Collection
是个接口,所以只能通过多态来实现实例化,即父类引用指向子类对象,在列表创建完成后,便可以调用对象中的方法,当然,这些方法都被子类进行了重写,这个列表中可以存储多种数据类型,collection.add(1);
这条语句给1
进行了自动装箱
通过System.out.println(collection);
来打印列表中的内容,程序运行结果为:
[a, b, 1]
代码演示2:
package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 14:36
*/
public class MyTest2 {
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add(100);
collection.add(Integer.valueOf(103));
collection.add(100);
collection.add(Integer.valueOf(104));
collection.add(100);
collection.add(Integer.valueOf(104));
collection.add(100);
collection.add(Integer.valueOf(1022));
collection.add(100);
collection.add(Integer.valueOf(103));
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(Integer.valueOf(103));
collection2.add(100);
collection2.add(Integer.valueOf(104));
collection2.add(100);
collection2.add(Integer.valueOf(104));
collection2.add(100);
collection2.add(Integer.valueOf(1022));
collection2.add(100);
collection2.add(Integer.valueOf(103));
//A 集合去addAll(B集合) 把B集合的所有元素放到A集合里面去
boolean b = collection.addAll(collection2);
System.out.println(collection);
System.out.println(collection2);
}
}
这段代码调用了addAll方法,运行结果为:
[100, 103, 100, 104, 100, 104, 100, 1022, 100, 103, 100, 103, 100, 104, 100, 104, 100, 1022, 100, 103]
[100, 103, 100, 104, 100, 104, 100, 1022, 100, 103]
代码演示3:
package org.westos.java;
import java.util.ArrayList;
import java.util.Collection;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 14:43
*/
public class MyTest {
public static void main(String[] args) {
//boolean removeAll (Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
//如果没有交集元素 则删除失败 返回false
Collection collection = new ArrayList();
collection.add("123");
collection.add("456");
collection.add("789");
collection.add("000");
Collection collection2 = new ArrayList();
collection2.add("123");
collection2.add("456");
collection2.add("7889");
// A集合removeAll(B集合) A集合中,会删掉两个集合的交集元素,如果移除之后,A集合中发生变化返回true否则返回false
boolean b = collection.removeAll(collection2);
System.out.println(b);
System.out.println(collection);
System.out.println(collection2);
}
}
代码运行结果为:
true
[789, 000]
[123, 456, 7889]
代码演示4:
package org.westos.java;
import java.util.ArrayList;
import java.util.Collection;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 15:00
*/
public class MyTest {
public static void main(String[] args) {
//多态
Collection collection2 = new ArrayList();
//往容器中添加元素
collection2.add("7889");
collection2.add("123");
collection2.add("555");
//判断集合中是否存在该元素
boolean b = collection2.contains("7889");
boolean b1 = collection2.contains("11111");
System.out.println(b);
System.out.println(b1);
}
}
上述代码运行结果为:
true
false
其他功能:
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
和这些功能都比较类似,在这里不再讲解
集合框架(集合的遍历之集合转数组遍历)
集合的遍历:
toArray() 把一个集合转成数组,其实就是依次获取集合中的每一个元素。
把集合转成数组toArray(),遍历这个数组 可以实现集合的遍历
集合框架(Collection存储自定义对象并遍历)
如果要遍历列表,我们可以通过将列表转换为数组之后遍历数组,实现对列表的间接遍历
代码示例:
package org.westos.demo5;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 15:29
*/
public class MyTest2 {
public static void main(String[] args) {
Collection collection = new ArrayList(); //定义一个新列表
collection.add(10);
collection.add(20);
collection.add(30);
collection.add(40);
collection.add(60);
collection.add(50);
collection.add(60);
//把集合转换成数组
Integer[] integer=new Integer[collection.size()]; //确定数组的长度
//遍历集合
Iterator iterator = collection.iterator();
int index=0;
while (iterator.hasNext()){
Object obj = iterator.next();
Integer integer1= (Integer) obj;
integer[index]=integer1;
index++;
}
System.out.println(Arrays.toString(integer));
}
}
这是根据我们之前讲解的知识实现将列表转换为数组,先创建一个和列表等长的数组,之后获得列表的迭代器,在迭代的同时获取将每个元素并且向下转型,将转型后的Integer类的对象赋给数组对应位置上的元素,之后就会实现将列表转换为数组
但是也可以使用现成的方法:
Object[] objects = collection.toArray();
Object object = objects[0];
Integer integer = (Integer) object;
System.out.println(integer + 100);
在这段代码中直接使用了toArray
方法,来实现将列表转换为数组,由于转换后的数组类型是Object
类,所以在访问其中的每个元素时要注意向下转型,最后一句代码还使用到了自动拆箱
集合框架(集合的遍历之迭代器遍历)
迭代器概述: 对 collection 进行迭代的迭代器
该接口中的方法:
boolean hasNext()
,如果仍有元素可以迭代,则返回true
。E next()
,返回迭代的下一个元素。(这里E
和泛型有关,后面会讲到)void remove()
,从迭代器指向的collection
中移除迭代器返回的最后一个元素(可选操作)。
代码示例:
package org.westos.demo3;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 15:07
*/
public class MyTest {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
//往容器中添加元素
collection1.add("a");
collection1.add("b");
collection1.add("c");
//获取一个迭代器
//Iterator 对 collection 进行迭代的迭代器。
//boolean hasNext ()
//如果仍有元素可以迭代,则返回 true。
//E next ()
//返回迭代的下一个元素。
Iterator iterator = collection1.iterator();
System.out.println(iterator);
while (iterator.hasNext()){
Object obj = iterator.next();//让指针下移
System.out.println(obj); //在使用元素时最好进行向下转型
}
}
}
在上段代码中可以看到,使用到了迭代器Iterator
,Iterator
是个接口,通过多态来实现实例化
-
可以看到
Iterator iterator = collection1.iterator();
通过这段代码就可以获得该列表collection1
的迭代器iterator
-
执行上段代码,
System.out.println(iterator);
的输出结果为:java.util.ArrayList$Itr @ 1540e19d
,这是内部类编译过后的class文件名ArrayList$Itr
,(内部类:可以直接访问外部类的成员,包括私有的) -
如果我们使用文本而不使用环境来编写Java程序,那么如果在一个类中有内部类,在编译的时候就会编译生成两个class文件,一个是本类,一个是内部类
-
之后通过
while
循环迭代每一个元素while (iterator.hasNext()){ Object obj = iterator.next();//让指针下移 System.out.println(obj); }
代码便可以实现对列表中元素的遍历
代码示例2:
package org.westos.demo4;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* @Author: Administrator
* @CreateTime: 2019-05-02 15:19
*/
public class MyTest {
public static void main(String[] args) {
Student s1 = new Student("1", 30);
Student s2 = new Student("2", 20);
Student s3 = new Student("3", 30);
Collection collection=new ArrayList();
collection.add(s1);
collection.add(s2);
collection.add(s3);
collection.add(new Student("4",24));
//遍历
Iterator iterator = collection.iterator();
// iterator.next();//手动移动了一下指针
while (iterator.hasNext()){
Object obj = iterator.next();
//向下转型
Student student= (Student) obj;
System.out.println(student.getName()+"==="+student.getAge());
}
}
}
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override //重写Object类中的toString方法
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
在上述代码中自定义了Student
类,,并且向列表中加入了3个Student
类的对象,之后遍历列表,在遍历同时向下转型,打印每个对象的成员变量。比较容易理解
在这里顺带提一下:
int size = collection1.size();//获取集合的长度
size
方法可以获取结合列表长度