Java面向对象—集合框架-CSDN博客

本文链接：https://blog.csdn.net/JavaMrs/article/details/140103245

一、集合框架简介

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");
}