List接口基本介绍和常用方法理解

最新推荐文章于 2024-10-08 10:22:24 发布

昱晟168

最新推荐文章于 2024-10-08 10:22:24 发布

阅读量951

点赞数

分类专栏： JAVA集合必须掌握文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_47267628/article/details/123434796

版权

JAVA集合必须掌握专栏收录该内容

14 篇文章 1 订阅

订阅专栏

`List`接口和常见方法

List接口基本介绍：

List集合类中元素有序【即添加顺序和取出顺序一致】并且可以重复
List集合中的每个元素都有其对应的顺序索引，即支持索引
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素

List接口实现类

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gsjfTXs4-1647006333632)(E:\Typora笔记\java笔记\img\image-20220215164951479.png)]$

package collection_.collectionP.list_;

import java.util.ArrayList;

/**
 * @author: 海康
 * @version: 1.0
 */
public class List01 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("海康");
        list.add("广州");
        System.out.println("list="+list);
    }
}

`List`接口常用方法

List集合里添加了一些根据索引来操作集合元素的方法

插入
1.   boolean add(Object ele):在集合中尾部插入ele元素
1.   void add(int index,Object ele):在index位置插入ele元素    
2.   boolean  addAll(int index,Collection eles):在index位置开始将eles中的所有元素添加进来

查询
3.   Object get(int index):获取指定index位置的元素
4.   int indexOf(Object obj):返回obj在集合中首次出现的位置
5.   int lastIndexOf(Object obj):返回obj在当前集合中未次出现位置

移除
6.   Object remove(int index):移除指定index位置的元素，并返回此元素
  
替换
7.   Object set(int index,Object ele):设置指定index位置的元素为ele，相当于是替换

截取    
8.   List  subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合【相当于截取成子集合】

List接口常见方法

Modifier and Type	Method and Description
`boolean`	`add(E e)` 将指定的元素追加到此列表的末尾（可选操作）。
`void`	`add(int index, E element)` 将指定的元素插入此列表中的指定位置（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)` 按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
`void`	`clear()` 从此列表中删除所有元素（可选操作）。
`boolean`	`contains(Object o)` 如果此列表包含指定的元素，则返回 `true` 。
`boolean`	`containsAll(Collection<?> c)` 如果此列表包含指定 `集合的`所有元素，则返回true。
`E`	`get(int index)` 返回此列表中指定位置的元素。
`int`	`indexOf(Object o)` 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
`boolean`	`isEmpty()` 如果此列表不包含元素，则返回 `true` 。
`Iterator<E>`	`iterator()` 以正确的顺序返回该列表中的元素的迭代器。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`ListIterator<E>`	`listIterator()` 返回列表中的列表迭代器（按适当的顺序）。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
`E`	`remove(int index)` 删除该列表中指定位置的元素（可选操作）。
`boolean`	`remove(Object o)` 从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
`boolean`	`removeAll(Collection<?> c)` 从此列表中删除包含在指定集合中的所有元素（可选操作）。
`E`	`set(int index, E element)` 用指定的元素（可选操作）替换此列表中指定位置的元素。
`int`	`size()` 返回此列表中的元素数。
`default void`	`sort(Comparator<? super E> c)` 使用随附的 `Comparator`排序此列表来比较元素。
`default Spliterator<E>`	`spliterator()` 在此列表中的元素上创建一个`Spliterator` 。
`List<E>`	`subList(int fromIndex, int toIndex)` 返回此列表中指定的 `fromIndex` （含）和 `toIndex`之间的视图。
`Object[]`	`toArray()` 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
`<T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

List集合常用方法

package collection_.collectionP.list_;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class ListMethod01 {
    public static void main(String[] args) {
        List list = new ArrayList();

        // 1.添加元素: 添加元素有三种方式
        // 第一种是：在集合的尾部插入
        list.add("海康");
        // 第二种是：指定索引位置插入
        list.add(1,"广州");
        // 第三种方法是以集合的方式插入 boolean addAll(int index,Collection eles)
        // 以集合方式插入也有两种方式：一种是把集合插在另一个集合的尾部，另一种是在指定索引插入
        // 现在演示的是：指定索引位置插入\
        List list2 = new ArrayList();
        list2.add("南宁");
        list2.add("南兴");
        list.addAll(list2);

        // 获取指定索引位置的元素：
        Object o = list.get(2);
        System.out.println("索引为2的元素="+o);

        // 查找元素存在集合中的索引位置:有两种方式【如果不存在直接返回 -1 】
        //方式一：元素第一次出现索引的位置
        int index = list.indexOf("南兴");
        //方式二：元素最后一次出现索引的位置
        int lastIndexOf = list.lastIndexOf("广州");

        // 移除【删除】指定索引位置：删除也有两种方式：
        // 方式一：直接指定索引位置，删除
//        list.remove(0);
        // 方式二：指定删除那个集合
//        list.removeAll(list2);

        // 替换 set 在指定索引位置，替换成别的元素
        list.set(2,"上海");

        // 截取 集合中的子集合
        // 包含头部不包含尾部
        List subList = list.subList(0, 2);
        System.out.println(subList);
    }
}

List接口课堂练习

添加 10 个以上的元素（比如：String "hello"）,在2号位插入一个元素"海康科技"，获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，要求：使用List的实现类ArrayList完成

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ldqybTvW-1647006333634)(E:\Typora笔记\java笔记\img\image-20220215174314467.png)]$

package collection_.collectionP.list_;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class ListExercise01 {
    public static void main(String[] args) {
        /**
         * 添加 10 个以上的元素（比如：String "hello"）,在2号位插入一个元素"海康科技"，
         * 获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，要求：使用List的实现类ArrayList完成
         */
        List list = new ArrayList();
        list.add("海康");
        list.add("上海");
        list.add("南宁");
        list.add("西安");
        list.add("北京");
        list.add("hello");
        list.add("南兴");
        list.add("西藏");
        list.add("杭州");
        list.add("广州");
        // 在 2 号的位置插入一个元素 “海康科技园”
        list.add(1,"海康科技园");
        // 获取第 5 个元素
        Object o = list.get(4);
        System.out.println("第 5 个元素是="+o);
        // 删除第 6 个元素
        Object remove = list.remove(5);
        System.out.println("删除第 6 个元素="+ remove);
        // 修改第 7 个元素 修改元素使用的方法是 set方法
        list.set(6,"中国人");

        // 使用迭代器遍历集合
        /**
         * 使用迭代器遍历集合三步
         * 1.第一步：先获取迭代器对象
         * 2.第二步：判断是否有元素
         * 3.第三步：返回索引处元素
         */
        Iterator iterator = list.iterator();//获取迭代器对象
        while (iterator.hasNext()){// 判断是否有元素
            // 返回索引处元素
            Object next = iterator.next();
            System.out.println(next);
        }

        /**
         * 返回值：
         * 第 5 个元素是=西安
         * 删除第 6 个元素=北京
         * 海康
         * 海康科技园
         * 上海
         * 南宁
         * 西安
         * hello
         * 中国人
         * 西藏
         * 杭州
         * 广州
         */
    }
}

`List`的三种遍历方式

方式一：使用iterator【迭代器方式】
方式二：使用增强for循环
方式三：使用普通for循环

【使用普通 for 循环需要使用两个方法：一个获取多少个元素【size()方法】，一个是获取元素方法【get(int index)】】

练习题：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5mhEi7eE-1647006333635)(E:\Typora笔记\java笔记\img\image-20220215183134408.png)]$

自己写的代码：

package collection_.collectionP.list_;

import JAVA面向对象中级部分.encapsulationAndInherit.detail_.Cat;

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

/**
 * @author: 海康
 * @version: 1.0
 */
public class ListExercise02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Book("红楼梦","曹雪芹",100));
        list.add(new Book("西游记","吴承恩",10));
        list.add(new Book("西游记","吴承恩",10));
        list.add(new Book("水浒传","施耐庵",90));
        list.add(new Book("水浒传","施耐庵",18));

        // 按价格排序，从低到高【使用冒泡法】
        for (int i = 0; i < list.size()-1; i++) {
            for (int j = 0; j < list.size() -i -1; j++) {
                Book book1 = (Book) list.get(j);
                Book book2 = (Book) list.get(j+1);
                if (book1.getPrice()>=book2.getPrice()){
                    list.set(j,book2);
                    list.set(j+1,book1);
                }
            }
        }

        // 遍历集合输出相关信息
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            Book book = (Book) next;
            System.out.println("名称:"+ book.getName()+"\t价格:"+book.getPrice()+"\t作者:"+ book.getAuthor());
        }

        /**
         * 返回值：
         * 名称:西游记  价格:10.0    作者:吴承恩
         * 名称:西游记  价格:10.0    作者:吴承恩
         * 名称:水浒传  价格:18.0    作者:施耐庵
         * 名称:水浒传  价格:90.0    作者:施耐庵
         * 名称:红楼梦  价格:100.0   作者:曹雪芹
         */
    }
}

class Book{
    private String name;
    private String author;
    private double price;

    public Book() {
    }

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public String getAuthor() {
        return author;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

老师写代码：

package com.hspedu.list_;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

@SuppressWarnings({"all"})
public class ListExercise02 {

    public static void main(String[] args) {

        //List list = new ArrayList();
        List list = new LinkedList();
        //List list = new Vector();
        list.add(new Book("红楼梦", "曹雪芹", 100));
        list.add(new Book("西游记", "吴承恩", 10));
        list.add(new Book("水浒传", "施耐庵", 19));
        list.add(new Book("三国", "罗贯中", 80));
        //list.add(new Book("西游记", "吴承恩", 10));

        //如何对集合进行排序


        //遍历

        for (Object o : list) {
            System.out.println(o);
        }

        //冒泡排序
        sort(list);

        System.out.println("==排序后==");

        for (Object o : list) {
            System.out.println(o);
        }

    }

    //静态方法
    //价格要求是从小到大
    public static void sort(List list) {

        int listSize = list.size();
        for (int i = 0; i < listSize - 1; i++) {
            for (int j = 0; j < listSize - 1 - i; j++) {
                //取出对象Book
                Book book1 = (Book) list.get(j);
                Book book2 = (Book) list.get(j + 1);
                if (book1.getPrice() > book2.getPrice()) {//交换
                    list.set(j, book2);
                    list.set(j + 1, book1);
                }
            }
        }

    }
}



public class Book {
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "名称：" + name + "\t\t价格:" + price + "\t\t作者：" + author;
    }
}