集合进阶-----Collection单列：List

最新推荐文章于 2025-01-25 15:12:48 发布
最新推荐文章于 2025-01-25 15:12:48 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z2021_000000/article/details/124757180
版权 

Collection集合概述和使用：
/*
        Collection集合概述和使用
        是单例集合的顶层接口，表示一组对象，这些对象也称为Collection的元素
        提供更具体的子接口（如set / list）实现

        Collection<E>   E - 此集合中元素的类型

        创建Collection集合的对象
            多态的方式
            ArrayList（）
 */

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

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

        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //添加元素
        c.add("a");
        c.add("b");
        c.add("c");
        //输出集合对象
        System.out.println(c);



    }
}

 

Collection集合常用方法：
package 集合进阶.Collection单列;

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

/*
        Collection集合常用方法
            boolean add (E e)   添加元素
            bollean remove(Object o)    移除指定元素
            void clear​() 从此集合中删除所有元素（可选操作）
            boolean contains​(Object o) 如果此集合包含指定的元素，则返回 true 。
            boolean isEmpty​() 如果此集合不包含元素，则返回 true 。
            int size​() 返回此集合中的元素数。


 */
public class CollectionDemo2 {
    public static void main(String[] args) {

        Collection<String> c=new ArrayList<String>();

        //添加
        System.out.println(c.add("a"));//返回ture，添加元素肯定添加正确所以输出语句没必要写
        System.out.println(c.add("b"));
        c.add("c");//这样
        c.add("d");

        //移除
        System.out.println(c.remove("a"));//返回ture
        System.out.println(c.remove("v"));
        c.remove("c");

        //清除
//        c.clear();

        //判断元素存在
        System.out.println(c.contains("a"));

        //判断集合是否为空
        System.out.println(c.isEmpty());

        //长度
        System.out.println(c.size());

        System.out.println(c);
    }
}

 

Collection集合的遍历

Iterator:迭代器，集合的专用遍历方式
package 集合进阶.Collection单列;

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

/*
            Collection集合的遍历

            Iterator:迭代器，集合的专用遍历方式
            常用方法：
            boolean hasNext​() 如果迭代具有更多元素，则返回 true 。
            E next​() 返回迭代中的下一个元素。


 */
public class IteratorDemo {
    public static void main(String[] args) {

        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("a");
        c.add("b");
        c.add("c");

        //通过调用集合的Itertor（）方法
        Iterator<String> it = c.iterator();

/*        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());*/

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}




并发修改异常
ConcurrentModificationException：
package 集合进阶.Collection单列;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
        并发修改异常
        ConcurrentModificationException

        产生原因
        迭代器遍历过程中，通过集合对象修改了集合中的元素长度，
        造成了迭代器获取元素中判断预期修改值和实际修改值不一致

        解决方案
        用for循环遍历，然后用集合对象做对应的操作即可
 */

public class 并发修改异常 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

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

        //遍历集合，得到每一个元素，看有没有“world”这个元素，如果有，我就添加一个“javaee”元素
/*       Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if (s.equals("world")) {
                list.add("javaee");
            }
        }*/

       for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("world")) {
                list.add("javaee");
            }
        }
        System.out.println(list);
    }

}

 

List集合概述和特点：
package 集合进阶.Collection单列.List;

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

/*
        概述：
        有序集合，用户可以精确控制每个元素的插入位置，用户也可以通过整数索引访问元素
        并搜集列表中的元素
        与Set集合不同，列表通常允许重复元素

        特点：
        有序：存储和取出的元素一致
        可重复：存储的元素可以重复
 */
public class List集合概述和特点 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

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

        list.add("world");

//        //输出集合
//        System.out.println(list);

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

    }

}

 

 

List集合特有方法：
package 集合进阶.Collection单列.List;
/*
      void add(int index,E element) 在此集合的指定位置插入指定元素
      E remove(int index)   删除指定索引处的元素，并返回
      E set（int index，E element）    修改并返回
      E get（int index）  返回

 */

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

public class LIst集合特有方法 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //插入
//        list.add(1,"javaee");
//        list.add(11,"javaeee");//IndexOutOfBoundsException

        //删除
//        list.remove(1);
//        System.out.println(list.remove(1));
//        System.out.println(list.remove(11));//IndexOutOfBoundsException

        //修改
//        list.set(1,"javaee");
//        System.out.println(list.set(1,"javaee"));
//        System.out.println(list.set(11,"javaeee"));//IndexOutOfBoundsException

        //返回
        System.out.println(list.get(0));
//        System.out.println(list.get(11));//IndexOutOfBoundsException

        //输出集合
        System.out.println(list);
    }

}

 

List集合子类的特点：
package 集合进阶.Collection单列.List;

import java.util.ArrayList;
import java.util.LinkedList;

/*
        常用子类：
        ArrayList：底层数据结构是数组，查询快，增删慢
        LinkedList：底层数据结构是链表，查询慢，增删快
 */
//完成存储字符串并遍历
public class List集合子类的特点 {
    public static void main(String[] args) {
        //创建集合对象ArrayList
        ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");

        for(String s : array) {
            System.out.println(s);
        }

        //LinkedList
        LinkedList<String> list = new LinkedList<String>();

        list.add("hello");
        list.add("world");

        for(String s : list) {
            System.out.println(s);
        }
    }
}


增强for：
package 集合进阶.Collection单列.List;
/*
        增强for：简化数组和Collection集合的遍历
            实现Iterable接口的类允许其对象成为增强型for语句的目标
            它是JDK5之后出现的，其内部原理是一个Iterator迭代器

        格式：
        for（元素数据类型 变量名：数组或者Collection集合）{
                //在此处使用变量即可，该变量就是元素
        }
        范例：
        int[] arr={1,2,3,4}
        for(int i:arr){
            sout(i);
        }
 */

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

public class 增强for {
    public static void main(String[] args) {

        int[] arr ={1,2,3,4};
        for(int i:arr){
            System.out.println(i);
        }

        String[] strArray={"hello","world","java"};
        for(String s:strArray){
            System.out.println(s);
        }

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

        //内部原理是一个Iterator迭代器
        for(String s:list){
            if(s.equals("world")){
                list.add("java");//ConcurrentModificationException
            }
        }
    }

}

 

 

ListIterator:列表迭代器
package 集合进阶.Collection单列.List;
/*
        ListIterator:列表迭代器
            通过List集合的listIterator（）方法得到，所以说它是List集合特有的迭代器
            用于允许程序员沿任意方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

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

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

public class ListIterator {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

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

        //通过list集合的ListIterator（）方法得到
/*        java.util.ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            System.out.println(s);
        }
        while (lit.hasPrevious()){
            String s=lit.previous();
            System.out.println(s);
        }*/

        //获取列表迭代器
        java.util.ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if (s.equals("world")){
                lit.add("javaee");
            }
        }
        System.out.println(list);
    }

}

 

LinkedList集合特有功能：
package 集合进阶.Collection单列.List;
/*
        void addFirst​(E e) 在该列表开头插入指定的元素。
        void addLast​(E e) 将指定的元素追加到此列表的末尾。
        E getFirst​() 返回此列表中的第一个元素。
        E getLast​() 返回此列表中的最后一个元素。
        E removeFirst​() 从此列表中删除并返回第一个元素。
        E removeLast​() 从此列表中删除并返回最后一个元素。

 */

import java.util.LinkedList;

public class LinkedList集合特有功能 {
    public static void main(String[] args) {

        //创建集合对象
        LinkedList<String> LinkedList = new LinkedList<String>();

        LinkedList.add("hello");
        LinkedList.add("world");
        LinkedList.add("java");

        LinkedList.addFirst("javaee");
        LinkedList.addLast("javase");

       LinkedList.getFirst();
       LinkedList.getLast();

        System.out.println(LinkedList.removeFirst());
        System.out.println(LinkedList.removeLast());


        System.out.println(LinkedList);
    }
}

 

List集合存储学生对象并遍历：
package 集合进阶.Collection单列.List.List集合存储学生对象并遍历;

public class Student {
    String name;
    int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package 集合进阶.Collection单列.List.List集合存储学生对象并遍历;

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

/*
        思路：
        定义学生类
        创建集合对象
        创建学生对象
        添加学生到集合
        遍历集合
 */
public class ListDemo {
    public static void main(String[] args) {

        //创建集合对象List
        List<Student> list = new ArrayList<Student>();

        Student s1=new Student("程序员1",30);
        Student s2=new Student("程序员2",31);
        Student s3=new Student("程序员3",32);

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

        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());

        }


    }

}

 

java进阶--Collection&泛型(IDEA版)
xiaohan0010的博客
03-03 715
本节目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ...
【进阶篇-Day9：JAVA中单列集合Collection、List、ArrayList、LinkedList的介绍】
Ma Sizhou
07-13 1059
注：集合分为单列集合和双列集合单列集合：一次添加一个元素，实现了Collection接口。双列集合：一次添加两个元素，实现了Map接口。2.2.2 增强for循环遍历：/*** 使用增强for循环遍历Student s1 = new Student("张三" , 11);//Student是自定义创建的类 Student s2 = new Student("李四" , 21);Student s3 = new Student("王五" , 31);
Collection中的list查找
不喝水的水煮鱼的博客
07-26 218
Collection中的list查找集合IndexOutOfBoundsException下标查找错误 集合 最近在学习集合相关的东西，今天在玩list的时候发现了两个奇怪的情况，先上第一个情况 IndexOutOfBoundsException 代码如下： public class TestCollection { public static void main(String[] arg...
核心类库-集合-Collection子接口-List接口
weixin_54687631的博客
04-20 125
import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import org.junit.Test; import com.atbe.collection.Person; /* |—Collection接口：单列集合，用来存储一个一个的对象 |---List接口：存储有序的、可重复的数据。 --->“动态”数组，替换原有的数组 |---
使用Collections工具类 创建简单的List
Sucker的小笔记
03-24 1669
Integer abc = 10; List<Integer> list = new ArrayList<>(); list.add(abc); 若仅此一个值，则可以使用Collections工具创建简单方法；如 List<Integer> list = Collections.singletonList(abc); ...
Collection之List
x²的博客
04-09 473
List基本知识 ArrayList ArrayList内部通过数组实现，当数组容量不够时，需要将原来的元素复制到新的扩容数组中。当要在ArrayList中插入元素时，需要进行数组元素的移动和复制，代价较高。所以ArrayList适用于随机查找和遍历元素，不适合插入和删除元素。 Vector Vector底层也是通过数组实现，不同的是它是线程安全的，某一时刻只允许一个线程写Vector，速度比ArrayList慢 List相关面试题 ...
集合框架——Collection单列集合介绍
菜鸟的JAVA编程路
09-01 667
封装的形式以及局限性 1.数组：只能存储同种类型的数据，并且程序运行期间，数组长度固定 2.对象：其实对象也是一个容器，而里面的属性便是封装的数据，所以数据很多的时候可以用对象存储，那么如果堆内存中对象很多用什么存储呢？没错，就是用集合存储，集合相当于大容器，包含着对象这个小容器 集合框架的体系总述 每一种集合对对象(数据)都有自己独特的存储方式，说明容器自身都有自己特定的结构，而这种结构恰恰规定了数据在容器中是如何存储的，而这种结构就称之为数据结构（存储数据的容器结构）。而世间容器千千万，java
Java集合进阶 单列集合collection和list
最新发布
2302_80073130的博客
01-25 1893
Java当中一共有很多种集合之前学过的ArrayList只是其中的一类。Collection单列集合：添加一个元素Map双列集合：添加俩个元素。
Java--集合进阶 Collection，迭代器，lambda表达式
2303_80261946的博客
09-09 575
Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到。boolean hasNext(): 判断当前位置是否有元素可以被取出。E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置。​ void remove(): 删除迭代器对象当前指向的元素。- 迭代器,集合的专用遍历方式。- Iterator中的常用方法。- 迭代器中删除的方法。- List集合的概述。- List集合的特点。
9 Java数据结构（中）：集合进阶之Collection(单列集合)：Collection、List接口（ArrayList、LinkedList实现类）、Set接口等、Collections工具类
smalltorch的博客
08-26 1133
前面已经学习过一些集合的基本知识：包装类、泛型，以及一个基本的集合ArrayList。本节我们将在前面的基础上面，更加系统的学习Java类里面集合这个概念。首先，第一步我们要弄明白Java里面的集合是个什么东西，我们要先从集合的体系结构开始学习。
java list collection_Java 集合类Collection、List
weixin_35851654的博客
02-12 364
Collection接口：1.集合可以理解为一个动态的对象数组，不同的是集合中的对象内容可以任意扩充。也就是说在集合当中的操作比较方便，容易添加或者删除2.集合的特点：性能高容易扩展和修改这也是为什么使用集合而不使用数组的主要原因3.Collection的常用子类ListSetQueue这几个子类也是它比较常用的接口Collection所有超级接口：Iterable所有已知接口：publicin...
mybatis resultMap collection 返回List＜String＞
m0_67392409的博客
04-21 1953
一般情况下，利用mybatis 一对多使用collection，返回的是一个对象list，但是特殊情况下，只需要一个String类型的List。下面就是返回String类型List的resultMap ** ** ...
collection接口之List接口
m0_60318777的博客
12-25 325
collection接口；单列集合，用来储存一个一个的对象 list接口：有序，可重复--”动态“数组 ArrayList:作为List接口的主要实现类，线程不安全，效率高 LinkedList:对于频繁的插入，删除操作，使用此类效率比ArrayList()高： 底层使用双向链表存储 Vector:作为List接口的古老实现类，线程安全，效率低 面试题：ArrayList,LinkedList, Vector.
Java--集合（Collection）与列表（List）
qq_45632453的博客
02-21 1509
集合：用于存储数据的容器；
集合（2）—Collection之List的使用方法
weixin_30757793的博客
03-25 167
声明集合变量 List list = new ArrayList(); 或者 : public LIst list； public 构造函数(){ this.list = new ArrayList(); } 添加元素 方法一： 首先创建对象:比如 Student st = new student(); 其次把对象添加到集合中:l...
Collection集合概述，List
it白白的博客
01-17 1967
集合 -- Collection&lt;E&gt; 集合的父接口--用于定义存储多种数据类型的集合。 集合中存储何种数据使用泛型进行限定。 主要定义的方法：    boolean add(E e)          添加数据到集合中  boolean addAll(Collection&lt;? extend...
Mybati通过collection实现级联列表查询，实现自动封装List数据
热门推荐
一恍过去
02-21 2万+
Mybati通过collection实现级联列表查询，实现自动封装List数据
java list collection_Java 集合Collection与List的详解
weixin_33421065的博客
02-12 699
1.什么是集合存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。集合的出现就是为了持有对象。集合中可以存储任意类型的对象,而且长度可变。在程序中有可能无法预先知道需要多少个对象,那么用数组来装对象的话,长度不好定义,而集合解决了这样的问题。2.集合和数组的区别数组和集合类都是容器数组长度是固定的，集合长度是可变的。数组...
Collection中list集合的应用常见的方法
weixin_30484739的博客
12-01 137
集合 ： 用存放对象的容器(集合) Collection ： 跟接口 ： 单列集合 ---> List :有序的 ，元素是可以重复的。 ---> Set : 无序的 ，元素是不可以重复的。 Collectionz红常用的方法： 增 add();添加一个元素 a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

放码过来a

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值