24.Collection集合

1.Collection集合

1.1数组和集合的区别【理解】

• 相同点

  都是容器,可以存储多个数据

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的

  • 数组可以存基本数据类型和引用数据类型

    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

1.2集合类体系结构【理解】

 

1.3Collection 集合概述和使用【应用】

• Collection集合概述

  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

• 创建Collection集合的对象

  • 多态的方式

  • 具体的实现类ArrayList

• Collection集合常用方法

  方法名	说明
  boolean add(E e)	添加元素
  boolean remove(Object o)	从集合中移除指定的元素
  boolean removeIf(Object o)	根据条件进行移除
  void clear()	清空集合中的元素
  boolean contains(Object o)	判断集合中是否存在指定的元素
  boolean isEmpty()	判断集合是否为空
  int size()	集合的长度，也就是集合中元素的个数

1.4Collection集合的遍历【应用】

• 迭代器介绍

  • 迭代器,集合的专用遍历方式

  • Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法

  boolean hasNext(): 判断当前位置是否有元素可以被取出 ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

package com.itheima.mycollectiondemo1;

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

public class MyCollectionDemo2 {
    public static void main(String[] args) {
        Collection<String> collection=new ArrayList<>();
        //boolean add(E e)	添加元素
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("dddd");
        //System.out.println(collection);

        //method1(collection);
        //method2(collection);
        //method3(collection);

        //method4(collection);
        //method5(collection);
        method6(collection);
    }

    public static void method6(Collection<String> collection) {
        //int size()	集合的长度，也就是集合中元素的个数
        int size = collection.size();
        System.out.println(size);
    }

    public static void method5(Collection<String> collection) {
        //boolean isEmpty()	判断集合是否为空
        collection.clear();
        boolean result = collection.isEmpty();
        System.out.println(result);
    }

    public static void method4(Collection<String> collection) {
        //boolean contains(Object o)	判断集合中是否存在指定的元素
        boolean result1 = collection.contains("a");
        System.out.println(result1);
        boolean result2 = collection.contains("aaa");
        System.out.println(result2);
    }

    public static void method3(Collection<String> collection) {
        //void clear()	清空集合中的元素
        //就是将集合中所有的元素都删除
        collection.clear();
        System.out.println(collection);
    }

    public static void method2(Collection<String> collection) {
        //boolean removeIf(Object o)	根据条件进行移除
        //removeIf底层会遍历集合，的到集合中的每一个元素
        //s依次表示集合中的每一个元素
        //就会把这每一个元素都到lambda表达式中去判断一下
        //如果返回的是true，则删除
        //如果返回的是false，则保留不删除

        //boolean test(String t);
        collection.removeIf(
                (String s)->{
                    return s.length()==3;
                }
        );
        System.out.println(collection);
    }

    public static void method1(Collection<String> collection) {
        //boolean remove(Object o)	从集合中移除指定的元素
        //如果删除成功了，则返回true
        //如果删除失败了，则返回false
        boolean result1 = collection.remove("aaa");
        boolean result2 = collection.remove("ddd");
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(collection);
    }
}

1.4Collection集合的遍历【应用】

• 迭代器介绍

  • 迭代器,集合的专用遍历方式

  • Iterator<E> iterator(): 返回此集合中元素的迭代器,该迭代器对象默认指向当前集合的0索引

• Iterator中的常用方法

  boolean hasNext(): 判断当前位置是否有元素可以被取出 ​

• E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

package com.itheima.mycollectiondemo1;

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

public class MyCollectionDemo3 {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        //1.获取迭代器对象
        //迭代器对象一旦被创建出来，默认指向集合的0索引处
        Iterator<String> it = list.iterator();
//        //利用迭代器里面的方法进行遍历
//        //当前位置是否有元素可以被取出
//        System.out.println(it.hasNext());
//        //取出当前位置的元素+将迭代器往后移动一个索引的位置
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

　　迭代器小结：

Iterator<E> iterator:创建迭代器对象，默认指向当前集合的0索引。

boolean hashNext():判断当前位置是否有元素可以被取出

E next():获取当前位置　　

　　　　将迭代器对象移向下一个索引位置

 

迭代器中删除的方法

void remove(): 删除迭代器对象当前指向的元素

 　　练习：创建一个集合，有元素a b b c d 

　　使用循环遍历这个集合，判断当前获取到的元素是否为b，如果是就删除

package com.itheima.mycollectiondemo1;

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

public class MyCollectionDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String s=it.next();
            if("b".equals(s)){
                //指向谁,删除谁
                it.remove();
            }
        }
        System.out.println(list);

    }


}

1.5增强for循环【应用】

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器

  • 实现Iterable接口的类才可以使用迭代器和增强for

  • 简化数组和Collection集合的遍历

• 格式

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

  // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

  }

• ArrayList<String> list=new ArrayList<>();
• //添加一些元素
• for(String s:list){
  • 　　System.out.println(i);
• }

• 代码

package com.itheima.mycollectiondemo1;

import java.util.ArrayList;

public class MyCollectionDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        //1.数据类型一定是集合或者数组中元素的类型
        //2.str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3.list就是要遍历的集合或者数组.
        for (String str : list) {
            System.out.println(str);
        }
    }
}

　　注意事项：

在增强for　　中修改第三方变量的值不会影响到集合中的元素

三种循环的使用场景

如果需要操作索引，使用普通for循环

如果在遍历的过程中需要删除元素，请使用迭代器

如果仅仅想遍历，那么使用增强for　　

 案例：Collection集合存储学生对象并遍历

需求：创建一个Collection集合存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

　　思路：

1.定义学生类

2.创建Collection集合对象

3.创建学生对象

4.把学生添加到集合

5.遍历集合（迭代器方式）

package com.itheima.mycollectiondemo1;

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

public class MyCollectionDemo8 {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        Student s1=new Student("小皮同学",23);
        Student s2=new Student("小路同学",31);
        Student s3=new Student("小甲同学",33);
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器的方式进行遍历
        Iterator<Student> it=list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------");
        //增强for
        for (Student student : list) {
            System.out.println(student);
        }
    }

}

2.List集合

2.1List集合的概述和特点【记忆】

• List集合的概述

  • 有序集合,这里的有序指的是存取顺序

  • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素

  • 与Set集合不同,列表通常允许重复的元素

• List集合的特点

  • 有序：存储和取出的元素顺序一致

  • 有索引：可以通过索引操作元素

  • 可重复：存储的元素可以重复

package com.itheima.mylistdemo1;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class MyListDemo1 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("================");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

2.2List集合的特有方法【应用】

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

package com.itheima.mylistdemo1;

import java.util.ArrayList;
import java.util.List;

public class MyListDemo2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //method1(list);
        //method2(list);
        //method3(list);
        // E get(int   index)返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);

    }

    public static void method3(List<String> list) {
        // E set(int index,E   element)修改指定索引处的元素，返回被修改的元素
        //注意事项，被替换的那个元素，在集合中就不存在了
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    public static void method2(List<String> list) {
        // E remove(int   index)删除指定索引处的元素，返回被删除的元素
        //在list集合中有两个删除方法
        //第一个 删除指定元素，返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素，返回值表示实际删除的元素
        String s= list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    public static void method1(List<String> list) {
        //void add(int index,E   element)在此集合中的指定位置插入指定的元素
        //原来位置上的元素会往后挪一个索引
        list.add(0,"qqq");
        System.out.println(list);
    }
}