ArrayList

------------恢复内容开始------------

ArrayList

集合概述

集合与数组类似,也是一种容器,用于装数据

  • 集合的大小不固定,启动后可以动态变化,类型也可以选择不固定
  • 集合非常适合做元素个数不确定,且要进行增删操作的业务场景。
  • 集合提供了许多丰富好用的功能,而数组的功能很单一。

总结

  1. 数组和集合元素存储的个数问题?
  • 数组定义后类型确定,长度确定
  • 集合类型可以不固定,大小是可变的。
  1. 数组和集合适合的场景
  • 数组适合做个数和类型确定的场景
  • 集合适合做数据个数不确定,且要做增删元素的场景

ArrayList集合

  • ArrayList是集合中的一种,它支持索引

ArrayList集合对象的获取

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

ArrayList集合添加元素的方法

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

import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        //1.创建ArrayList集合的对象
        ArrayList list = new ArrayList();

        //2.添加数据
        list.add("java");
        list.add("中国");
        list.add(123);
        list.add(12.12);
        list.add(false);
        System.out.println(list.add('中'));
        System.out.println(list);

        //3.给指定索引位置插入元素
        list.add(1,"陈太帅");
        System.out.println(list);

    }
}
output:
true
[java, 中国, 123, 12.12, false, 中]
[java, 陈太帅, 中国, 123, 12.12, false, 中]

   

小结

  1. ArrayList类如何创建集合对象的,如何添加元素:
  • ArrayList list = new ArrayList();
  • public boolean add(E e);
  • public void add (int index,E element);

泛型概述

  • ArrayList:其实就是一个泛型类,可以在编译阶段约束集合对象只能操作某种数据类型。

举例:

  • ArrayList: 此集合只能操作字符串类型的元素。
  • ArrayList: 此集合只能操作整数类型的元素。

注意:集合中只能存储引用类型,不支持基本数据类型

package com.arraylist;
import java.util.ArrayList;

public class ArrayListDemo02 {
    public static void main(String[] args) {
        //ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list = new ArrayList<>();//JDK1.7新特性,泛型后面类型声明可以不写
        list.add("hello");
        list.add("java");
//        list.add(33);
//        list.add('中');
    }
}

ArrayList集合常用方法

方法名称 说明
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.arraylist;

import java.util.ArrayList;

public class ArrayListDemo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("java");
        list.add("java");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("HTML");
        System.out.println(list);
        //1.public E get(int index):返回指定索引处的元素
        String s = list.get(3);
        System.out.println(s);

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

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

        //4.public E remove(int index):删除指定索引处的元素,返回被删除的元素
        String s1 = list.remove(2);
        System.out.println(s1);
        System.out.println(list);

        //5.public boolean remove(Object o):删除指定的元素,返回删除是否成功
        boolean flag = list.remove("java");
        System.out.println(flag);
        System.out.println(list);

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("java");
        list1.add("张三丰");
        list1.add("java");
        list1.add("mysql");
        System.out.println(list1);
        //只会删除第一个出现的元素值后面的不删除
        System.out.println(list1.remove("java"));
        System.out.println(list1);

        //6.public E set(int index,E element):修改指定索引处的元素,返回被修改的元素
        String s2 = list1.set(0, "李连杰");
        System.out.println(s2);
        System.out.println(list1);
    }
}
output:
[java, java, MySQL, MyBatis, HTML]
MyBatis
5
java
java
MySQL
MyBatis
HTML
MySQL
[java, java, MyBatis, HTML]
true
[java, MyBatis, HTML]
[java, 张三丰, java, mysql]
true
[张三丰, java, mysql]
张三丰
[李连杰, java, mysql]

案例一:遍历并删除元素

需求:

  • 某个班级的考试在系统上进行,成绩大致为:98,77,66,89,79,50,100
  • 现在需要把数据低于80分以下的删掉

分析:

  1. 定义ArrayList集合存储多名学生的成绩。
  2. 遍历集合的每个元素,如果元素值低于80,去掉它
package com.arraylist;

import java.util.ArrayList;

public class ArrayListDemo04 {
    public static void main(String[] args) {
        ArrayList<Integer> scores = new ArrayList<>();
        scores.add(98);
        scores.add(77);
        scores.add(66);
        scores.add(89);
        scores.add(79);
        scores.add(50);
        scores.add(100);
        //遍历集合中的每一个元素
       /* for (int i = 0; i < scores.size(); i++) {
            int score = scores.get(i);
            if (score < 80 ){
                scores.remove(i);
            }
        }
        System.out.println(scores);//[98, 66, 89, 50, 100]*/
        for (int i = scores.size()-1; i >=0 ; i--) {
            int score = scores.get(i);
            if (score<80){
                scores.remove(i);
            }
        }
        System.out.println(scores);//[98, 89, 100]边遍历边删除
    }
}

总结

  1. 从集合中遍历元素,并筛选元素删除它,应该怎么解决?
  • 从集合后面遍历然后删除,可以避免漏删元素。

案例二:存储自定义类型

需求:

  • 某影院系统需要在后台存储上述三部电影,然后依次展示出来

分析:

  1. 三部电影是3个对象,定义一个电影类,定义一个集合存储电影对象
  2. 创建3个电影对象,封装相关数据,把3个对象存入到集合中去。
package com.arraylist;

public class Movie {
    private String name;//电影名
    private double score;//电影评分
    private String actor;//演员

    public Movie() {
    }

    public Movie(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;
    }
}

package com.arraylist;

import java.util.ArrayList;

/*
    《肖申克的救赎》,9.7,罗宾斯
    《霸王别姬》,9.6,张国荣,张丰毅
    《阿甘正传》,9.5,汤姆.汉克斯
 */
public class ArrayListTest05 {
    public static void main(String[] args) {
        //1.定义一个电影类
        //2.定义一个ArrayList集合存储这些影片对象
        ArrayList<Movie> movies = new ArrayList<>();
        //创建影片对象封装数据,把对象加入到集合中去
//        Movie m1 = new Movie("《肖申克的救赎》",9.7,"罗宾斯");
//        movies.add(m1);
        movies.add(new Movie("《肖申克的救赎》", 9.7, "罗宾斯"));
        movies.add(new Movie("《霸王别姬》", 9.6, "张国荣,张丰毅"));
        movies.add(new Movie("《阿甘正传》", 9.5, "汤姆.汉克斯"));

        //4.遍历集合中的影片对象并展示出来
        for (int i = 0; i < movies.size(); i++) {
            Movie movie = movies.get(i);
            System.out.println("片名:"+movie.getName()+
                    "影评:"+movie.getScore()+
                    "主演:"+movie.getActor());
        }
    }
}
output:
片名:《肖申克的救赎》影评:9.7主演:罗宾斯
片名:《霸王别姬》影评:9.6主演:张国荣,张丰毅
片名:《阿甘正传》影评:9.5主演:汤姆.汉克斯

集合中存储元素并不是对象本身,而是对象的地址

案例三:元素搜索

学号 姓名 年龄 班级
20220106 张三 23 一班
20220107 李四 23 二班
20220108 王五 26 三班
20210109 赵六 26 4班

需求:

  • 后台程序需要储存以上信息并展示,然后要提供按照学号搜索学生信息的功能。

分析:

  1. 定义一个学生类,定义ArrayList集合存储以上学生信息,并遍历出来
  2. 提供一个方法,可以接受ArrayList集合,和要搜索的学号,返回搜索到的学生信息,并展示。
  3. 使用死循环,让用户可以不停的搜索。
package com.arraylist;

public class Student {
    private String studyId;
    private String name;
    private int age;
    private String className;

    public Student() {
    }

    public Student(String studyId, String name, int age, String className) {
        this.studyId = studyId;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getStudyId() {
        return studyId;
    }

    public void setStudyId(String studyId) {
        this.studyId = studyId;
    }

    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 getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

package com.arraylist;

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

public class ArrayListTest06 {
    public static void main(String[] args) {
        //1.定义一个学生类
        //2.定义一个集合对象用于装学生对象
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student("20210106","张三",23,"一班"));
        students.add(new Student("20210107","李四",23,"二班"));
        students.add(new Student("20210108","王五",26,"三班"));
        students.add(new Student("20210109","赵六",26,"四班"));
        System.out.println("学号\t\t\t姓名\t\t年龄\t\t班级");
        //3.遍历集合中的每一个元素
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            System.out.println(student.getStudyId()+"\t\t"+student.getName()+"\t\t"
                    +student.getAge()+"\t\t"+student.getClassName());
        }
        Scanner sc = new Scanner(System.in);
        //4.让用户不断的输入学号,可以搜索出该学生的对象信息并展示出来(独立成方法)
        while (true) {
            System.out.println("请输入要查询的学号:");
            String stuId = sc.next();
            Student s = getStudentByStudyId(students, stuId);
            if (s == null){
                System.out.println("学号不存在!");
            }else {
                System.out.println(s.getStudyId()+"\t\t"+s.getName()+"\t\t"
                        +s.getAge()+"\t\t"+s.getClassName());
            }
        }

    }

    /**
     * 根据学号,去集合中找到学生对象并返回
     * @param students
     * @param id
     * @return
     */
    public static Student getStudentByStudyId(ArrayList<Student> students,String id){
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if (s.getStudyId().equals(id)){
                return s;
            }
        }
        return null;//查无此学号
    }
}
output:
学号			姓名		年龄		班级
20210106		张三		23		一班
20210107		李四		23		二班
20210108		王五		26		三班
20210109		赵六		26		四班
请输入要查询的学号:
123
学号不存在
请输入要查询的学号:
20210106
20210106		张三		23		一班
请输入要查询的学号:
20210107
20210107		李四		23		二班
请输入要查询的学号:
20210108
20210108		王五		26		三班
请输入要查询的学号:

------------恢复内容结束------------

posted @ 2022-01-06 21:37  tryAgainCs  阅读(73)  评论(0编辑  收藏  举报