Java基础复习——DAY8（Collection；List集合）

大概是犬青

已于 2022-10-06 16:13:02 修改

阅读量394

点赞数

文章标签： java

于 2022-03-10 10:27:50 首次发布

本文链接：https://blog.csdn.net/Kevinwen0228/article/details/123376522

版权

Java 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

集合进阶

1. 集合知识回顾

集合类特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时改变

单列集合（Collection）和双列集合（Map）

体系结构
在这里插入图片描述

2. Collection集合

2.1 Collection概述和创建对象

概述：

单例集合的顶级接口，他代表一组对象，这些对象成为collection的元素
jdk不提供任何接口的直接实现，提供更加具体子接口（Set，List）实现

创建Collection集合的对象

多态方式
具体实现类ArrayList

package arrays;

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

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection对象
        Collection<String> c  =   new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("java");
        c.add("world");

        //输出
        System.out.println(c);//[hello, java, world]
    }
}

2.2 Collection常用方法

在这里插入图片描述
alt + 7 看类的信息 ctrl + B 追朔

package arrays;

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

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection对象
        Collection<String> c  =   new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("java");
        c.add("world");

        //删除指定
        c.remove("java");

        //判断元素
        System.out.println(c.contains("hello"));//true
        
        //输出
        System.out.println(c);//[hello,world]
    }
}

2.3 Collection集合遍历

Iterator：迭代器，集合遍历的专用工具

Iterator iterator():返回此集合中元素的迭代器，通过集合的iterator（）方法得到
通过集合的iterator（）方法得到，所以依赖于集合而存在

Iterator的常用方法

E next():返回迭代中的下一个元素
boolean hasNext(): 如果迭代具有多个元素，返回true

package arrays;

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

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection对象
        Collection<String> c  =   new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("java");
        c.add("world");

        //遍历
        Iterator it = c.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

案例，学生类遍历

package arrays;

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

public class CollectionDemo {
    public static void main(String[] args) {
       Collection<Student> c = new ArrayList<>();
       Student s1 = new Student("wts",20);
       Student s2 = new Student("cyc",30);
       Student s3 = new Student("wyx",50);

       c.add(s1);
       c.add(s2);
       c.add(s3);

       Iterator<Student> it = c.iterator();
       while (it.hasNext()){
           Student s = it.next();
           System.out.println(s.getName()+','+s.getAge());
           //wts,20
           //cyc,30
           //wyx,50
       }
    }
}

3. List集合

3.1 List集合概念和特点

List集合概念

有序集合，可以精确控制每个元素插入位置。索引访问
与Set集合不同，允许重复集合
List集合特点
有序，存储和取出的元素顺序一致
可重复：存储的元素可重复

3.2 List集合的常用创建方法

在这里插入图片描述

案例：List集合，学生对象

package arrays;

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

public class ListDemo {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student s1 = new Student("wts", 20);
        Student s2 = new Student("cyc", 30);
        Student s3 = new Student("wyx", 50);

        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.getName() + ',' + s.getAge());
            //wts,20
            //cyc,30
            //wyx,50
        }
        for (int i = 0; i < list.size(); i++) {
            Student ss = list.get(i);
            System.out.println(ss.getName() + ',' + ss.getAge());
            //wts,20
            //cyc,30
            //wyx,50
        }
    }
}

3.3 并发修改异常

ConcurrentModificationException
产生原因：迭代遍历过程中，通过修改集合对象修改了集合的长度，造成了迭代器获取元素判断修改值和实际值不一样
解决方案：用for循环遍历

3.4 ListIterator（）

列表迭代器，

通过List集合的Iterator（）方法得到的，是List集合特有的迭代器
用于允许程序员沿任意一方向遍历列表，在迭代期间修改列表，并获取列表中迭代器的当前位置

常用的方法：

E next（）返回迭代中的下一个元素
boolean hasNext（）
E previous（）返回列表中的上一个元素
boolean hasPrevious（）如果此迭代器在相反方向遍历列表是具有更多元素，则返回true
void add（E e）：将指定的元素插入列表

package arrays;

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

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

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        //ListIterator()方法得到
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            System.out.println(s);
            //hello
            //java
            //world
        }
        System.out.println("------------");

        //反方向迭代
        while (lit.hasPrevious()) {
            String ss = lit.previous();
            System.out.println(ss);
            //world
            //java
            //hello
        }
        System.out.println("------------");

        //获取迭代器
        while (lit.hasNext()) {
            if (lit.next().equals("world")) {
                lit.add("wtsgogogogo");//使用ListIterator有add的方法，不会有并发修改异常
            }
        }
        System.out.println(list);
    }
}

Iterator（）接口有add会抛出并发修改异常，而ListIterator（）add不会

3.5增强for循环

增强for：简化数组和Collection集合的遍历

实现Iterator接口的类允许其对象成为增强for语句的目标

package arrays;

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

public class ListDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
        //1
        //2
        //3
        //4
        //5
        System.out.println("------------");

        String[] strArray = {"wts", "gogogo", "666"};
        for (String s : strArray) {
            System.out.println(s);
        }
        //wts
        //gogogo
        //666
        System.out.println("------------");

        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("java");
        list.add("world");
        for (String ss : list) {
            System.out.println(ss);
            //hello
            //java
            //world
        }
    }
}

三种遍历

Iterator() （集合特有遍历）
普通for（有索引）
增强for （简单）

3.6 数据结构

3.6.1 栈

压/进栈
在这里插入图片描述

3.6.2 队列

在这里插入图片描述

3.7 常见的数据结构

3.7.1 数组

在这里插入图片描述

3.7.2 链表

在这里插入图片描述

ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快

3.8 LinkedList集合特有功能

在这里插入图片描述

package arrays;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedlist = new LinkedList<>();
        linkedlist.add("wen");
        linkedlist.add("tian");
        linkedlist.add("sheng");
        System.out.println(linkedlist);//[wen, tian, sheng]

        //头尾添加
        linkedlist.addFirst("cczu");
        linkedlist.addLast("gogogo");
        System.out.println(linkedlist);//[cczu, wen, tian, sheng, gogogo]

        //获取头尾元素
        String first = linkedlist.getFirst();
        String last = linkedlist.getLast();
        System.out.println("首："+first+"   尾："+last);//首：cczu   尾：gogogo

        //删除首尾
        linkedlist.removeFirst();
        linkedlist.removeLast();
        System.out.println(linkedlist);//[wen, tian, sheng]
        
    }
}

大概是犬青

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础复习——DAY8（Collection；List集合）

集合进阶1. 集合知识回顾集合类特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时改变单列集合（Collection）和双列集合（Map）体系结构2. Collection集合2.1 Collection概述和创建对象概述：单例集合的顶级接口，他代表一组对象，这些对象成为collection的元素jdk不提供任何接口的直接实现，提供更加具体子接口（Set，List）实现创建Collection集合的对象多态方式具体实现类ArrayListpackage arr
复制链接

扫一扫