【实训笔记】第六天：集合（1）

最新推荐文章于 2024-06-02 18:21:33 发布

ZNing_1

最新推荐文章于 2024-06-02 18:21:33 发布

阅读量800

点赞数 26

文章标签：笔记 java ide 开发语言学习

本文链接：https://blog.csdn.net/ZNing_1/article/details/135940087

版权

数组存储的缺点
1、数组一旦初始化后，其长度和类型就确定了;
2、数组中提供的方法有限、对于增删改等操作不方便，效率也不高
3、能够解决有序、可重复，但对于无序和不可重复的需求时，不能够满足

基本概念
当需要在java程序中记录单个数据内容时，则声明一个变量即可;

当需要在java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可;

当需要在java程序中记录多个类型不同的数据内容时，则创建一个对象即可;

当需要在Java程序中记录多个类型相同的对象数据时，则创建一个对象数组即可;

当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合即可;

集合框架
Java中集合框架的顶层框架是:java.util.Collection集合和java.util.Map集合。
其中Collection集合中存取元素的基本单位是:单个元素。其中Map集合中存取元素的基本单位是:单对元素。

Collection集合(重点)

常用方法
boolean add(E e)：向集合中添加对象
boolean contains(Object o)：判断是否包含指定对象
boolean remove(Object o)：从集合中删除对象
void clear();//清空集合
int size();//返回包含对象的个数
boolean isEmpty();//判断是否为空

Object[] toArray();//将集合转换成数组
List asList(Object[] o);//将数组转换成集合
Iterator<E> iterator()：遍历集合中的元素
Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
        boolean hasNext()：如果仍有元素可以迭代，则返回true
        E next()：退回迭代的下一个元素
注意:集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
使用foreach循环遍历集合元素：JDK1.5提供，可以选代访问Collection和数组
        遍历时不需要获取Collection或数组的长度，也不需要使用索引访问
        本质上，底层也是调用iterator
格式:

for(要遍历的元素类型遍历后自定义元素名称:要遍历的结构名称){
System.out,println(遍历后自定义元案名称);

}

public void collectionTest(){
        //接口类型的引用指向实现的对象，形成多态
        Collection collection = new ArrayList();
        // []
        System.out.println(collection);
        //  向集合中添加元素，该方法的形参要求是Object类型
        // [one]
        boolean b = collection.add("one");
        System.out.println(collection);
        // true
        System.out.println("b = " + b);
        // [one, 2]
        collection.add(2);
        System.out.println(collection);
        collection.add('a');
        collection.add(3.14);
        collection.add("张三");
        //  [one, 2, a, 3.14, 张三]
        System.out.println(collection);
        System.out.println("----------------------");
        //判断是否包含对象
        b = collection.contains("two");
        System.out.println("b = " + b);
        b = collection.contains("one");
        System.out.println("b = " + b);
        //判断是否为空
        b = collection.isEmpty();
        System.out.println("b = " + b);
        System.out.println("======================");

        System.out.println("集合中的元素有：" + collection);
        b = collection.remove("one");
        System.out.println("b = " + b);
        System.out.println("集合中的元素有：" + collection);
        System.out.println("======================");
        //集合转换为数组
        Object[] objects = collection.toArray();
        //地址值
        System.out.println(objects);
        //遍历数组中的元素
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        System.out.println("======================");
        //将数组转换为集合
        List objects1 = Arrays.asList(objects);
        System.out.println(objects1);
        System.out.println("======================");
        //迭代器，遍历集合中的元素 方式二
        Iterator it = objects1.iterator();
//        b = it.hasNext();
//        System.out.println("b = " + b);
//        Object obj = it.next();
//        System.out.println("元素：" + obj);
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
//            String str = (String) it.next();
//            System.out.println(str);
        }
        System.out.println("=================================");
        //遍历集合中的元素，第三种方式
        for (Object o: objects1) {
            System.out.println(o);
        }
    }

List集合(重点)

基本概念
java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。该集合的主要实现类有:ArrayList类、LinkedList类、Stack类、Vector类。

其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。

其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。

其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LlFO)。

其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低。

常用的方法
void add(int index, E element)：向集合中指定位置添加元素
boolean addAll(int index, Collection<? extends> c)：向集合中添加所有元素
E get(int indox)：从集合中获取指定位置元素
E set(int index, E element)：修改指定位置的元素
E remove(int index)：删除指定位置的元素
List<E> subList(int fromIndex, int to Index);//获取子List，前闭后开
注意:subList获取的List与原List占有相同的存储空间,对子List的操作会影响到原List

public void listTest(){
        //查询java.util.Stack类以及相关方法，实现将11、22、33、44、55依次入栈并打印，
        //查者栈顶元素并打印，然后依次出栈并打印。
        List list = new ArrayList();
        int size = list.size();
        //0
        System.out.println(size);
        //[]
        System.out.println(list);
        //向集合中添加元素
        list.add(0,"one");
        list.add(1,2);
        list.add(2,'3');
        list.add(3,3.14);
        System.out.println(list);
        List list1 = new ArrayList();
        list1.add("two");
        list1.add(10);
        list.addAll(list1);
        System.out.println(list);
        System.out.println("------------------");
        //根据下标查看原集合中指定位置的元素
        Object o = list.get(3);
        System.out.println(o);
        //根据下标修改集合中指定位置的元素
        o = list.set(0, 1);
        System.out.println("下标为0的位置修改前为：" + o);
        System.out.println(list);
        //根据下标删除集合指定位置的元素
        o = list.remove(0);
        System.out.println("删除的元素为：" + o);
        System.out.println("==========================");
        List list2 = list.subList(0, 3);
        //前闭后开
        System.out.println("list集合：" + list);
        System.out.println("子集合中的元素：" + list2);
        //list与list2指向的地址一样，所以删除list2下标为0的元素同时也删除了list的该元素
        list2.remove(0);
        System.out.println("list集合：" + list);
        System.out.println("子集合中的元素：" + list2);
    }

Queue集合(重点)

基本概念
java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FlFO)该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势.

常用的方法
boolean add(E e)：将指定的元素插入此队列(如果立即可行且不会违反容量限制)，在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
E element()：获取，但是不移除此队列的头。
boolean offer(E e)：将指定的元索插入此队列(如果立即可行且不会违反容量限制)，当使用有容量限制的队列时，此方法通常要优于add(E)，后者可能无法插入元素，而只是抛出一个异常。
E peek()：获取但不移除此队列的头;如果此队列为空，则返回null。
E poll()：获取并移除此队列的头，如果此队列为空，则返回 null。
E remove()：获取并移除此队列的头。

public void queueTest(){
        //准备一个Queue集合
        Queue<Integer> queue = new LinkedList<>();
        // 将数据11、22、33、44、55依次入队并打印
        for (int i = 1; i < 6; i++) {
            queue.offer(i * 11);
            System.out.println(queue);
        }

        // 查看队首元素并打印
        Integer it = queue.peek();
        System.out.println("队首元素：" + it);
        // 将队列中所有数据依次出队并打印
        //poll
        for (int i = 1; i < queue.size() + i; i++) {
            Integer it1 = queue.poll();
            System.out.println(it1);
        }
    }

泛型机制

基本概念
通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。为了避免上述错误的发生，从jdk1.5开始增加泛型机制，也就<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错，如:
List<String> lt1 = new LinkedList<String>();

泛型机制的本质
泛型机制的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，实际参数主要用于给形式参数初始化，一旦初始化成功，以后所有的E全部被实参取代，如:

public void collectionTest02(){
        Collection<String> collection = new ArrayList<>();
        collection.add("AA");
        collection.add("BB");
        collection.add("CC");
        collection.add("DD");
        System.out.println(collection);
    }