不做大哥好多年
xiaonaiqiang
2021-11-16
目录

06.ArrayList

# 01.ArrayList

  • ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

# 1、增删改查

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

public class Test{
    public static void main(String args[]){
        // 1、创建一个名为langs的ArrayList对象，该对象将存储字符串
        ArrayList<String> langs = new ArrayList<>(Arrays.asList("C", "C++"));

        // 2、添加元素
        langs.add("python");

        // 3、get获取元素
        System.out.println( langs.get(0) );  // C

        // 4、set设置元素
        langs.set(0, "golang");

        // 5、删除
        langs.remove(1);
        // langs.clear();          // 删除所有元素

        // 6、获取元素个数
        System.out.println( langs.size() );

        // 7、添加多个元素
        langs.addAll(Arrays.asList("java2", "java3"));
        System.out.println(langs); //[golang, python, java2, java3]
    }
}
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

# 2、for遍历

package com.example01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test {
    public static void main(String[] strings) {
        ArrayList<String> langs = new ArrayList<>(Arrays.asList("java", "python"));

        // 方法1：普通遍历
        for (int i = 0; i < langs.size(); i++) {
            System.out.println(langs.get(i));
        }

        // 方法2：for-each循环遍历
        for (String i : langs) {
            System.out.println(i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 3、排序

java.util包中另一个有用的类是Collections类，该类包括用于对列表进行字母或数字排序的sort()方法

  • 1）对字符串的ArrayList进行排序
package com.example01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test {
    public static void main(String[] strings) {
        ArrayList<String> langs = new ArrayList<>(Arrays.asList("02java", "01python"));
        Collections.sort(langs);
        System.out.println(langs); // [01python, 02java]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 02.常用方法

# 1、addAll()

package com.example01;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3));
        ArrayList<Integer> num2 = new ArrayList<>(Arrays.asList(4,5));
        num1.addAll(num2);
        System.out.println(num1);  // [1, 2, 3, 4, 5]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 2、contains()

  • contains() 方法用于判断元素是否在动态数组中。
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> primeNumbers = new ArrayList<>(Arrays.asList(3, 5));
        System.out.println( primeNumbers.contains(5) );  // true
    }
}
1
2
3
4
5
6
7
8
9
10

# 3、removeAll()

  • removeAll() 方法用于删除存在于指定集合中的动态数组元素。

  • 返回值

    • 如果从动态数组成功删除元素返回 true

    • 如果动态数组中存在的元素类与指定 collection 的元素类不兼容，则抛出 ClassCastException 异常

    • 如果动态数组中包含 null 元素，并且指定 collection 不允许 null 元素，则抛出 NullPointerException 异常

package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<String> sites = new ArrayList<>(Arrays.asList("zs", "ls", "ww"));
        sites.removeAll(Arrays.asList("zs", "ls"));
        System.out.println(sites);  // [ww]
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 4、isEmpty()

  • isEmpty() 方法用于判断动态数组是否为空。
import java.util.ArrayList;

public class Test{
    public static void main(String args[]){
        ArrayList<String> sites = new ArrayList<>();
        boolean result = sites.isEmpty();  // true
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9

# 5、subList()

  • subList() 方法用于截取并返回动态数组中的一部分。
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> sites = new ArrayList<>(Arrays.asList(1,2,3,4));
        // 元素位置为1到3
        System.out.println(sites.subList(1, 3));  // [2, 3]
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 6、toArray()

  • toArray() 方法将Arraylist对象转换为数组
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>(Arrays.asList("bj", "sh"));

        // 创建一个新的 String 类型的数组，数组长度和 ArrayList 长度一样
        String[] arr = new String[sites.size()];

        // 将ArrayList对象转换成数组
        sites.toArray(arr);
        System.out.print(sites);  // [Runoob, Google]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 7、toString()

  • toString() 方法将 Arraylist 对象转换为字符串
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<String> sites = new ArrayList<>(Arrays.asList("bj", "sh"));
        // 转换为 string 类型
        String s = sites.toString();
        System.out.print(s);  // [Runoob, Google]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

# 8、containsAll()

  • containsAll() 方法用于检测 arraylist 是否包含指定集合中的所有元素。
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3,4));
        ArrayList<Integer> num2 = new ArrayList<>(Arrays.asList(1,2));
        System.out.println(num1.containsAll(num2));  // true
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 9、removeRange()

  • removeRange() 方法用于删除指定索引之间存在的元素
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3,4));
        num1.subList(1,3).clear();
        System.out.println(num1);  // [1, 4]
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 10、replaceAll()

  • replaceAll() 方法用于将给定的操作内容替换掉数组中每一个元素。
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3,4));
        num1.replaceAll(i -> i*10);
        System.out.println(num1);  // [10, 20, 30, 40]
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 11、removeIf()

  • removeIf() 方法用于删除所有满足特定条件的数组元素。
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3,4));
        num1.removeIf( e -> (e <= 2) );
        System.out.println(num1);  // [3, 4]
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 12、forEach()

  • forEach() 方法用于遍历动态数组中每一个元素并执行特定操作
package com.example01;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> num1 = new ArrayList<>(Arrays.asList(1,2,3,4));
        num1.forEach((e) -> {
            e = e * 10;
            System.out.println(e); // 10 20 30 40
        });
        System.out.println(num1); // [1, 2, 3, 4]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 03.List

# 1、List 优势

  • 有一种情况你可能需要直接使用ArrayList，那就是当你需要使用ArrayList特有的一些方法时
  • 例如trimToSize()或ensureCapacity()，这些方法在List接口中是没有的

  • 在大多数情况下，我们会选择使用List接口而不是直接使用ArrayList，因为这样可以提高代码的灵活性和可维护性

  • 具体地说，如果你声明一个变量为List类型，你可以轻易地改变它的实现，而不需要改变整个代码

  • 你可能开始时使用ArrayList，但随着需求的变化，可能需要改为LinkedList或者其他的实现

  • 只需要改变初始化的部分，不需要改变其他使用这个变量的代码

package com.example01;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {
    public static void main(String[] strings) {
        // 如果你发现LinkedList比ArrayList更适合你的需要，你只需要改变第一行代码
        // List<String> list = new LinkedList<>();
        List<String> list = new ArrayList<>(Arrays.asList("zs", "ls"));
        System.out.println(list.get(0));  // zs
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

  • 相反，如果你直接使用ArrayList，那么当你需要改变实现时，可能需要改变代码的很多部分

  • 此外，使用List可以让你的代码更易于理解和维护

  • 因为List是一个接口，它定义了你可以对一个集合执行的操作，而不关心这个集合是如何实现的

  • 当其他人阅读你的代码时，他们可以立即理解你的意图，而不需要知道你使用了哪个具体的类

# 2、List 方法

package com.example01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] strings) {
        // 0、创建一个新的ArrayList
        List<String> list = new ArrayList<>();

        // 1、使用add方法添加元素
        list.add("bj");
        // 1.1 add 多个元素
        Collections.addAll(list,"sh", "gz");
        // 1.2 add 一个 list
        List<String> list2 = new ArrayList<>(Arrays.asList("sz", "hz"));
        list.addAll(list2);
        System.out.println("最终数据" + list);

        // 2、使用size方法获取列表的大小
        System.out.println(list.size()); //3

        // 3、使用get方法获取特定位置的元素
        System.out.println(list.get(1)); //sh

        // 4、使用set方法设置特定位置的元素
        list.set(1, "zz");
        System.out.println(list);
        System.out.println(list.get(0)); //bj

        // 5、使用indexOf方法获取元素的索引
        System.out.println(list.indexOf("gz")); //2

        // 6、使用contains方法检查列表是否包含某个元素
        System.out.println(list.contains("gz")); //true

        // 7、使用remove方法删除特定位置的元素
        list.remove(0);
        System.out.println(list); //[zz, gz, sz, hz]

        // 8、使用clear方法清空列表
        list.clear();
        System.out.println(list); //[]
    }
}
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
上次更新: 2024/5/31 11:18:42
05.数组
07.LinkedList

← 07.LinkedList→

最近更新
01
04.数组双指针排序_子数组
03-25
02
08.动态规划
03-25
03
06.回溯算法
03-25
更多文章>
Theme by Vdoing | Copyright © 2019-2025 逍遥子 技术博客 京ICP备2021005373号