Ming-Log's Blog

记录生活中的点点滴滴

0%

Java(7)ArrayList集合类

发表于 更新于 分类于
本文字数： 7.4k 阅读时长 ≈ 7 分钟

ArrayList 集合类

Person类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.tipdm.demo03;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

调用Person类，并在数组中存储

数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.tipdm.demo03;

/**
 * 题目：
 * 定义一个数组，用来存储3个Person对象。
 *
 * 数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变。
 */
public class demo1 {
    public static void main(String[] args) {
        Person[] array = new Person[3];

        Person one = new Person("迪丽热巴", 18);
        Person two = new Person("赵丽颖", 19);
        Person three = new Person("杨幂", 20);

        array[0] = one;  // 将one当中的地址值复制到数组的0号元素位置
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        System.out.println(array[1].getName());
    }
}
1
2
3
4
5
6
com.tipdm.demo03.Person@1b6d3586
com.tipdm.demo03.Person@4554617c
com.tipdm.demo03.Person@74a14482
赵丽颖

进程已结束,退出代码0

数组的长度不可以发生改变，并且直接打印得到的是地址值。

但是ArrayList集合的长度是可以随意变化的

对于ArrayList来说，有一个尖括号<E>代表泛型。

泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。

**注意：泛型只能是引用类型，不能是基本类型。** 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class demo2 {
    public static void main(String[] args) {
        // 创建了一个ArrayList集合，集合名称是list，里面装的全都是String字符串类型的数据
        // 备注：从JDK 1.7+ 开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);  // []

        // 向集合当中添加一些数据，需要用到add方法。
        list.add("赵丽颖");
        System.out.println(list);
        list.add("迪丽热巴");
        System.out.println(list);
        list.add("古力娜扎");
        System.out.println(list);
    }
}
1
2
3
4
5
6
[]
[赵丽颖]
[赵丽颖, 迪丽热巴]
[赵丽颖, 迪丽热巴, 古力娜扎]

进程已结束,退出代码0

注意事项：

  • 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
  • 如果内容是空，得到的是空的中括号:[]

ArrayList常用方法

  • public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致。

备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。

但是对于其他集合（今后学习）来说，add添加动作不一定成功。

  • public E get(int index):从集合中获取元素，参数是索引编号，返回值就是对应位置的元素。

  • public E remove(int index):从集合中删除元素，参数是索引编号，返回值就是被删掉的元素。

  • public int size(): 获取集合的尺寸长度，返回值是集合中包含的元素个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);  // 刚刚创建好后是空的[]

        // 向集合中添加元素: add
        boolean success = list.add("赵丽颖");
        System.out.println(list);
        System.out.println("添加是否成功：" + success);

        list.add("高圆圆");
        list.add("赵又廷");
        list.add("彭于晏");
        list.add("李小龙");
        System.out.println(list);

        // 获取元素
        System.out.println(list.get(4));

        // 删除元素
        String whoRemoved = list.remove(2);
        System.out.println("被删除的人是:" + whoRemoved);
        System.out.println(list);

        // 查看集合长度
        System.out.println(list.size());
    }
}
1
2
3
4
5
6
7
8
9
10
[]
[赵丽颖]
添加是否成功：true
[赵丽颖, 高圆圆, 赵又廷, 彭于晏, 李小龙]
李小龙
被删除的人是:赵又廷
[赵丽颖, 高圆圆, 彭于晏, 李小龙]
4

进程已结束,退出代码0

遍历集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tipdm.demo03;

import java.util.ArrayList;

/**
 * 遍历数组
 */
public class demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("高圆圆");
        list.add("赵又廷");
        list.add("彭于晏");
        list.add("李小龙");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
1
2
3
4
5
6
高圆圆
赵又廷
彭于晏
李小龙

进程已结束,退出代码0

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的”包装类”

基本类型 包装类
byte Byte
short Short
int Integer【特殊】
long Long
float Float
double Double
char Character【特殊】
boolean Boolean 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class demo5 {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        // 错误写法！ 泛型只能是引用类型，不能是基本类型
//        ArrayList<int> listB = new ArrayList<>();
        ArrayList<Integer> listB = new ArrayList<>();
        listB.add(10);
        listB.add(100);
        listB.add(1000);
        System.out.println(listB);

        int num = listB.get(2);
        System.out.println(num);
    }
}
1
2
3
4
[10, 100, 1000]
1000

进程已结束,退出代码0

题目：生成6个1~33之间的随机整数，添加到集合，并遍历集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.tipdm.demo03;

import java.util.ArrayList;
import java.util.Random;

/**
 * 题目：
 * 生成6个1~33之间的随机整数，添加到集合，并遍历集合
 */
public class demo6 {
    public static void main(String[] args) {
        Random ran = new Random();
        ArrayList<Integer> listInt = new ArrayList<>();
        for (int i = 0; i < 6; i++) {
            listInt.add(ran.nextInt(33) + 1);
        }
        for (int i = 0; i < listInt.size(); i++) {
            System.out.println(listInt.get(i));
        }
    }
}
1
2
3
4
5
6
7
8
29
29
22
2
6
23

进程已结束,退出代码0

题目：自定义4个学生对象，添加到集合，并遍历

学生类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.tipdm.demo03;

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

    public Student() {
    }

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

    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;
    }
}

调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.tipdm.demo03;

import java.util.ArrayList;

/**
 * 题目：
 * 自定义4个学生对象，添加到集合，并遍历
 */
public class demo7 {
    public static void main(String[] args) {
        Student stu1 = new Student("赵丽颖", 18);
        Student stu2 = new Student("杨幂", 19);
        Student stu3 = new Student("古力娜扎", 20);
        Student stu4 = new Student("蒙娜丽莎", 60);
        ArrayList<Student> listStu = new ArrayList<>();
        listStu.add(stu1);
        listStu.add(stu2);
        listStu.add(stu3);
        listStu.add(stu4);
        for (int i = 0; i < listStu.size(); i++) {
            System.out.println(listStu.get(i).getName());
        }
    }
}
1
2
3
4
5
6
赵丽颖
杨幂
古力娜扎
蒙娜丽莎

进程已结束,退出代码0

题目：定义以指定格式打印集合的方法

1
2
(ArrayList类型作为参数), 使用{}括起来，使用@分隔每个元素。
格式按照{元素@元素@元素}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.tipdm.demo03;

import java.util.ArrayList;

/**
 * 定义以指定格式打印集合的方法(ArrayList类型作为参数), 使用{}括起来，使用@分隔每个元素。
 * 格式按照{元素@元素@元素}
 */
public class demo8 {
    public static void main(String[] args) {
        ArrayList<String> listStr = new ArrayList<>();
        listStr.add("赵丽颖");
        listStr.add("杨幂");
        listStr.add("古力娜扎");
        listStr.add("张三丰");
        printList(listStr);
    }

    public static void printList(ArrayList<String> listStr){
        System.out.print("{");
        for (int i = 0; i < listStr.size(); i++) {
            System.out.print(listStr.get(i));
            if(i != listStr.size() - 1){
                System.out.print("@");
            }
        }
        System.out.print("}");
    }
}
1
2
{赵丽颖@杨幂@古力娜扎@张三丰}
进程已结束,退出代码0

题目：用一个大集合存入20个随机数，然后筛选其中的偶数元素，放到小集合当中。

要求使用自定义的方法来实现筛选。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.tipdm.demo03;

import java.util.ArrayList;
import java.util.Random;

/**
 * 题目：
 * 用一个大集合存入20个随机数，然后筛选其中的偶数元素，放到小集合当中。
 * 要求使用自定义的方法来实现筛选。
 */
public class demo9 {
    public static void main(String[] args) {
        Random ran = new Random();
        ArrayList<Integer> listInt = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            listInt.add(ran.nextInt(100));
        }
        System.out.println("大集合:" + listInt);
        ArrayList<Integer> listSmall = getEven(listInt);
        System.out.println("总共有" + listSmall.size() + "个偶数!");
        System.out.println("小集合:" + listSmall);
    }

    public static ArrayList<Integer> getEven(ArrayList<Integer> listBig){
        ArrayList<Integer> listSmall = new ArrayList<>();
        for (int i = 0; i < listBig.size(); i++) {
            if (listBig.get(i) % 2 == 0){
                listSmall.add(listBig.get(i));
            }
        }
        return listSmall;
    }
}
1
2
3
4
5
大集合:[30, 38, 76, 98, 33, 46, 69, 98, 27, 72, 82, 78, 59, 72, 14, 95, 66, 86, 0, 23]
总共有14个偶数!
小集合:[30, 38, 76, 98, 46, 98, 72, 82, 78, 72, 14, 66, 86, 0]

进程已结束,退出代码0
-------------本文结束感谢您的阅读-------------