Day17

最新推荐文章于 2024-07-11 17:24:34 发布

Demo0000001

最新推荐文章于 2024-07-11 17:24:34 发布

阅读量77

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_53409953/article/details/115224617

版权

Collection

集合类体系结构

在这里插入图片描述

注：蓝色框为接口红色框为实现类

Collection 集合概述和使用

Collection集合概述

是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
JDK不提供此接口的任何直接实现，他提供更具体的子接口（如Set和List）实现

创建Collection集合的对象

多态的方式
具体的实现类ArrayList
```
Collection<E> c= new ArrayList<E>()
```

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

        //添加元素：boolean add（E e）
        c.add("hello");
        c.add("java");
        c.add("world");

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

Collection 集合常用方法

方法名	说明
boolean add（E e）	添加元素
boolean remove（Object o）	从集合中移除指定的元素
void clear（）	清空集合中的元素
boolean contains（Object o）	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

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

        //boolean add（E e）添加元素
        //调用此方法永远返回true
        /*
        System.out.println(c.add("hello"));
        System.out.println(c.add("hello"));
         */
        c.add("hello");
        c.add("hello");

        boolean remove（Object o）从集合中移除指定的元素
        c.remove("hello");

        void clear（）清空集合中的元素
        c.clear();

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

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

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


        System.out.println(c);

    }
}

Collection 集合的遍历

Iterator：迭代器集合的专用遍历方式

Iterator iterator（）:返回此集合中元素的第二代其，通过集合的iterator（）方法得到
迭代器是通过集合的iterator（）方法得到的，所以我们说她是依赖与=于集合而存在的

Iterator 中常用的方法

E next（）：返回迭代中的下一个元素
boolean hasNext（）：如果迭代具有更多的元素，则返回true

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("java" );
        c.add("world");

        //Iterator <E>iterator（）:返回此集合中元素的第二代其，通过集合的iterator（）方法得到
        Iterator<String> it =c.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
        while(it.hasNext()){
            System.out.println(it.next());
        }
        
    }
}

在这里插入图片描述

案例：Collection存储学生对象并遍历

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

public class CollectionStudent {
    public static void main(String[] args) {
        Collection<Student> a= new ArrayList<Student>();

        //创建学生对象
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",28);
        Student s3=new Student("王五",38);

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

        //遍历集合
        Iterator<Student> it=a.iterator();
        while(it.hasNext()){
            Student s=it.next();
            System.out.println(s.getName()+" "+s.getAge());
        }
    }
}

List

List集合概述和特点

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

特点：

有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

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

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

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

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

        //遍历 迭代器的方式
        Iterator<String> it=list.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）	返回指定索引处的元素

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

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

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



        //void add（int index， E element）在此集合中的指定位置插入指定的元素
        list.add(2,"world");

        //E remove（int index）删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(1));

        //E set （int index， E element）删除指定索引处的元素，返回被修改的元素
        System.out.println(list.set(0,"hello"));

        //E get （int index）返回指定索引处的元素
        System.out.println(list.get(3));


        //输出

        System.out.println(list);
        
         //用for循环修改遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

并发修改异常

ConcurrentModificationException

产生原因

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

解决方案：

用for循环遍历

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

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

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

        //遍历 迭代器的方式
        //此方法会导致预期修改次数和实际修改次数不一致 造成错误异常
//        Iterator<String> it=list.iterator();
//        while(it.hasNext()){
//            String s =it.next();
//            System.out.println(s);
//            if(s.equals("hello")){
//                list.add("java");
//        }

        for (int i = 0; i < list.size(); i++) {
            String s=list.get(i);
            if(s.equals("hello")){
                list.add("java");
            }
        }
    }

    }

ListIterator

ListIterator：列表迭代器

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

ListIterator中的常用方法

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

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

        //添加元素
        list.add("hello1");
        list.add("hello2");
        list.add("hello3");

        ListIterator<String> lis = list.listIterator();

        //通过迭代器访问
        while(lis.hasNext()) {
            String s = lis.next();
            System.out.println(s);
        }

        //逆向遍历
        while(lis.hasPrevious()) {
            String s = lis.previous();
            System.out.println(s);
        }


        //void add（E e）：将指定元素插入列表
        while(lis.hasNext()) {
            String s = lis.next();
            if(s.equals("hello1")){
                lis.add("world");
            }
        }
        System.out.println(list);
    }
}

增强for 循环

在这里插入图片描述

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

        System.out.println("===================");
        String [] str={"我","很","好"};
        for(String s:str){
            System.out.println(s);
        }

        System.out.println("===================");
        //创建集合对象
        List<String> list= new ArrayList<String>();

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

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

List集合子类特点

List集合常用子类：Arraylist ，Linkedlist

Arraylist：底层数据结构是数组，查询快，增删慢
Linkedlist：底层数据结构是链表，查询慢，增删快；

LinkedList集合的特有功能

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

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

        //添加数据
        list.add("hello");
        list.add("world");
        list.add("Java");

        //public  void addFirst（E e）在该列表开头插入指定的元素
        list.addFirst("我");

        //public  void  addLast(E e)将指定的元素追加到此列表的结尾
        list.addLast("你");

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

        //public E getLast()返回此列表中的最后一个元素
        System.out.println(list.getLast());

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

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


        //打印 链表
        System.out.println(list);
    }
}

Set集合概述和特点

Set集合特点

不包含重复的元素
没有带索引的方法，所以不能使用for循环遍历

Set集合练习

/*
Set集合特点

1. 不包含重复的元素
2. 没有带索引的方法，所以不能使用for循环遍历

   HashSet：对集合的迭代顺序不作任何保证
 */
public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set= new HashSet<>();

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

        //遍历
        for (String s: set){
            System.out.println(s);
        }
    }
}

Demo0000001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Day17

Collection集合类体系结构注：蓝色框为接口红色框为实现类Collection 集合概述和使用Collection集合概述是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素JDK不提供此接口的任何直接实现，他提供更具体的子接口（如Set和List）实现创建Collection集合的对象多态的方式具体的实现类ArrayListCollection<E> c= new ArrayList<E>()publ
复制链接

扫一扫