JAVASE基础（十五）

最新推荐文章于 2022-07-10 20:02:34 发布

fjs_43

最新推荐文章于 2022-07-10 20:02:34 发布

阅读量171

点赞数

分类专栏： java 文章标签： List集合体系 ArrayList LinkedList

本文链接：https://blog.csdn.net/weixin_36412090/article/details/77587891

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、List接口

集合的体系：
———| Collection 单列集合的根接口。
————-| List 如果是实现了List接口的集合类，具备的特点：有序，元素可重复。
————-| Set 如果是实现了Set接口的集合类，具备的特点：无序，元素不可重复。

有序：在集合中所谓的“有序”不是指自然顺序，而是指添加进去的顺序与存储的顺序一致。

List接口下面特有的方法：

增加
     add(int index, E element)     指定索引值添加元素
     addAll(int index, Collection c)  指定索引值把一个集合的元素添加到另外一个集合中、


删除
    remove(int index)   指定索引值删除元素

修改

    set(int index, E element)      指定索引值修改元素

获取
    get(int index)       根据索引值获取元素
    indexOf(Object o)    查找指定元素第一次出现的索引值, 如果不包含指定的元素则返回-1表示.
    lastIndexOf(Object o)   查找指定元素最后一次出现的索引值， 如果不包含指定的元素则返回-1表示.
    subList(int fromIndex, int toIndex)   指定开始于结束的索引值截取集合中的元素，返回 


迭代
    listIterator() 
    listIterator特有的方法：

    next()  :    先获取当前游标指向的元素，然后游标向下移动一个 单位。

    hasPrevious()  问是否有上一个元素
    previous()     游标先向上移动一个单位，然后获取当前游标指向的元素。


    add(E e)        把元素添加到当前游标指向的位置上。
    set(E e)        使用指定的元素替代迭代器最后一次返回的元素。

List接口特有的方法都是操作索引值的

public class Demo3 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("王林");
        list.add("马云");
        list.add("志军");

        /*
        List list2 = new ArrayList();
        list2.add("如花");
        list2.add("凤姐");
        list2.add("美美");

         * 添加
        list.add(1,"化腾");
        list.addAll(2, list2);
        * 
        * 删除

        System.out.println("返回被删除的元素："+ list.remove(2));

        修改      
        list.set(1, "马元坤");
        */

        System.out.println("集合的元素："+ list);     
    }

}

public class Demo4 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("王林");
        list.add("马云");
        list.add("志军");
        list.add("马云");

        /*
        System.out.println("元素："+ list.get(2));

        for(int index = 0 ; index< list.size() ; index++){
            System.out.print(list.get(index)+",");
        }

        System.out.println("索引值："+ list.indexOf("马云"));
        System.out.println("最后一次出现 的元素索引值："+ list.lastIndexOf("马云"));

        List subList = list.subList(2, 4) ; // 包头不包尾
        System.out.println("子集合的元素："+ subList);
        */
    }

}

public class Demo5 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("王林");
        list.add("马云");
        list.add("志军");
        list.add("表哥");

        ListIterator it = list.listIterator();  // 获取到一个迭代器

        /*
        it.next();
        it.next();
        //System.out.println("有上一个元素吗？"+ it.hasPrevious());
        System.out.println("上一个元素："+ it.previous());
        *


        while(it.hasNext()){
            it.next();
        }

        while(it.hasPrevious()){
            System.out.print(it.previous()+",");
        }

        it.add("宝宝");
        */
        it.next();
        it.next();
        it.set("狗娃");

        System.out.println("集合的元素："+ list);

    }

}

需求：使用四种方式遍历集合的元素
public class Demo6 {

public static void main(String[] args) {
    List list=  new ArrayList();
    list.add("王林");
    list.add("万林");
    list.add("表哥");
    list.add("标哥");

    //  方式一：toArray();
    Object[] arr = list.toArray(); // 把集合的元素添加到一个Object数组中返回。
    System.out.println("==========toArray方式遍历=========");
    for(int i = 0;  i < arr.length ; i++){
        System.out.print(arr[i]+",");
    }



    // 方式二： 使用for循环配合 get的方式。
    System.out.println("\r\n=====get方式遍历=====");
    for(int i = 0 ; i< list.size() ; i++ ){
        System.out.print(list.get(i)+",");
    }


    //方式三：使用迭代器正序遍历
    System.out.println("\r\n======迭代器正序遍历========");
    ListIterator it = list.listIterator(); 
    while(it.hasNext()){
        System.out.print(it.next()+",");
    }

    //方式四：使用迭代器逆序遍历。
    System.out.println("\r\n======迭代器逆序遍历========");
    while(it.hasPrevious()){
        System.out.print(it.previous()+",");
    }
}

}

迭代器在迭代的过程中要注意的事项：

    1. 迭代器在迭代的过程中不准使用集合对象改变集合的元素个数。 否则会报出：ConcurrentModificationException
    2. 在迭代过程中如果需要改变集合中的元素个数，只能使用迭代器的方法去改变。

public class Demo7 {

    public static void main(String[] args) {
        List list=  new ArrayList();
        list.add("王林");
        list.add("万林");
        list.add("表哥");

        ListIterator it = list.listIterator();  //获取一个迭代器
        while(it.hasNext()){
            System.out.print(it.next()+",");
            it.add("狗娃"); //使用的是迭代器的add方法。 迭代器的add方法是把元素添加到当前游标指向的位置。   
//          list.add("狗娃"); //使用集合对象的add方法，元素每次都是添加到集合对象的最后面。  

//          list.remove(2);
        }

/*
        list.add("狗娃");


        it.next(); 
        */
    }

}

二、arrayList接口

集合的体系：
———| Collection 单列集合的根接口
————–| List 如果是实现了List接口的集合类具备的特点：有序，元素可重复。
——————| ArrayList ArrayList的底层是维护了一个Object数组去实现的，特点：查询速度快，增删慢。

ArrayList的应用场景：
如果操作的数据时查询比较多，增删比较少，这时候则应该使用ArrayList. 比如：图书馆。

笔试题目：使用 ArrayList无参的构造方法是默认的容量是多少？当容量不够使用时，自动回增长多少？
ArrayList的底层是使用了一个Object数组去实现的，往ArrayList存储数据的时候，数据实际上
是存储到了Object数组中，使用无参构造函数是，Object数组的初始化容量是10，当容量不够使用时会自动自增原来的0.5倍。

ArrayList接口实现原理:

三、LinkedList接口

集合的体系：
———| Collection 单列集合的根接口
————–| List 如果是实现了List接口的集合类具备的特点：有序，元素可重复。
——————| ArrayList ArrayList的底层是维护了一个Object数组去实现的，特点：查询速度快，增删慢。
——————| LinkedList 底层是使用了链表数据结构实现的，特点：查询速度慢，增删快。

LinkedList特有的方法：

1：方法介绍
            addFirst(E e)   把元素添加到集合的首位置
            addLast(E e)    把元素添加到集合的末尾处。

        getFirst()     获取集合的首位置元素
        getLast()        获取集合的末尾元素


        removeFirst()   删除集合的首元素
        removeLast()    删除集合的末尾元素

2：数据结构
        1：栈 （1.6）
            先进后出
            push() 
            pop()

        2：队列（双端队列1.5）
            先进先出
            offer()
            poll()
3：返回逆序的迭代器对象      
    descendingIterator()   返回逆序的迭代器对象

LinkedList实现原理：

栈与队列数据结构特点：
这里写图片描述

public class Demo10 {

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("张三");
        list.add("李四");
        list.add("王五");

    /*  list.addFirst("狗娃");
        list.addLast("狗剩");

        System.out.println("首元素："+ list.getFirst());
        System.out.println("末尾元素："+ list.getLast());

        System.out.println("删除的首元素："+ list.removeFirst());
        System.out.println("删除末尾元素："+ list.removeLast());

        */


        list.push("狗娃");  //把元素添加到集合的首位置
        System.out.println("出栈（删除并返回集合中首元素）："+ list.pop());


        /*
        list.offer("标哥");
        System.out.println("删除并返回集合的首元素:"+ list.poll());
        */


        Iterator it = list.descendingIterator(); 
        while(it.hasNext()){
            System.out.print(it.next()+",");
        }
    }

}