Collection,List,ArrayList,LinkedList集合_collection list arraylist-CSDN博客

本文链接：https://blog.csdn.net/cl66666666/article/details/109789858

在这里插入图片描述

Collection集合

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

lJDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

Collection集合对象

package com.itxuexi.it14.Collection01;

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

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合对象 ，指向ArrayList子类
        Collection<String> c = new ArrayList<String>();
        
        //创建Collection集合对象 ，指向LinkedList子类
        Collection<String> d = new ArrayList<String>();

        //添加对象
        c.add("hello");
        c.add("world");
        
		d.add("hello");
        d.add("java");

        //输出集合对象
        System.out.println(c);
        System.out.println(c);

    }
}

Collection集合常用方法

package com.itxuexi.it14.Collection01;

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

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

        //添加对象,返回boolean类型，可重复，返回true
        System.out.println(c.add("hello"));   // true
        System.out.println(c.add("hello"));   // true
        System.out.println(c.add("world"));   // true

        //移除指定元素,返回boolean类型，
        System.out.println(c.remove("hello"));

        //清除集合
//        c.clear();
        System.out.println();

        //判断集合中是否有指定元素
        System.out.println(c.contains("word"));

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

        //集合中元素的个数  
        System.out.println(c.size());

    }
}

Collection集合遍历（Iterator迭代器）

Iterator 迭代器，集合的专用遍历方式；Iterator 是接口。迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中的常用方法：

lE next()：返回迭代中的下一个元素

lboolean hasNext()：如果迭代具有更多元素，则返回 true；

Collection遍历循环

Collection集合没有获取元素的方法，无法通过for循环获取元素（增强版 for循环获取为地址；需要在Student中加toString方法）


package com.itxuexi.it14.Collection01;

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

public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        
//        增强for循环
//        for(String s : str){
//            System.out.println(s);
//        }

        Iterator<String> it = c.iterator();

        //用while循环，hasNext()判断集合中是否有元素 （trun循环，false终止）
        while (it.hasNext()){
            //使用next() 获取元素 ，没有元素会报错NoSuchElementException
            String s = it.next();
            System.out.println(s);
      }
    }
}

练习题

package com.itxuexi.it14.Collection02;
/*
学生类
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 //-----------------------------------------------
package com.itxuexi.it14.Collection02;
/*
测试类
 */
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

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

        //创建学生对象
        Student s1 = new Student("张玲",20);
        Student s2 = new Student("王辉",19);
        Student s3 = new Student("刘军",22);

        //把学生添加到集合
        str.add(s1);
        str.add(s2);
        str.add(s3);
        
        
//        for(Student s : str){
//            System.out.println(s);
//        }

        //遍历集合（迭代器）
        Iterator<Student> it = str.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

List – 有序，可重复，接口

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

List集合概述

有索引，可以存储重复元素，元素存取有序

List集合对象 (ArrayList,LinkedList或对象)

package com.itxuexi.it14.List01;

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

public class ListDemo1 {
    public static void main(String[] args) {
        //创建集合对象 子类ArrayList
        List<String> li = new ArrayList<String>();
        //创建集合对象 子类LinkedList
        List<String> ll = new LinkedList<String>();

        //添加元素  （可重复）
        li.add("hello");
        li.add("word");
        li.add("word");
        li.add("java");
        System.out.println(li);  //有序
        
        ll.add("hello");
        ll.add("word");

        //循环获取元素  ，List继承Iterator 可用他的方法
        Iterator<String> it = li.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

List集合特有方法

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

package com.itxuexi.it14.List01;

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

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

        //添加元素
        li.add("hello");
        li.add(1,"world");  //注意索引越界
        li.add("java");
        li.add("javaee");

        //输出集合对象
        System.out.println(li);

        //删除元素，返回被删除的元素
        li.remove("hello");
        li.remove(0);    //注意索引越界
        System.out.println(li);

        //修改元素，返回被修改的元素
        System.out.println(li.set(0,"get"));

        //返回指定位置元素
        System.out.println(li.get(0));

        //用循环获取集合元素
        for(int i = 0;i<li.size();i++){
            String s = li.get(i);
            System.out.println(s);
        }

    }
}

并发修改异常与 ListIterator迭代器

并发修改异常

并发修改异常：ConcurrentModificationException

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

解决方案：用for循环遍历或使用ListIterator迭代器

package com.itxuexi.it14.List03;

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

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

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

        /*
        //遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素
        //next 迭代器中预期修改次数与实际修改次数不一致（add操作）
        Iterator<String> it = li.iterator();
        while (it.hasNext()){
            String s = it.next();
            if(s.equals("world")){
                li.add("javaee");
            }
        }
         */

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

    }
}

ListIterator迭代器

通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。

package com.itxuexi.it14.List03;

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

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

        //给集合添加元素
        li.add("hello");
        li.add("world");
        li.add("java");
        li.add("1234");

        System.out.println(li);

        //获取列表迭代生成器；在迭代器中增加元素
        ListIterator<String> lit = li.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            if (s == "world"){
                lit.add("javaee");
            }
        }
        System.out.println(li);

    }
}

遍历练习题（迭代器iterator；普通for；增强for）

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

package com.itxuexi.it14.List04;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//----------------------------------------------------------------------------

package com.itxuexi.it14.List04;

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

public class StudentDemo {
    public static void main(String[] args) {
        //创建集合
        List<Student> li = new ArrayList<Student>();

        //实例化学生类
        Student s1 = new Student("李静",15);
        Student s2 = new Student("王玉",14);
        Student s3 = new Student("贺语",17);

        //往集合中添加元素
        li.add(s1);
        li.add(s2);
        li.add(s3);

        //迭代器 iterator ;集合特有的遍历方式
        Iterator<Student> it = li.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

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

        //普通for ：带有索引的遍历方式
        for(int i =0;i<li.size();i++){
            Student sf = li.get(i);
            System.out.println(sf.getName() + "," + sf.getAge());
        }

        System.out.println("-----------------------------");
        //增强for ：最方便的遍历方式
        for(Student i : li){
            System.out.println(i.getName() + "," + i.getAge());
        }

    }
}

数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

数据结构之栈和队列

栈结构：先进后出 (进栈ABCD 出栈DCBA)

队列结构：先进先出 (入队列ABCD 出队列ABCD )

数据结构之数组和链表

数组结构：查询快、增删慢

队列结构：查询慢、增删快

List集合的实现类

List集合子类的特点

ArrayList集合：底层是数组结构实现，查询快、增删慢

LinkedList集合：底层是链表结构实现，查询慢、增删快

ArrayList/LinkedList遍历（迭代器iterator；普通for；增强for）

package com.itxuexi.it14.List04;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//------------------------------------------------------------------

package com.itxuexi.it14.List04;

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

public class StudentArray {
    public static void main(String[] args) {
        //创建arraylist集合
        ArrayList<Student> arr = new ArrayList<Student>();

        //实例化学生对象
        Student s1 = new Student("赵谦",15);
        Student s2 = new Student("钱慧",17);
        Student s3 = new Student("孙俞",16);

        //将学生添加到集合中
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);

        //iterator迭代器
        Iterator<Student> it = arr.iterator();
        while(it.hasNext()){
            Student si = it.next();
            System.out.println(si.getName() + "," + si.getAge());
        }

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

        //for循环
        for(int i =0;i<arr.size();i++){
            Student sf = arr.get(i);
            System.out.println(sf.getName() + "," + sf.getAge());
        }

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

        //for加强版
        for(Student i : arr){
            System.out.println(i.getName() + "," + i.getAge());
        }

    }
}

LinkedList集合特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

package com.itxuexi.it14.List03;

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

public class LinkedListDemo {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList<String> ll = new LinkedList<String>();

        //添加元素
        ll.add("hello");

        //在该列表开头插入指定的元素
        ll.addFirst("hi");

        //将指定的元素追加到此列表的末尾
        ll.addLast("end");

        System.out.println(ll);

        // 返回此列表指定索引元素
        System.out.println(ll.get(1));

        // 返回此列表中的第一个元素
        System.out.println(ll.getFirst());

        // 返回此列表中的最后一个元素
        System.out.println(ll.getLast());
        
        //删除元素
        System.out.println(ll.remove(1));
        System.out.println(ll.remove("hi"));

        //从此列表中删除并返回第一个元素
        System.out.println(ll.removeFirst());

        //从此列表中删除并返回最后一个元素
        System.out.println(ll.removeLast());

    }
}