Java中的容器解析----集合.2

最新推荐文章于 2024-07-14 22:26:46 发布

是番茄鱼啊

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量78

点赞数

分类专栏： Java 集合文章标签： java 列表并发编程语言

本文链接：https://blog.csdn.net/returnback_18/article/details/117199393

版权

Java 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

集合

3 篇文章 0 订阅

订阅专栏

1.List集合入门

很长时间没写SQL小函数了,今天更新一点,最近在总结小函数文档给新人学习使用,后续也会根据文档来做案例讲解,这篇文章先接着讲List集合,List集合的子类放到下一篇文章吧,每次内容尽量少一点,让不懂的同志们能够搞懂,理解,吸收,话不多说,开撸!

1.1 List集合常用方法

? public void add(int index, E element)
  解释: 在集合的指定位置(索引), 插入指定的元素, 索引越界会报IndexOutOfBoundsException异常.
? public E remove(int index)
  解释: 删除指定索引处的元素, 并返回被删除的元素, 索引越界会报IndexOutOfBoundsException异常.
? public E set(int index, E element)
  解释: 修改指定索引处的元素为指定的值, 并返回修改前的元素, 索引越界会报IndexOutOfBoundsException异常.
? public E get(int index)
 解释: 根据索引, 获取其对应的元素, 索引越界会报IndexOutOfBoundsException异常.

下面用代码演示入门方法,这些方法属于单列集合的通用方法,前一篇文章所述的方法属于单列集合的顶层方法,学会了上一篇文章中的方法基本上后续的单列集合都掌握了,只需要注意特殊方法即可

import java.util.ArrayList;
import java.util.List;
/*
    List集合中的特有成员方法:
        public void add(int index, E element);   在指定的位置插入指定的元素
        public E remove(int index);              根据索引, 移除指定的元素, 并返回此元素.
        public E set(int index, E element)     修改指定索引处的元素未指定的值, 并返回修改前的元素.
        public E get(int index)                  根据索引, 获取其对应的元素.

    细节:
上述的四个方法, 涉及到的索引如果不存在, 则会报: IndexOutOfBoundsException(索引越界异常)
 */
public class Demo02 {
    public static void main(String[] args) {
        //1.创建List集合, 用来存储字符串.
        List<String> list = new ArrayList<>();
        //2.往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
        list.add("hello");
        list.add("world");
        list.add("java");
        //3.演示上述的4个方法.
        //测试  public void add(int index, E element);   在指定的位置插入指定的元素
        //list.add(10, "加班加点敲代码");      //报错, 索引越界.
        //list.add(3, "加班加点敲代码");        //不报错


        //测试 public E remove(int index);              根据索引, 移除指定的元素, 并返回此元素.
        //System.out.println(list.remove(11));        //报错, 索引越界.
        //System.out.println(list.remove(1));          //不报错

        //测试public E set(int index, E element)       修改指定索引处的元素未指定的值, 并返回修改前的元素.
        //list.set(10, "老板真特么帅");      //报错, 索引越界.
        //list.set(3, "老板真特么帅");        //报错, 索引越界.
        //list.set(1, "老板真特么帅");         //不报错

        //测试 public E get(int index)                  根据索引, 获取其对应的元素.
        /*System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));*/

        //打印集合.
        System.out.println("list: " + list);
        System.out.println("------------------------");


        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(5);

        list2.remove(3);    //如果集合的泛型是Integer类型, 传入值后, 是按照索引走的.
        System.out.println(list2);  //1235
    }
}

1.2 List集合的遍历

1. 创建List集合, 用来存储字符串.
2. 往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
3. 通过for循环 + size() + get()的形式, 遍历List集合.
4. import java.util.ArrayList;
import java.util.List;

//案例: 演示List集合(独有)的遍历方式.
//思路: 通过for循环 + size() + get()的形式, 遍历List集合.
public class Demo03 {
    public static void main(String[] args) {
        //1.创建List集合, 用来存储字符串.
        List<String> list = new ArrayList<>();
        //2.往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
        list.add("hello");
        list.add("world");
        list.add("java");
        //3. 通过for循环 + size() + get()的形式, 遍历List集合.
        //分解版
        /*System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));*/

        //for循环版本
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

        //补充: for循环遍历List集合的快捷键: itli
    }
}

再来一个加深泛型理解的案例,学生类的定义自己去做,这里只演示List集合的用法

1. 定义一个学生类, 属性为姓名和年龄
2. 创建List集合, 用来存储学生对象
3. 往List集合中, 添加3个学生的信息
4. 分别通过两种遍历方式, 来遍历List集合 
public class Demo04 {
    public static void main(String[] args) {
        //1.定义一个学生类, 属性为姓名和年龄.
        //2.创建List集合, 用来存储学生对象.
        List<Student> list= new ArrayList<>();
        //3.往List集合中, 添加3个学生的信息.
        Student s1 = new Student("刘亦菲", 33);
        Student s2 = new Student("邱淑贞", 31);
        Student s3 = new Student("高圆圆", 35);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //4.分别通过两种遍历方式, 来遍历List集合.
        //方式一: 通过迭代器实现.
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            /*Student stu = it.next();
            System.out.println(stu);*/

            System.out.println(it.next());
        }
        System.out.println("--------------------");

        //方式二: 通过for() + size() + get()方法实现.
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu);
        }
    }
}

1.3.列表迭代器

列表迭代器指的是ListIterator接口, 它是List集合特有的迭代器.
该迭代器继承了Iterator迭代器，所以, 我们可以直接使用.
使用方法在上个案例中有使用

? List集合中的成员方法
  public ListIterator<E> listIterator()	//根据List集合对象, 获取其对应的列表迭代器对象. 
? ListIterator迭代器中的成员方法
  public boolean hasNext();  //判断集合中是否有下一个元素.
  public E next();     //有就获取集合中的下一个元素.
  public boolean hasPrevious()	//判断列表迭代器中, 是否有上一个元素. 
  public E previous()				//获取列表迭代器中的上一个元素.


 需求
1. 创建List集合, 用来存储字符串.
2. 往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
3. 通过列表迭代器对List集合分别进行正向遍历和逆向遍历. 

/*
    ListIterator简介
        概述:
            它是Iterator迭代器的子类(接口), 它主要是作用于List体系的, 它叫: 列表迭代器.
         涉及到的成员方法:
            List集合中的成员方法
                public ListIterator<E> listIterator();  //根据集合对象获取其对应的列表迭代器对象.
            ListIterator中的成员方法:
                hasNext();  判断集合中是否有下一个元素.
                next();     有就获取集合中的下一个元素.
                hasPrevious();  判断集合中是否有上一个元素.
                previous();     有就获取集合中的上一个元素.
        细节:
            通过列表迭代器进行逆向遍历之前, 必须先进行一次正向遍历.
 */
public class Demo01 {
    public static void main(String[] args) {
        //1.创建List集合, 用来存储字符串.
        List<String> list = new ArrayList<>();
        //2.往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
        list.add("hello");
        list.add("world");
        list.add("java");
        //3.通过列表迭代器对List集合分别进行正向遍历和逆向遍历.
        //3.1 通过ListIterator进行正向遍历.
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()) {
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("----------------------------");
        while(lit.hasPrevious()) {
            String s = lit.previous();
            System.out.println(s);
        }

        System.out.println(2 << 3);  //每往左移动一次, 相当于乘以 2
        System.out.println((2 << 4) - 1 );
    }
}
    //记忆: 通过列表迭代器进行逆向遍历之前, 必须先进行一次正向遍历. 此点尤为重要,当然后面也可以用方法反转遍历,但是此处有助于理解列表迭代器工作原理

1.4.并发修改异常(重要)

这里我们在演示问题中总结

public class Demo02 {
    public static void main(String[] args) {
        //1.创建List集合, 用来存储字符串.
        List<String> list = new ArrayList<>();
        //2.往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
        list.add("hello");
        list.add("world");
        list.add("java");
        //3.判断集合中是否有"world"元素, 如果有, 就往集合中添加一个"JavaEE".
        //使用普通的迭代器实现,  会报并发修改异常.
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            String s = it.next();
            //判断是否是"world", 如果是, 就添加"JavaEE"
            if ("world".equals(s)) {
                list.add("JavaEE");   //报错
            }
        }

    }
}




/*
    并发修改异常简介:
        问题描述:
            当使用普通迭代器(Iterator)遍历集合的同时, 又往集合中添加了元素, 就会报并发修改异常.
        产生原因:
            迭代器是依赖于集合而存在, 当判断成功后, 集合中添加了新的元素, 而迭代器不知道, 所以就报错了.
            其实这个问题说的是: 迭代器遍历集合中的元素时, 不要使用集合对象去修改集合中的元素.
        解决方案:
            1. 通过 列表迭代器(ListIterator)来解决.
                细节一: 必须使用列表迭代器中的添加元素的方法.    ListIterator#add();
                细节二: 这种方式添加的元素是在刚才迭代到的元素后边的.
            2. 通过for循环 + size()方法来解决.
                细节一: 这种方式添加的元素是在集合的最后位置添加的.
            3. 通过CopyOnWriteArrayList集合解决.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1.创建List集合, 用来存储字符串.
        List<String> list = new ArrayList<>();
        //2.往List集合中添加3个字符串值, 分别是: "hello", "world", "java".
        list.add("hello");
        list.add("world");
        list.add("java");
        //3.判断集合中是否有"world"元素, 如果有, 就往集合中添加一个"JavaEE".
        //方式一: 使用普通的迭代器实现,  会报并发修改异常.
        /*Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            String s = it.next();
            //判断是否是"world", 如果是, 就添加"JavaEE"
            if ("world".equals(s)) {
                list.add("JavaEE");   //并发
            }
        }*/

        //方式二: 使用列表迭代器实现.
       /* ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()) {
            String s = lit.next();
            //判断是否是"world", 如果是, 就添加"JavaEE"
            if ("world".equals(s)) {
                //细节一: 必须使用列表迭代器中的添加元素的方法.    ListIterator#add();
                lit.add("JavaEE");   //并发
            }
        }*/

       //方式三: 使用for + size()解决.
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            //判断是否是"world", 如果是, 就添加"JavaEE"
            if ("world".equals(s)) {
                list.add("JavaEE");   //并发
            }
        }

        //4. 打印集合
        System.out.println("list: " + list);
    }
}

OK 今天先到这里,同志们zaiwei!

是番茄鱼啊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java中的容器解析----集合.2

1.List集合入门很长时间没写SQL小函数了,今天更新一点,最近在总结小函数文档给新人学习使用,后续也会根据文档来做案例讲解,这篇文章先接着讲List集合,List集合的子类放到下一篇文章吧,每次内容尽量少一点,让不懂的同志们能够搞懂,理解,吸收,话不多说,开撸!1.1 List集合常用方法? public void add(int index, E element) 解释: 在集合的指定位置(索引), 插入指定的元素, 索引越界会报IndexOutOfBoundsException异常.?
复制链接

扫一扫