JavaSE进阶八集合一 Collection接口

2021-06-15 本文已影响0人 SimonLike

1 集合概述

什么是集合，有什么作用？

数组其实就是一个集合，集合实际上就是一个容器，可以来容纳其他类型的数据。

集合为什么说在开发中使用较多？

  集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假如链接数据库，
  数据库中有10条记录，那么假设把这10条记录查询出来，在Java程序中会将10条数据封装
  成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历
  集合，将一个数据一个数据展现出来。

集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说是集合中存储的是引用。）
在java中每一个不同的集合，底层对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。数据结构：数据存储的结构就是数据结构；不同的数据结构，数据存储方式不同。
```
 例如：数组、二叉树、链表、哈希表、...  都是常见的数据结构
 new ArrayList(); 创建一个集合，底层是数组。
 new LinkedList(); 创建一个集合，底层是链表。
 new TreeSet(); 创建一个集合，底层是二叉树。
```
集合中分为两大类
- 单个方式存储元素，超级父接口：java.util.Collection;
- 以键值对的方式存储元素, 超级父接口：java.util.Map;
所有的集合类和集合接口都在java.util包下。

2 Collection接口

Collection中存放什么元素？
- 没有使用"泛型"之前，Collection中可以存储Object的所有子类型。
- 使用了"泛型"之后，Collection中只能存储某个具体的类型。
- 集合后期我们会学习"泛型"语法，目前不用管。(再次强调：集合中不能直接存储基本数据类型，也不能存储java对象，只是存储对象的内存地址。)

2.1 关于java.util.Collection接口中常用的方法

  boolean add(Object e); 向集合中添加元素
  int size(); 获取集合中元素的个数
  void clear(); 清空集合
  boolean contains(Object o); 判断集合中是否包含某个元素；包含是true，不包含是false。
  boolean remove(Object o); 删除集合中某个元素
  boolean isEmpty(); 判断该集合中元素的个数是否为0  为空为零是true，不为空是false。
  Object[] toArray(); 把集合转换成数组。

代码示例

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

public class CollectionTest01 {
    public static void main(String[] args) {
        // 创建一个集合对象
        // Collection  c = new Collection();//接口是抽象的，无法实例化。

        // 多态
        Collection c = new ArrayList();
        // 调用Collection接口中的常用方法
        c.add(120); // 自动装箱
        c.add(3.14);// 自动装箱
        c.add(new Object());
        c.add(false);// 自动装箱

        // 获取集合中元素的个数
        System.out.println("集合中元素的个数:" + c.size()); // 4

        // 清空集合
        c.clear();
        System.out.println("集合中元素的个数:" + c.size());// 0

        // 再向集合中添加元素
        c.add("abc");
        c.add("def");
        c.add("中国人");
        c.add("张三");

        // 判断集合中是否包含某个元素
        boolean flag = c.contains("def");
        System.out.println(flag); //true
        System.out.println(c.contains("defh")); //false

        System.out.println("集合中元素的个数:" + c.size());// 4
        // 删除集合中某个元素
        c.remove("张三");
        System.out.println("集合中元素的个数:" + c.size());// 3

        // 判断集合是否为空（集合中是否存在元素）
        System.out.println(c.isEmpty());// false
        // 清空集合
        c.clear();
        System.out.println(c.isEmpty());// true

        // 再向集合中添加元素
        c.add(12);
        c.add("asd");
        c.add("hello");
        c.add("world");
        c.add("美女");
        c.add(new Student());

        System.out.println("----------------------------------------------------------");

        // 把集合转换成数组。
        Object[] objs = c.toArray();
        // 遍历数组
        for (int i = 0;i < objs.length; i++){
            Object o = objs[i];
            System.out.println(o);
        }
    }
}

class Student{

}

2.2 关于集合遍历/迭代专题(对象Iterator)

以下讲解的遍历方式/迭代方式，是所有Collection通用的一种方式。
在map集合中不能使用，所有的Collection以及其子类中都可以使用。

以下两个方法是迭代器对象Iterator中的方法：

  boolean hasNext(); 如果仍有原素可以迭代，则返回true。
  Object next(); 返回迭代的下一个元素。

代码示例

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

public class CollectionTest02 {
    public static void main(String[] args) {

        // 创建集合对象
        Collection c = new ArrayList(); // 有序可重复

        // 添加元素
        c.add("abc");
        c.add("def");
        c.add(123);
        c.add(321);
        c.add("def");
        c.add(new Object());

        // 对集合进行遍历/迭代
        // 第一步:获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();
        // 第二步：通过迭代器对象开始迭代/遍历集合
        /*
            以下两个方法是迭代器对象Iterator中的方法：
                boolean hasNext(); 如果仍有原素可以迭代，则返回true。
                Object next(); 返回迭代的下一个元素。
         */
        //遍历迭代
        while (it.hasNext()){
            Object obj = it.next();
            System.out.print(obj);
            if (obj instanceof Integer){
                System.out.println(" 是Integer类型");
            }else if (obj instanceof String){
                System.out.println(" 是String类型");
            }else if (obj instanceof Object){
                System.out.println(" 是Object类型");
            }
        }
    }
}

2.3 关于Collection集合中的contains方法

boolean contains(Object o); 判断集合中是否包含某个元素；包含是true，不包含是false。
它在底层是怎么判断集合中是否包含某个元素：调用了equals方法进行比对的。
- 存放在集合中类型，一定要重写equals方法，不然比较的就是内存地址。

代码示例

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

public class CollectionTest03 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();
        // 向集合中存储元素
        String s1 = new String("abc");
        c.add(s1);

        String s2 = new String("def");
        c.add(s2);

        System.out.println("集合汇总元素个数：" + c.size());

        String x = new String("abc");
        System.out.println(c.contains(x));// 等于调用了equals方法进行比对的。true

        // ===============================================================================

        // 测试contains方法
        Collection c1 = new ArrayList();
        //创建用户对象
        User user1 = new User("java");
        User user2 = new User("java");

        //加入集合
        c1.add(user1);
        // 判断集合中是否包含user2
        // 没重写equals方法之前 输出false
        // 重写equals方法之后 输出true
        System.out.println(c1.contains(user2));

    }
}

class User{
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 重写equals方法 (系统重写)
    // 这个equals方法的比较原理是：只要姓名一样就表示同一个用户
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(getName(), user.getName());
    }
}

2.4 关于Collection集合中的remove方法

boolean remove(Object o); 删除集合中某个元素
它在底层是怎么判断删除集合中的哪个元素：调用了equals方法进行比对。
重点：
- 当集合的结构发生改变是，迭代器必须重新获取，如果还是用老的迭代器，会出现异常：java.util.ConcurrentModificationException
- 在迭代/遍历集合元素的过程中，不能调用集合对象的remove方法删除元素。不然会出现异常：java.util.ConcurrentModificationException
- 在迭代元素的过程中，一定要使用迭代器Iterator的remove方法删除元素，不要使用集合自带的remove方法删除元素。

代码示例

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

public class CollectionTest04 {
    public static void main(String[] args) {

        // 创建集合
        Collection c = new ArrayList();
        String s1 = new String("java");
        c.add(s1);
        String s2 = new String("java");
        // 删除集合中某个元素
        c.remove(s2);
        System.out.println(c.size()); // 0
        System.out.println("======================================================");

        // ======================================================

        // 创建集合
        Collection c1 = new ArrayList();

        // 注意此时获取的迭代器，指向的是集合中没有元素状态下得迭代器。
        // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。
        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法
        // 会报异常：java.util.ConcurrentModificationException

        Iterator it = c1.iterator();

        // 添加元素
        c1.add(1);
        c1.add(2);
        c1.add(3);

        // 重新获取迭代器
        it = c1.iterator();// 注释掉该代码 会报异常：java.util.ConcurrentModificationException

        while (it.hasNext()){
            Object obj = it.next();

            // 删除某一个元素
            // 删除元素之后，集合发生了变化，应该重新获取，
            // 但是循环下一次时没有重新获取迭代器，所以报异常：java.util.ConcurrentModificationException
            // c1.remove(obj);

            // 使用迭代器的remove方法删除
            it.remove();//删除迭代器指向的当前元素
            System.out.println(obj);
        }

        System.out.println(c1.size()); //0
    }
}

2.4 关于Collection集合中的list子接口

list接口的常用方法：
- list集合存储元素特点：有序可重复。
- 有序：list集合中的元素有下标：从0开始，以1递增。
- 可重复：存储一个1，还可以再存储1。

list是Collection接口的子接口，那么list接口有自己"特色"的方法

  list接口特有的常用方法：
  void add(int index, E element); // 在指定位置添加元素（下标,元素）
  E get(int index); //  根据下标获取元素
  int indexOf(Object o); // 获取指定对象第一次出现的索引
  int lastIndexOf(Object o); // 获取指定对象最后一次出现的索引
  E remove(int index); // 删除指定下标位置的元素
  E set(int index, E element);//修改指定下标位置的元素

代码示例

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

public class CollectionTest05 {
    public static void main(String[] args) {
        // 创建list类型的集合。
        List myList = new ArrayList();
        // 添加元素
        myList.add(1);
        myList.add(2);
        myList.add(3);
        myList.add(4);
        myList.add(3);

        // 在指定位置添加元素（下标,元素）
        // 这个方法使用不多，因为对于ArrayList集合来说效率比较低。
        myList.add(1,"kind");

        // 迭代
        Iterator it = myList.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
        System.out.println("======================================================");

        // 根据下标获取元素
        Object firstObj = myList.get(0);
        System.out.println(firstObj);

        System.out.println("======================================================");

        // 通过下标遍历。【list集合特有的方式，set没有】
        for (int i = 0;i < myList.size(); i++){
            Object obj = myList.get(i);
            System.out.println(obj);
        }

        System.out.println("======================================================");

        // 获取指定对象第一次出现的索引
        System.out.println(myList.indexOf(3)); // 3
        // 获取指定对象最后一次出现的索引
        System.out.println(myList.lastIndexOf(3)); // 5

        System.out.println("删除前：" + myList.size());
        // 删除指定下标位置的元素
        myList.remove(3);
        System.out.println("删除后：" + myList.size());

        // 修改指定下标位置的元素
        myList.set(2,"abc");

        // 通过下标遍历。
        for (int i = 0;i < myList.size(); i++){
            Object obj = myList.get(i);
            System.out.println(obj);
        }
    }
}

3 ArrayList集合

3.1 ArrayList的使用

默认初始化容量10
- 集合底层是一个Object[]数组
- 构造方法： new ArrayList();

ArrayList集合的扩容：

增长到原容量的1.5倍。

ArrayList集合就是底层数组，如何优化？

 尽可能少的扩容，因为数组扩容效率比较低，
 建议使用ArrayList集合的时候， 给出预估计好的初始化容量值。

数组的优缺点：
- 优点：检索效率比较高。
- 确定：随机增删元素效率比较低。
- 注意：向数组末尾增加元素，效率很高，不受影响。
ArrayList集合是非线程安全的，如何将ArrayList集合转换成线程安全的
- 使用集合工具类：java.util.Collections;

代码示例

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class CollectionTest06 {
    public static void main(String[] args) {

        // 默认初始化容量是10
        // 数组的长度10
        List list = new ArrayList();
        list.add(1);

        // 集合size()方法获取的是当前集合中元素的个数，不是获取集合的容量。
        System.out.println(list.size());

        // 指定初始化容量
        // 数组的长度20
        List list1 = new ArrayList(20);
        System.out.println(list1.size());

        System.out.println("======================================================");

        //创建一个HashSet集合
        Collection c = new HashSet();
        c.add(2);
        c.add(20);
        c.add(200);
        c.add(2000);

        // 通过这个构造方法可以将HashSet集合转换成List集合
        List list2 = new ArrayList(c);
        // 遍历
        for (int i = 0; i < list2.size(); i++){
            System.out.println(list2.get(i));
        }
        // ==============================================================
        List myList = new ArrayList();// 非线程安全的
         // 变成线程安全的
        Collections.synchronizedList(myList);
        myList.add(1);
    }
}

3.2 补充内容位运算

public class BinaryTest {
    public static void main(String[] args) {
        // 位运算
        // >> 1 二进制右移一位
        // >> 2 二进制右移二位
        // 10的二进制位是：00001010  【10】
        // 右移一位是：00000101   【5】
        System.out.println(10 >> 1);  // 5

        // << 1 二进制左移一位
        // << 2 二进制左移二位
        // 10的二进制位是：00001010  【10】
        // 左移一位是：00010100   【20】
        System.out.println(10 << 1);// 20

    }
}

4 LinkedList集合

LinkedList集合是双向链表
链表的优点：
- 由于链表上的元素在空间存储上内存地址不够连续，所以随机增删元素的时候不会有大量的元素位移，因此随机增删效率较高。
- 在开发中遇到随机增删集合中元素的业务比较多少时，建议使用LinkedList。
链表的缺点
- 不能通过数学表达式计算查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。
- 所以LinkedList集合检索/查找的效率较低。
ArrayList和LinkedList的区别
- ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的）
- LinkedList：把随机增删发挥到极致。

代码示例

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class LinkedListTest01 {
    public static void main(String[] args) {
        // 创建LinkedList集合
        List list = new LinkedList();
        // 添加元素
        list.add(2);
        list.add(33);
        list.add(22);

        // 输出集合中元素个数
        System.out.println(list.size());

        // 使用迭代器变量集合
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

5 Vector集合

底层是一个数组
初始化容量：10
扩容之后是原容量的2倍。
Vector中所有的方法都是线程同步的，都带有synchroized关键字，是线程安全的。（效率较低，使用较少）

代码示例

import java.util.Iterator;
import java.util.List;
import java.util.Vector;

public class VectorTest01 {
    public static void main(String[] args) {
        // 创建Vector集合
        List list = new Vector();
        // 添加元素
        list.add(12);
        list.add(33);
        list.add(22);

        // 输出集合中元素个数
        System.out.println(list.size());

        // 使用迭代器变量集合
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

5 泛型

JDK5.0之后推出的新特性：泛型
泛型这种语法机制只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用！）
使用泛型的好处：
- 1，集合中存储的元素类型统一了。
- 2，从集合中取出的元素类型是泛型指定的类型，不需要进行大量的"向下转型"！
泛型的缺点
- 集合中存储的元素缺乏多样性。

代码示例

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

public class GenericTest01 {
    public static void main(String[] args) {

        // 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。
        // 使用泛型来指定集合中存储的数据类型。
        List<Animal> mylist = new ArrayList<Animal>();
        // 指定List集合中只能存储Animal,那么存储String就会编译报错
        // 这样用了泛型之后，集合中元素的数据类型更加统一了。
        // mylist.add("abc");

        Cat c = new Cat();
        Bird b = new Bird();

        mylist.add(c);
        mylist.add(b);

        // 获取迭代器
        // 这个表示迭代的是Animal类型。
        Iterator<Animal> it = mylist.iterator();
        while (it.hasNext()){
            Animal a = it.next();
            a.move();// 调用父类方法
            if (a instanceof Cat){
                ((Cat) a).cathMouse();//调用子类特有方法
            }else if (a instanceof Bird){
                ((Bird) a).fly();//调用子类特有方法
            }
        }
    }
}
class Animal{
    public void move(){
        System.out.println("动物在移动！");
    }
}
class Cat extends Animal{
    public void cathMouse(){
        System.out.println("猫在抓老鼠！");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("鸟儿在飞翔！");
    }
}

5.1 自动类型推断机制（又称钻石表达式）

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

public class GenericTest02 {
    public static void main(String[] args) {
        // ArrayList<这里的类型自动推断,可以不写>()，jdk8之后才有的
        // 自动类型推断，钻石表达式！
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("xxx");

        // list.add(11);// 报错类型不匹配

        System.out.println("元素个数：" + list.size());

        //迭代器遍历
        Iterator<String> its = list.iterator();
        while (its.hasNext()){
            String s = its.next();
            System.out.println(s);
        }
    }
}

5.2 自定义泛型

<>尖括号中是一个标识符，可以随便写的。
java源码中常用的是<E>和<T>
- E是Element单词首字母。
- T是Type单词首字母。

代码示例

public class GenericTest03{
    public static void main(String[] args) {
        // new对象的时候指定了泛型String类型
        GenerricSelf<String> gt = new GenerricSelf<>();
        gt.doSome("11");
        // gt.doSome(11); // 类型不匹配

        GenerricSelf<Integer> gt1 = new GenerricSelf<>();
        // gt1.doSome("11");// 类型不匹配
        gt1.doSome(11);
    }
}
// 自定义泛型类
// E代表标识符可以随便写的
class GenerricSelf<E>{
    public void doSome(E e){
        System.out.println(e);
    }
}

6 增强for循环（foreach）

jdk5.0之后推出的一个新特性。

语法结构:

  for(元素类型 变量名 : 数组或集合){
         System.out.println(f);
     }

增强for循环（foreach）没有下标

代码示例

public class ForEachTest01 {
    public static void main(String[] args) {
        // int数组
        int[] arr = {12,32,323,82,55,33,98};
        // 遍历数组（普通for循环）
        for (int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }

        System.out.println("==================================================");

        // 增强for（foreach）
        // f代表的是数组中的元素
        for (int f : arr){
            System.out.println(f);
        }

        System.out.println("==================================================");

        // 集合使用foreach
        // 创建list集合
        List<String> strings = new ArrayList<>();
        // 添加元素
        strings.add("hello");
        strings.add("word");
        strings.add("java");

        // 使用迭代器遍历
        Iterator<String> it = strings.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

        // 使用普通for循环 ，有下标
        for (int i = 0; i < strings.size(); i++){
            System.out.println(strings.get(i));
        }

        // 使用增强for循环 foreach，没有下标
        for (String s : strings) {
            System.out.println(s);
        }
    }
}

上篇：JavaSE进阶七异常
下篇：JavaSE进阶八集合二 Map接口

JavaSE进阶八集合一 Collection接口

1 集合概述

2 Collection接口

2.1 关于java.util.Collection接口中常用的方法

代码示例

2.2 关于集合遍历/迭代专题(对象Iterator)

代码示例

2.3 关于Collection集合中的contains方法

代码示例

2.4 关于Collection集合中的remove方法

代码示例

2.4 关于Collection集合中的list子接口

代码示例

3 ArrayList集合

3.1 ArrayList的使用

代码示例

3.2 补充内容位运算

4 LinkedList集合

代码示例

5 Vector集合

代码示例

5 泛型

代码示例

5.1 自动类型推断机制（又称钻石表达式）

5.2 自定义泛型

代码示例

6 增强for循环（foreach）

代码示例

猜你喜欢

热点阅读

JavaSE进阶八 集合一 Collection接口

1 集合概述

2 Collection接口

2.1 关于java.util.Collection接口中常用的方法

代码示例

2.2 关于集合遍历/迭代专题(对象Iterator)

代码示例

2.3 关于Collection集合中的contains方法

代码示例

2.4 关于Collection集合中的remove方法

代码示例

2.4 关于Collection集合中的list子接口

代码示例

3 ArrayList集合

3.1 ArrayList的使用

代码示例

3.2 补充内容位运算

4 LinkedList集合

代码示例

5 Vector集合

代码示例

5 泛型

代码示例

5.1 自动类型推断机制（又称钻石表达式）

5.2 自定义泛型

代码示例

6 增强for循环（foreach）

代码示例

猜你喜欢

热点阅读

JavaSE进阶八集合一 Collection接口