List及ArrayList/LinkedList常用方法以及所有迭代方式

Jax-李白

已于 2024-02-16 11:52:56 修改

阅读量495

点赞数

文章标签： list java

于 2022-10-28 22:46:19 首次发布

本文链接：https://blog.csdn.net/m0_61393256/article/details/127580655

版权

List
1.List集合是有下标的
2.List集合是有顺序的
3.List集合可以存放重复的元素
在这里插入图片描述
Collection基础方法复习+List常用方法测试

public class TestList {
    public static void main(String[] args) {
        //1.创建list的多态对象，注意list是接口，不可以实例化
        List<String> list=new ArrayList<>();
        //2.测试继承自Collection中单个集合的方法
        list.add("大娃");
        list.add("2娃");
        list.add("3娃");
        list.add("4娃");
        list.add("5娃");
        list.add("6娃");
        list.add("7娃");
        System.out.println(list);

        //list.clear();//清空集合
        System.out.println(list.contains("7娃"));//true，包含元素7娃
        System.out.println(list.isEmpty());//false,集合不为空
        System.out.println(list.remove("7娃"));//删除元素7娃
        System.out.println(list.size());//6，获取集合中元素的个数
        System.out.println(Arrays.toString(list.toArray()));//转为数组并打印

        //测试集合间的操作
        List<String>list2=new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        list2.add("4");
        System.out.println(list2);
        list.addAll(list2);//把集合2的元素添加到集合1
        System.out.println(list);
        System.out.println(list.containsAll(list2));//判断集合一中属于集合2的所有元素
        list.removeAll(list2);//删除集合一中属于集合二的元素
        System.out.println(list);
        list2.retainAll(list);//仅仅保留集合2中两个集合的公共元素
        System.out.println(list);//没有发生改变
        System.out.println(list2);//[],变成空集，谁来调用影响谁

        //3.测试list集合独有的方法
        /*list接口是有下标的、有序的、可以存放重复元素的集合*/
        list.add("小蝴蝶");
        list.add(1,"蛇精");//在指定的索引处添加元素
        list.add(3,"小蝴蝶");//在指定的索引处添加元素
        System.out.println(list);

        System.out.println(list.indexOf("小蝴蝶"));//判断元素第一次出现的下标
        System.out.println(list.lastIndexOf("小蝴蝶"));//判断元素最后一次出现的下标
        System.out.println(list.remove(5));//根据下标删除元素，并把删除的元素返回
        System.out.println(list);
        System.out.println(list.get(3));//根据索引获取对应元素
        System.out.println(list.set(7,"蝎子精"));//根据索引修改指定位置元素
        System.out.println(list);

        list2.add("231");
        list2.add("231");
        list2.add("231");
        list.addAll(list2);
        list.addAll(1,list2);
        System.out.println(list);
    }

}

List集合迭代所有方式

/*本类用于进一步测试List接口迭代*/
public class TestList2 {
    public static void main(String[] args) {
        //1.创建list接口多态对象
        List<String> list = new ArrayList<>();
        //2.向集合中存入元素
        list.add("喜羊羊");
        list.add("懒洋洋");
        list.add("美羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("肥牛卷");
        System.out.println(list);
        //3.测试集合的迭代
        /*集合的迭代方式
         * 1.for循环
         * 2.foreach循环
         * 3.iterator迭代器
         * 4.listIterator*/
        //方式1：因为list集合是有序的，元素是有下标的，所以可以根据下标进行遍历
        //从那开始 0  到那结束 list.size()-1 如何让变化 ++
        for (int i = 0; i < list.size(); i++) {
            //根据本轮循环到的下标值，获取集合中对应下标处的元素
            System.out.println(list.get(i));
        }
        System.out.println("**********************方式一********************");

        //方式2：因为普通for循环写法复杂，效率低，所以实用高效for循环
        //格式：for(每轮遍历到的元素类型 元素名:要遍历的数组/集合名){循环体}
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("**********************方式二********************");

        //方式3：使用的是从父接口Collection处继承过来的迭代器iterator
        Iterator<String> it = list.listIterator();
        while (it.hasNext()) {//只要hasNext()结果为true，说明还有下一个元素
            //打印本轮中迭代到的元素
            System.out.println(it.next());
        }
        System.out.println("**********************方式三********************");
        //方式四：使用list接口特有的迭代器ListIterator
        /*listIterator是list接口特有的迭代器
         * ListIterator<E>子接口--继承了父类的功能
         * listIterator还有自己的功能，比如逆序遍历，但并不常用*/
        ListIterator<String> it2 = list.listIterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
        System.out.println("**********************逆序迭代********************");
        ListIterator<String> it3 = list.listIterator();
        while (it3.hasNext()) {//判断是否有下一个元素迭代
            System.out.println(it3.next());//打印当前迭代到的元素
            if (!it3.hasNext()) {//直到迭代器没有下一个元素可以迭代--到最后了
                System.out.println("开始逆序迭代");
                while (it3.hasPrevious()) {//判断是否有上一个元素可以迭代
                    System.out.println(it3.previous());//打印获取到的上一个元素
                }
                break;//终止循环，不然会一直从头到尾，再从尾到头迭代
            }
        }
    }
}

Arraylist的特点
1.List接口的实现类
2.底层数据结构是数组，内存空间是连续的
3.元素有下标，有序，允许存放重复的元素
4.通常可以根据下标进行操作
5.增删操作比较慢，查询比较快 [数据量比较大的时候]
Arraylist常用方法以及迭代

/*本类用于ArrayList的相关测试*/
public class TestArrayList {
    public static void main(String[] args) {
        /*底层会帮助我们创建数组用于存放对象，并且数组的初始容量是10
        * ArrayList底层是数组*/
        //1.创建对应的集合对象
        ArrayList<Integer>list=new ArrayList();
        //2.向集合添加元素
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(400);
        list.add(300);
        System.out.println(list);

        //3.测试ArrayList常用方法
       //list.clear();//清空集合
        System.out.println(list);
        System.out.println(list.contains("100"));//false,是否包含String类型的元素”100“
        System.out.println(list.get(0));//100，获取集合中下标为0的元素
        System.out.println(list.indexOf(400));//获取元素第一次出现的索引
        System.out.println(list.lastIndexOf(400));//获取元素最后一次出现的索引

        System.out.println(list.remove(1));//根据下标删除集合中的元素
        //System.out.println(list.remove(300));//Integer集合.remove()整数的话默认为下标，此时会出现数组下标越界异常
        /*上面的代码会报错：数组下标越界：index 300，size 5
        * 主要是因为list中有两个重载的remove()，如果直接传入数字300
        * 会直接匹配int类型的index索引方法，而不会认为这是一个Integer类型的数据
        * 所以，如果想要根据指定元素删除数据，需要把int类型的数据手动装箱成Integer*/
        System.out.println(list.remove(Integer.valueOf(300)));//指定Integer类型集合元素删除，而非指定下标
        System.out.println(list);

        System.out.println(list.size());//获取集合的元素个数
        list.set(2,777);//修改下标2处的元素，值为777
        System.out.println(list);

        //1.使用for循环迭代集合
        System.out.println("方式1");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("方式2");
        for (Integer i:list){
            System.out.println(i);
        }
        System.out.println("方式3");
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4.使用list独有的迭代器listIterator
        System.out.println("方式4");
        ListIterator<Integer> it2 = list.listIterator();
        while (it2.hasNext()){
            System.out.println(it2.next());
        }
    }
}

LinkedList特点
1.List接口的实现类
2.底层的数据结构是链表，内存空间是不连续的
3.元素有下标，有序，允许存放重复的元素
4.通常进行首尾节点的操作比较多
5.增删操作比较快，查询操作比较慢[数据量比较大时]
注意：LinkedList的查询操作也不是都慢，首尾操作还是很快的
在这里插入图片描述
LinkedList常用方法

public class TestLinkedList {
    public static void main(String[] args) {
        //1.创建集合对象
        LinkedList<String>list=new LinkedList<>();
        //2.添加数据
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("唐三藏");
        list.add("沙师弟");
        list.add("白龙马");
        System.out.println(list);
        //3.测试LinkedList独有方法
        list.addFirst("蜘蛛精");//向链表添加首元素
        list.addLast("玉兔精");//向链表添加尾元素
        System.out.println(list);

        System.out.println(list.getFirst());//获取链表中的首元素
        System.out.println(list.getLast());//获取链表中的尾元素

        System.out.println(list.removeFirst());//删除链表的首元素，并返回被删除的元素
        System.out.println(list.removeLast());//删除链表的尾元素，并返回被删除的元素
        System.out.println(list);
        //4。其他测试
        //创建新的集合
        LinkedList<String>list1=new LinkedList<>();
        list1.add("水浒传");
        list1.add("三国");
        list1.add("西游");
        list1.add("红楼梦");
        System.out.println(list1);
        System.out.println(list1.element());//获取首元素
        System.out.println(list1);
        /*别名：查询系列*/
        System.out.println(list1.peek());//获取首元素
        System.out.println(list1.peekFirst());//获取首元素
        System.out.println(list1.peekLast());//获取尾元素

        /*别名：新增系列*/
        System.out.println(list1.offer("易经"));//添加尾元素
        System.out.println(list1);
        System.out.println(list1.offerFirst("三体"));//添加首元素
        System.out.println(list1.offerLast("wa"));//添加尾元素
        System.out.println(list1);

        /*别名：移除系列*/
        System.out.println(list1.poll());//删除首元素
        System.out.println(list1);
        System.out.println(list1.pollFirst());//删除首元素
        System.out.println(list1.pollLast());//删除尾元素
        System.out.println(list1 );
    }
}

Jax-李白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
List及ArrayList/LinkedList常用方法以及所有迭代方式

注意：LinkedList的查询操作也不是都慢，首尾操作还是很快的。5.增删操作比较慢，查询比较快 [数据量比较大的时候]5.增删操作比较快，查询操作比较慢[数据量比较大时]2.底层的数据结构是链表，内存空间是不连续的。2.底层数据结构是数组，内存空间是连续的。3.元素有下标，有序，允许存放重复的元素。3.元素有下标，有序，允许存放重复的元素。3.List集合可以存放重复的元素。4.通常进行首尾节点的操作比较多。2.List集合是有顺序的。1.List接口的实现类。1.List接口的实现类。
复制链接

扫一扫