Java面向对象—集合框架

一、集合框架简介

1、数组

int [] arr=new int[50];
arr[0]=12;
arr[1]=13;
arr[2]=15;

数组：长度固定不变，可以通过.length获取长度，且不能获取实际值的个数 内存中采用连续空间存储，效率底下

如何解决这个问题呢？

2、集合框架

那么集合到底是什么呢? ●集合:集合是java中提供的一种容器,可以用来存储多个数据。 集合和数组既然都是容器,它们有啥区别呢? ●数组的长度是固定的。集合的长度是可变的。 ●数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一 致。在开发中一般当对象多的时候,使用集合进行存储。

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

集合按照其存储结构可以分为两大类,分别是单列集合java.util.collection 和双列集合java.util.Map

集合框架：是位于java.util包中的一套性能优良、使用方便的接口和类

3、ArrayList：连续空间 a b a b c d e

0 1 2 3 4 5 6

4、LinkedList：链表 a——b——a——b——c——d

二、集合中的常用方法：

• boolean add(Object O) 在列表的末尾顺序添加元素，起始索引位置从0开始

• void add(int index,Object O) 在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间

• int size() 返回列表中的元素个数

• Object get(int index) 返回指定索引位置处的元素。取出的元素是Object类型,使用前需要进行强制类型转换

• boolean contains(Object O) 判断列表中是否存在指定元素

• boolean remove(Object O) 从列表中删除元素

• Object remove(int index) 从列表中删除指定位置元素，起始索引位置从0开始

三、ArrayList实现类

1、使用ArrayList实现类演示集合中的各个方法

案例：使用List集合存储狗狗信息，获取狗狗数量，按顺序打印狗狗信息，删除狗狗等。

//1、创建狗狗对象
Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
//Dog d4=new Dog("小黄","拉布拉多");//注意不是同一个对象
//2、创建ArrayList集合，使用add()方法存储狗狗对象
List dogs=new ArrayList();
dogs.add(d1);
dogs.add(d2);
dogs.add(d3);
dogs.add(2,d4);
//3、获取狗狗数量
System.out.println("集合中狗狗的数量："+dogs.size());
//4.输出每条狗狗的信息
for (int i = 0; i < dogs.size(); i++) {
    //获取对象信息，获取到的是Object类型，需要强转
    Dog dog=(Dog) dogs.get(i);
    System.out.println("姓名："+dog.getName()+",品种："+dog.getStrain());
}
//5、删除一只狗狗
//dogs.remove(4);//下标越界，下标从0开始，到大小的位置
dogs.remove(3);
//dogs.remove(d1);
System.out.println("集合中狗狗的数量："+dogs.size());
//6、增强for循环，for-each
for (Object o:dogs) {
    Dog d=(Dog) o;
    System.out.println(d.getName());
}
//7、查询集合中是否包含某个狗狗
if (dogs.contains(d1)){
    System.out.println("集合中有小黄");
}else {
    System.out.println("集合中没有小黄");
}

2、泛型

泛型代表集合中数据的类型，一般都是引用类型和包装类。

（1）当指定了泛型，使用时就不需要强转了

（2）指定了泛型后，foreach循环中就只能把集合放到指定的泛型中

//1、创建狗狗对象
Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
​
//2.现在的集合是Object类型的，任何值都能存
List list=new ArrayList();
list.add(d1);
list.add(1);
list.add("张三");
//但是获取值时就需要强转
Dog dog=(Dog) list.get(0);
​
//3.当指定了泛型时，就不需要强转了
List<Integer> a=new ArrayList<Integer>();
a.add(11);
//a.add("李四");
List<String> b=new ArrayList<String>();
//b.add(11);
b.add("李四");
//指定泛型为Dog类型
List<Dog> d=new ArrayList<Dog>();
d.add(d1);
d.add(d2);
d.add(d3);
d.add(d4);
for (int i = 0; i < d.size(); i++) {
    Dog dogs=d.get(i);//指定泛型后就不需要强转了
    System.out.println(dogs.getName());
}
//指定了泛型后，foreach循环中就只能把集合放到指定的泛型中
for (Dog dogs1:d) {
    System.out.println(dogs1.getName());
}
d.remove(0);
System.out.println(d.contains(0));

四、LinkedList实现类

1、LinkedList和ArrayList其实是一样的都是不唯一有序，ArrayList存连续空间；LinkedList存链表；

2、LinkedList可以在任何位置（头，中间，尾）做添加、获取、删除操作

3、添加和删除操作频繁时，使用LinkedList效率更高

4、LinkedList额外提供了对头和尾元素做添加、获取、删除操作的方法

addFirst、addLast、getFirst、getLast、removeFirst、removeLast

注意：已上方法是LinkedList类中特有的方法，List接口中没有

案例1：测试LinkedList中的添加，删除，获取等方法

Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
//LinkedList和ArrayList一样，都有添加、获取、删除等方法
List list=new LinkedList();
list.add(d1);
list.add(d2);
list.add(d3);
list.add(d4);
Dog dog=(Dog) list.get(2);
System.out.println(dog.getName());
list.remove(3);
System.out.println(list.size());

案例2：测试LinkedList实现类中特有的方法

Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
//对头尾操作的方法时LinkedList中特有的方法，父类到子类时是调不到的
//List list=new LinkedList();
//list.add(d1);
//list.addFirst(d2);//特有，调不到
//list.addLast(d3);
LinkedList<Dog> list=new LinkedList<Dog>();
list.add(d1);
list.add(d2);
list.addFirst(d3);
list.addLast(d4);
Dog d= list.get(2);
System.out.println(d.getName());
d= list.getFirst();
System.out.println(d.getName());
d= list.getLast();
System.out.println(d.getName());
System.out.println("删除前："+list.size());
list.removeFirst();
list.removeLast();
System.out.println("删除后："+list.size());
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i).getName());
}
System.out.println("----------------");
for (Dog dog:list) {
    System.out.println(dog.getName());
}

五、set集合测试：

1、set集合是无序的

2、set集合中添加时不能指定位置，也没有get()方法。

3、删除时只能删除指定的对象，不能删除指定位置

Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
//创建集合对象
Set<Dog> set=new HashSet<Dog>();
set.add(d1);
set.add(d2);
set.add(d3);
set.add(d4);
//set.add(1,d2); //Set集合是无序的,也没有get()方法
//无序集合只能用foreach循环遍历
for (Dog dog:set) {
    System.out.print(dog.getName()+"\t");
}
System.out.println();
//删除后再输出
set.remove(d1);
for (Dog dog:set) {
    System.out.print(dog.getName()+"\t");
}

六、Map集合测试：

1、Map以键值对形式存取值，键唯一，值不唯一

2、Map集合中指定泛型时，也要指定成键值对形式，键一般都是String类型

3、Map集合中添加数据用put()方法，当键发生重复时，值会出现覆盖现象

4、获取和删除时可以通过键来执行

5、遍历Map集合时，可以先把所有键获取出来存Set集合，再通过遍历键集合来获取值

Dog d1=new Dog("小黄","拉布拉多");
Dog d2=new Dog("小黑","泰迪");
Dog d3=new Dog("小白","金毛");
Dog d4=new Dog("小花","边牧");
//Map集合是键值对形式存储数据，键唯一，值不唯一
//创建Map集合时，泛型要指定成键值对形式，键一般都是String类型
Map<String,Dog> map=new HashMap<String,Dog>();
//添加使用put()方法
map.put("1",d1);
map.put("2",d2);
map.put("3",d3);
map.put("1",d4);//键重复时，后添加的值会覆盖先添加的值
//获取
Dog dog=map.get("1");
System.out.println(dog.getName());
//删除
map.remove("2");
System.out.println(map.size());
​
//循环输出
//把键全部获取出来存到Set集合中
Set<String> str=map.keySet();
//使用foreach循环遍历键集合
for (String s:str){
    //通过遍历键集合取到对象
    Dog d=map.get(s);
    System.out.print(d.getName()+"\t");
}

七、迭代器

java. util. Iterator接口:迭代器(对集合进行遍历)

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

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

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

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

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

有两个常用的方法：

boolean hasNext() 如果仍有元素可以迭代，则返回true。判断集合中还有没有下一个元素,有就返回true,没有就返回false

E next() 返回迭代的下一个元素。取出集合中的下一个元素

Iterator迭代器,是一个接口， 我们无法直接使用，需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象

Iterator<E> iterator() 返回在此Collection 的元素上进行迭代的迭代器。

迭代器的使用步骤(重点):

1.使用集合中的方法iterator( )获取迭代器的实现类对象,使用Iterator接口接收(多态)

2.使用Iterator接口中的方法hasNext判断还有没有下一个元素

3.使用Iterator接口中的方法next取出集合中的下一个元素

Dog d1 = new Dog("小黄", "拉布拉多");
Dog d2 = new Dog("小黑", "泰迪");
Dog d3 = new Dog("小白", "金毛");
Dog d4 = new Dog("小花", "边牧");

//ArrayList
List list =new ArrayList();//Object类型
list.add(d1);
list.add(d2);
list.add(d3);
list.add(d4);
//1、把list集合元素放到迭代器中
Iterator i=list.iterator();
//2、判断迭代器中是否有下一个元素
while (i.hasNext()){
    //3、取出迭代器中下一个元素
    Object o=i.next();//存Object类型
    Dog d=(Dog) o;//转型
    System.out.print(((Dog) o).getName()+"\t");
}

//LinkedList
List list1=new LinkedList();
list1.add(d1);
list1.add(d2);
list1.add(d3);
list1.add(d4);
//1、把list1集合元素放到迭代器中
Iterator i1=list1.iterator();
//2、判断迭代器中是否有下一个元素
while (i1.hasNext()){
    //3、取出迭代器中下一个元素
    Object o=i1.next();//存Object类型
    Dog d=(Dog) o;//转型
    System.out.print(((Dog) o).getName()+"\t");
}

//HashSet
Set set=new HashSet();
set.add(d1);
set.add(d2);
set.add(d3);
set.add(d4);
//1、把set集合元素放到迭代器中
Iterator i3=set.iterator();
//2、判断迭代器中是否有下一个元素
while (i3.hasNext()){
    //3、取出迭代器中下一个元素
    Object o=i3.next();//存Object类型
    Dog d=(Dog) o;//转型
    System.out.print(((Dog) o).getName()+"\t");
}

//HashMap
Map<String,Dog> map=new HashMap<String,Dog>();
map.put("1",d1);
map.put("2",d2);
map.put("3",d3);
map.put("4",d4);
//把键取出来存Set集合
Set<String> s=map.keySet();
//1、把键集合元素放到迭代器中
Iterator<String> i4=s.iterator();
//2、判断迭代器中是否有下一个元素
while (i4.hasNext()){
    //3、取出迭代器中下一个元素
    String str=i4.next();//存Object类型
    Dog d=map.get(str);
    System.out.print(str+":"+d.getName()+"\t");
}