11.常用API—ArrayList

作者: 每天起床都想摆 | 来源:发表于2022-01-13 19:36 被阅读0次

ArrayList

集合概述

ArrayList类代表的是集合类，集合是一种容器，与数组类似，不同的是集合的大小是不固定的
集合的大小不固定，启动后可以动态变化，类型也可以选择不固定
集合非常适合元素个数不确定，且要进行增删操作的业务场景
集合相比数组而言，提供了大量丰富的API

ArrayList集合快速入门

ArrayList是集合中的一种，它支持索引
ArrayList集合的对象获取

构造器说明

public ArrayList() 创建一个空的集合对象
ArrayList集合添加元素的方法

方法名说明

public boolean add(E e) 将指定的元素追加到集合的末尾

public void add(int index, E element) 在此集合中的指定位置插入指定的元素

构造器	说明
public ArrayList()	创建一个空的集合对象

方法名	说明
public boolean add(E e)	将指定的元素追加到集合的末尾
public void add(int index, E element)	在此集合中的指定位置插入指定的元素

package com.java.test;

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 1.创建ArrayList对象，代表集合容器，往里面添加元素
        ArrayList list = new ArrayList();
        // 2. 添加数据
        list.add("Java");
        list.add("MySQL");
        list.add("后端开发");
        list.add(666);
        list.add(233.33);
        list.add('S');

        // add方法添加成功返回true，失败返回false；通常情况下，集合add操作不会失败
        System.out.println(list.add("^_^"));
        // 直接打印集合list对象，和数组不同的是得到的不是地址值，而直接是遍历了集合中的元素
        System.out.println(list);

        // 指定索引插入元素，原本的元素以及其后所有的元素向后挪
        list.add(1, "最好的伙伴");
        System.out.println(list);
    }
}
/*
true
[Java, MySQL, 后端开发, 666, 233.33, S, ^_^]
[Java, 最好的伙伴, MySQL, 后端开发, 666, 233.33, S, ^_^]
 */

ArrayList对泛型的支持

泛型概述

ArrayList<E>：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种集合数据类型
集合只能存储引用类型，不支持基本数据类型，因此基本数据类型必须书写成其包装类的形式
- 举例：
  
  ArrayList<String>：此集合只能操作字符串类型的元素
  
  ArrayList<Integer>：此集合只能操作整数类型的元素

ArrayList<String> list = new ArrayList<String>();

// 从JDK1.7开始，泛型后面的类型申明可以不写
ArrayList<String> list = new ArrayList();

// 使用泛型来约束集合操作类型是良好的编码规范，即使是装载多类型的集合，也采用泛型实现，而不是不使用泛型

// 泛型-所有元素
ArrayList<Object> list = new ArrayList();

//不是用泛型-所有元素
ArrayList list = new ArrayList();

ArrayList常用API，遍历

方法名称	说明
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中元素的个数
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E set(int index, E element)	修改指定索引处的元素，返回被修改的元素

package com.java.test;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("Java");
        list.add("JavaWeb");
        list.add("JavaScript");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("JDBC");
        System.out.println(list);

        // 1. public  E  get(int  index)               | 返回指定索引处的元素
        System.out.println(list.get(2));

        // 2. public  int  size()                      | 返回集合中元素的个数
        System.out.println(list.size());

        // 集合遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


        // 3. public  E  remove(int  index)            | 删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(5));
        System.out.println(list);

        // 4. public  boolean  remove(Object  o)       | 删除指定的元素，返回删除是否成功
        // 当集合中存在相同的元素时，只会删除首次出现的元素
        System.out.println(list.remove("MySQL"));
        System.out.println(list);

        // 5. public  E  set(int  index,  E  element)  | 修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(0, "PHP")); // 返回的是指定索引的原来的元素
        System.out.println(list);

    }
}

ArrayList集合案例：

需求：某个班级的考试在系统上进行，成绩大致为：98，77，66，89，79，50，100；
现在需要先把成绩低于80分以下的数据去掉

ArrayList遍历并删除元素

package com.java.test;

import java.util.ArrayList;

public class ArrayListScore {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(98);
        list.add(77);
        list.add(66);
        list.add(89);
        list.add(79);
        list.add(50);
        list.add(100);

        // 集合正推出bug因为元素的索引随着删除元素而动态变化着，所以需要倒着循环
        /*                      <---- i
            [98, 77, 66, 89, 79, 50, 100]
            [98, 77, 66, 89, 79, 100]
            [98, 77, 66, 89, 100]
            [98, 77, 89, 100]
            [98, 89, 100]
            从后往前判断，删除元素时，长度-1，上一轮循环判断过的元素重新被判断
         */
        for (int i = list.size() - 1; i >= 0; i--) {
            if (list.get(i) < 80) {
                list.remove(i);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

对于从集合中遍历元素，并筛选出元素删除它，解决思路：

从集合后面遍历然后删除，可以避免漏掉元素

ArrayList存储自定义类型的对象

需求：某影院系统需要在后台存储三部电影，然后依次展示出来；

     三部电影就是三个对象，定义一个电影类，定义一个集合存储电影对象

     创建3个电影对象，封装相关数据，把3个对象存入到集合中去

package com.java.test;

import java.util.ArrayList;

public class ArrayListStore {
    public static void main(String[] args) {
        // 1. 定义一个电影类：Movie
        // 2. 定义一个ArrayList集合存储这些影片对象
        ArrayList<Movies> movies = new ArrayList<>();

        // 3. 创建影片对象封装电影数据，把对象加入到集合中去
        /*
        Movies m1 = new Movies("《2012》",8.7,"罗宾");
        movies.add(m1);
         */
        movies.add(new Movies("《肖申克的救赎》", 9.7, "罗宾"));
        movies.add(new Movies("《霸王别姬》", 6.6, "张国"));
        movies.add(new Movies("《美丽人生》", 9.8, "大卫"));

        // 4. 遍历集合中的影片对象并展示出来（集合装载对象，对象装载地址，直接打印集合只会得到地址）
        for (int i = 0; i < movies.size(); i++) {
            // movies.get(i)取得是每一个影片对象的地址，用一个影片类型的变量接收
            // 变量获得了地址，打印变量时会去访问这个地址   
            Movies movie = movies.get(i);
            System.out.println("片名：" + movie.getName());
            System.out.println("评分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }

    }
}

package com.java.test;

public class Movies {
    private String name;
    private double score;
    private String actor;

    public Movies() {
    }

    public Movies(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

ArrayList元素搜索

需求：后台程序需要存储学生信息并展示，然后要提供学号搜索学生信息的功能

package com.java.test;

public class Student {
    private String id;
    private String name;
    private int age;
    private String sex;

    public Student() {
    }

    public Student(String id, String name, int age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.java.test;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList();
        Student stu1 = new Student("0001", "王宝强", 30, "男");
        students.add(stu1);
        Student stu2 = new Student("0002", "陈羽凡", 31, "女");
        students.add(stu2);
        Student stu3 = new Student("0003", "贾乃亮", 32, "男");
        students.add(stu3);
        Student stu4 = new Student("0004", "谢霆锋", 33, "女");
        students.add(stu4);

        // 遍历已经存储进来的学生信息
        for (int i = 0; i < students.size(); i++) {
            Student stu = students.get(i);
            System.out.print("学号：" + stu.getId() + "\t");
            System.out.print("姓名：" + stu.getName() + "\t");
            System.out.print("年龄：" + stu.getAge() + "\t");
            System.out.print("性别：" + stu.getSex() + "\t");
            System.out.println();
        }
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("输入学号查询学生信息：");
            String Id = scanner.next();
            Student s = getStudentById(students, Id);
            //判断学号是否拥有地址，即是否存在
            if (s == null) {
                System.out.println("查无此人");
            } else {//返回的是对象，通过对象调用方法获得信息
                System.out.println("学号：" + s.getId());
                System.out.println("姓名：" + s.getName());
                System.out.println("年龄：" + s.getAge());
                System.out.println("性别：" + s.getSex());
            }
        }

    }

    public static Student getStudentById(ArrayList<Student> students, String strId) {
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if (s.getId().equals(strId)) {
                return s;
            }
        }
        return null;    // 查无此学号
    }
}

分析：
1. 定义Student类，定义ArrayList集合存储学生对象信息，并遍历出来
2. 提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息并展示
3. 使用死循环，让用户不停的搜索

11.常用API—ArrayList

ArrayList

集合概述

ArrayList集合快速入门

ArrayList对泛型的支持

泛型概述

ArrayList常用API，遍历

ArrayList集合案例：

ArrayList遍历并删除元素

ArrayList存储自定义类型的对象

ArrayList元素搜索

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读