Java-Collection、List_java collection 和list-CSDN博客

本文链接：https://blog.csdn.net/qq_46238275/article/details/117364302

本文介绍了Java集合框架中的Collection接口和List接口，包括它们的特点、常用方法及其实现类ArrayList。通过实例展示了如何创建集合、添加元素、遍历元素、修改和删除元素。同时讲解了List的有序性和可重复性，以及特有的添加、删除和修改元素的方法。最后，探讨了并发修改异常和ListIterator的使用，以及增强for循环在遍历List集合中的应用。

摘要由CSDN通过智能技术生成

1.Collection

1.1集合基础知识
集合类的特点：提供一种存储空间可变的存储类型，存储的数据容量随时可以发生改变
1.2集合类体系结构
在这里插入图片描述
1.3 Collection 集合概述和使用

Collection集合概述
是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
IDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现
创建Collection集合的对象
多态的方式
具体的实现类ArrayList

小例子：

package smile1;
import java.util.Collection;
import java.util.ArrayList;
public class caogao {
    public static void main(String[] args){
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //添加元素 boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);
        //输出[hello, world, java]
    }
}

1.4Collection集合常用的方法
在这里插入图片描述
举例：

package smile1;
import java.util.Collection;
import java.util.ArrayList;
public class caogao {
    public static void main(String[] args){
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //boolean add(E e):添加元素，这个方法总是返回true
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);//输出[hello, world, java]

        //boolean remove(Object o):从集合中移除指定元素
        System.out.println(c.remove("hello"));//true,集合中少一个元素
        System.out.println(c);
        System.out.println(c.remove("hel"));//false,集合中元素不少
        System.out.println(c);

        //void clear():清空集合中的元素
        c.clear();
        System.out.println(c);//输出[]

        //boolean contains(Object o):判断集合中是否存在指定元素
        System.out.println(c.contains("world"));//true

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

        //int size():集合的长度，也就是集合中元素的个数
        System.out.println(c.size());
    }
}

1.5Collection集合的遍历

Iterator:迭代器，集合的专用遍历方式
Iterator iterator:返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
Iterator中的常用方法
E next():返回迭代中的下一个元素
boolean hasNext():如果迭代具有更多元素，则返回true

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

public class caogao {
    public static void main(String[] args){
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
//Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到,其泛型和集合泛型一样
        Iterator<String> it=c.iterator();
//iterator()得到的是iterator的具体实现类itr的对象，故这是一个多态的方式得到Iterator的对象
        //E next():返回迭代中下一个元素
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());//三个元素已经迭代结束了，再迭代会出错
        System.out.println(it.next());//NoSuchElementException:表示被请求的元素不存在

        //boolean hasNext():如果迭代具有更多元素，则返回true
        if(it.hasNext()){
            System.out.println(it.next());
        }//每次迭代时进行判断就不会出错

        //while循环改进判断
        while(it.hasNext()){
            System.out.println(it.next());//方法一
            String s=it.next();//方法二
            System.out.println(s);
        }
    }
}

1.6集合的使用步骤

1.创建集合对象
2.添加元素直接添加元素到集合或
2.1创建元素
2.2添加元素到集合
3.遍历集合
3.1通过集合对象获取迭代对象
3.2通过迭代器对象的hasNext()方法判断是否还有元素
3.3通过迭代器对象的next()方法获取下一个元素

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

public class caogao {
    public static void main(String[] args){
        Collection<String> c=new ArrayList<String>();//1.创建集合对象
        String s="hello";//2.添加元素（创建元素、添加元素到集合）
        c.add(s);
        c.add("world");//直接添加元素到集合
        //3.遍历集合
        Iterator<String> it=c.iterator();//3.1通过集合对象获取迭代对象
        while(it.hasNext()){//3.2通过迭代器对象的hasNext()方法判断是否还有元素
            String ss=it.next();//3.3通过迭代器对象的next()方法获取下一个元素
            System.out.println(ss);
        }
    }
}

案例在这里插入图片描述

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

public class caogao {
    public static void main(String[] args){
        Collection<Student> c=new ArrayList<Student>();
        Student s1=new Student("小李",18);
        Student s2=new Student("小申",19);
        Student s3=new Student("小张",20);
        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());
        }
    }
}
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;
    }
}

2.List

2.1 List集合概述和特点

List集合概述
有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素
List集合的特点
有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

package smile1;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class caogao {
    public static void main(String[] args){
        //创建集合对象
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");
        //输出集合对象
        System.out.println(list);
        //迭代器的方式遍历
        Iterator<String> it= list.iterator();
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s);
        }
    }
}

2.2List集合特有的方法
继承自Collection,故有它的全部方法，特有的方法如下
在这里插入图片描述

package smile1;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class caogao {
    public static void main(String[] args){
        //创建集合对象
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");

        //void add(int index,E element):在此集合中的指定位置插入指定的元素
        list.add(1,"hello1");//[hello, hello1, world, java, hello]
        //list.add(11,"hello11");//越界

        //E remove(int index):删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(1));//输出 hello1；集合里还剩下[hello, world, java, hello]

        //E set(int index,E element):修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(1,"javaee"));//在上面的基础上，修改的是world，集合里元素为[hello, javaee, java, hello]

        //E get(int index):返回指定索引处的元素
        System.out.println(list.get(1));
        //输出集合对象
        System.out.println(list);//[hello, javaee, java, hello]

        //另一种遍历方式，利用list有索引来用for循环遍历
        for(int i=0;i<list.size();i++){
            String s=list.get(i);
            System.out.println(s);
        }
        //hello
        //javaee
        //java
        //hello
    }
}

案例：List集合存储学生对象并遍历
在这里插入图片描述

package smile1;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class caogao {
    public static void main(String[] args) {
        //创建对象
        List<Student> list=new ArrayList<Student>();
        //创建学生对象
        Student s1=new Student("小李",18);
        Student s2=new Student("小张",19);
        Student s3=new Student("由",19);
        //添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //遍历1
        Iterator<Student> it=list.iterator();
        while(it.hasNext()){
            Student s=it.next();
            System.out.println(s.getname()+","+s.getage());
        }
        //遍历2
        for(int i=0;i<list.size();i++){
            Student s=list.get(i);
            System.out.println(s.getname()+","+s.getage());
        }

    }
}
class Student{
    String name;
    int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getname(){
        return name;
    }
    public int getage(){
        return age;
    }
}

2.3并发修改异常
在这里插入图片描述

package smile1;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class caogao {
    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循环时不报错
        for(int i=0;i<list.size();i++){
            String s=list.get(i);
            if(s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);

    }
}

2.4Listlterator

Listerator:列表迭代器
通过listlterator()方法得到，所以说它时List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
Listlterator中的常用方法
E next():返回迭代中的下一个元素
boolean hasNext():如果迭代具有更多元素，返回true
E previous():返回列表中的上一个元素
boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add(E e):将指定的元素插入列表

package smile1;
import java.util.*;

public class caogao {
    public static void main(String[] args) {
        //创建对象
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //通过List集合的ListIterator()方法
        //再次尝试：遍历集合，如果有world这个元素，则添加一个元素javaee  不报错，划重点
        ListIterator<String> lit=list.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
        }
        System.out.println(list);//输出[hello, world, javaee, java]
        /*
        //正向遍历,了解
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
        //逆向遍历，了解
        while(lit.hasPrevious()){
            String s=lit.previous();
            System.out.println(s);
        }
        */
    }
}

2.5增强for循环

增强for：简化数组和Collection集合的遍历
实现Iterable接口的类允许其对象成为增强型for语句的目标
它是JDK5之后出现的，其内部原理是一个Iterator迭代器
增强for格式
格式：
for(元素数据类型变量名：数组或者Collection集合){
//此处使用变量即可，该变量就是元素}

package smile1;
import java.util.*;

public class caogao {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        for(int i:arr){
            System.out.println(i);
        }
        String[] str={"hello","java","world"};

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

        List<String> list=new ArrayList<String>();
        list.add("小李");
        list.add("小张");
        list.add("小马");
        //遍历1 迭代器
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String st=it.next();
            System.out.println(st);
        }
        //遍历2 list索引遍历
        for(int i=0;i<list.size();i++){
            String st=list.get(i);
            System.out.println(st);
        }
        //遍历3 增强for循环
        for(String ss:list){
            System.out.println(ss);
        }
        /*证明增强for循环其内部就是iterator迭代器
        for(String ss:list){
            if(ss.equals("小李")){
                list.add("javaee");//ConcurrentModificationException 出现并发控制异常，证明其内部就是iterator迭代器
            }
        }
        */
    }
}

2.6List集合子类特点

List集合常用子类：ArrayList、LinkedList
ArrayList:底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快

List集合接口
集合的声明创建及使用的方法
举例1：
创建List集合类型的一个变量,声明其类型,名字strings，实现方式是对象数组
思考：用什么具体的数据结构存储这些元素呢
（List下的两个主要的实现类ArryList,LinkedList）
创建一个实现类ArryList,即对象数组的实现，ArryList的泛型有但不需要写
最终：创建List集合类型的一个变量,声明其类型,名字strings，实现方式是对象数组

 List<String> strings = new ArrayList<>();
 //collection接口下添加元素的方法
 strings.add("df");

同理举例2：
声明一个整型的只能放整数的集合
注意：List不可以，涉及到泛型，具体的类型需要使用引用类型，而int是基本的数据类型，故需要使用其引用类型即其包装类

 List<Integer> Integers = new ArrayList<>();
//添加元素
 Integers.add(12);

相关示例

package smile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class main1{
    private  static final List<User> Users=create();

    private static List<User> create(){
        User u1=new User("BO");
        User u2=new User("SUN");
        User u3=new User("SUN");
        List<User> users=new ArrayList<>();
        users.add(u1);
        users.add(u2);
        users.add(u3);
        return users;
    }
    public static void main(String [] args) {
       // getsize();
       // forByIndex();
        //updateElement();
        //addRepeatElement();
        listToArray();
    }
    private static void addSubClass(){
        //Users.add(new Object());  元素不可以放User的父类
        Users.add(new student());//可以放入User的子类，不报错；故只有指定类型及其子类才可以放进去
    }
    private static void getsize(){//一些基本的方法
        System.out.println(Users.size());//数组大小
        System.out.println(Users.isEmpty());//判断是否为空
    }
    private static void forByIndex(){//基于索引的基本for循环,将三个元素名字依次打出来
        for (int i=0;i<Users.size();i++)//一种循环方法
            System.out.println(Users.get(i).getname());
        for (User u:Users){//foreach循环，另一种循环方法
            System.out.println(u.getname());
        }
    }
    private static void updateElement(){//更新元素
        User user=Users.get(0);//从集合当中把第0个元素取出来
        user.setname("ZHANG");//把它的名字改成zhang
        for(User u:Users){
            System.out.println(u.getname());
        }
    }
    private static void addRepeatElement(){//添加重复元素
        User user=Users.get(0);
        Users.add(user);//从集合中拿出第0个元素再添加进去,集合变成四个元素，可以添加重复的元素
        for(User u:Users){
            System.out.println(u.getname());
        }
    }
    private static void removeElement(){//移除指定元素
        for(User u:Users){//依次拿集合中的元素比，将指定名字的字符串移除出去
            if("BO".equals(u.getname())){//删除第一个元素出现异常，换成第二个元素，发现只能删除一个指定名字的字符串；应对措施待定
                Users.remove(u);
            }
        }
    }
    private static void listToArray(){//集合转数组
        User[] users=Users.toArray(new User[0]);//toArray是把泛型重写了
        for(User u:Users){
            System.out.println(u.getname());
        }
    }
    private static void arrayToList(){//数组转集合
        User[] users=Users.toArray(new User[0]);
        //把上面这个数组转成集合
        List<User> userList = Arrays.asList(users);
//注意asList方法是适配器模式方法，仅仅转换了类型，底层仍然是数组，而数组长度不可改变，故将其作为集合来修改长度时会出错
    }

}
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;
    }
}
class student extends User{

        }