1 ArrayList类

1.1 ArrayList类概述

数组的长度是固定的，无法适应数据变化的需求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对象数据。

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList 中可不断添加元素，其大小也自动增长。

对于ArrayList来说，有一个尖括号<E>代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。

注意：

• 泛型只能是引用类型（类、接口、数组、字符串），不能是基本类型
• 直接打印对象 / 数组名，输出的是对象 / 数组的地址值，而对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号：[]

1.2 创建ArrayList对象

// 格式
ArrayList<String> list = new ArrayList<>();
1
2

注意：

• 从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是 <> 本身还是要写的。
• 参数E e，在构造ArrayList对象时， <E> 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据类型的对象。
• 查看构造方法 public ArrayList() ：构造一个内容为空的集合。

1.3 ArrayList对象常用操作

（1）public boolean add(E e) ：将指定的元素添加到此集合的尾部，返回值代表添加的动作是否成功
（2）public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
（3）public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
（4）public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
（5）遍历集合

 public static void main(String[] args) {
 		// ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list = new ArrayList<>();
        list.add("迪丽热巴");// 注意添加内容必须是字符串
        list.add("古力娜扎");
        list.add("玛尔扎哈");
        System.out.println(list); // [迪丽热巴, 古力娜扎, 玛尔扎哈]
		
        // 遍历集合
        for (int i = 0; i < list.size(); i++) { //list.fori+回车——>自动生成代码
            System.out.println(list.get(i));
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

注意：

• 对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集合来说，add添加动作不一定成功
• 字符串.length()，数组名.length，ArrayList集合名.size()

1.4 ArrayList存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 <int> 不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据，<> 中的数据类型，必须转换后才能编写，转换写法如下：

注意：

• 我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可
• 从JDK 1.5+开始，支持自动装箱、自动拆箱。
  – 自动装箱：基本类型 --> 包装类型
  – 自动拆箱：包装类型 --> 基本类型

1.5 ArrayList案例

（1）数值添加到集合

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

public static void main(String[] args) {
	ArrayList<Integer> list = new ArrayList<>();
	Random r = new Random();
	for (int i = 0; i < 6; i++) {
		int num = r.nextInt(33) + 1;
		list.add(num);
	}
	// 遍历集合
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

（2）对象添加到集合

需求：自定义4个学生对象，添加到集合，并遍历。

public static void main(String[] args) {
	ArrayList<Student> list = new ArrayList<>();

	Student one = new Student("洪七公", 20);
	Student two = new Student("欧阳锋", 21);
	Student three = new Student("黄药师", 22);
	Student four = new Student("段智兴", 23);

	list.add(one);
	list.add(two);
	list.add(three);
	list.add(four);

	// 遍历集合
	for (int i = 0; i < list.size(); i++) {
		Student stu = list.get(i);
		System.out.println("姓名：" + stu.getName() + "，年龄" + stu.getAge());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（3）获取集合方法
需求：用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。要求使用自定义的方法来实现筛选。

public static void main(String[] args) {
	ArrayList<Integer> bigList = new ArrayList<>();
	Random r = new Random();
	for (int i = 0; i < 20; i++) {
		int num = r.nextInt(100) + 1; // 1~100
		bigList.add(num);
	}

	ArrayList<Integer> smallList = getSmallList(bigList);

	System.out.println("偶数总共有多少个：" + smallList.size());
	for (int i = 0; i < smallList.size(); i++) {
		System.out.println(smallList.get(i));
	}
}

// 这个方法，接收大集合参数，返回小集合结果
public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
	// 创建一个小集合，用来装偶数结果
	ArrayList<Integer> smallList = new ArrayList<>();
	for (int i = 0; i < bigList.size(); i++) {
		int num = bigList.get(i);
		if (num % 2 == 0) {
			smallList.add(num);
		}
	}
	return smallList;
}
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

2 Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来 非常简单。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序

public static void main(String[] args) {
    int[] intArray = {10, 20, 30};
    // 将int[]数组按照默认格式变成字符串
    String intStr = Arrays.toString(intArray);
    System.out.println(intStr); // [10, 20, 30]

    int[] array1 = {2, 1, 3, 10, 6};
    Arrays.sort(array1);
    System.out.println(array1); // [I@1b6d3586
    System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

    String[] array2 = {"bbb", "aaa", "ccc"};
    Arrays.sort(array2);
    System.out.println(array2); // [Ljava.lang.String;@4554617c
    System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意：

• 如果是数值，sort默认按照升序从小到大
• 如果是字符串，sort默认按照字母升序
• 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

案例：倒序打印字符串
需求：请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public static void main(String[] args) {
	String str = "asv76agfjh";

	// 如何进行升序排列：sort
	// 必须是一个数组，才能用Arrays.sort方法
	// String --> 数组，用toCharArray
	char[] chars = str.toCharArray();
	Arrays.sort(chars); // 对字符数组进行升序排列

	// 需要倒序遍历
	for (int i = chars.length - 1; i >= 0; i--) {
		System.out.print(chars[i]+" "); // v s j h g f a a 7 6
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3 Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单

public static double abs(double a) ：返回 double 值的绝对值
public static double ceil(double a) ：返回大于等于参数的最小的整数
public static double floor(double a) ：返回小于等于参数最大的整数
public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
Math.PI代表近似的圆周率常量（double）

public static void main(String[] args) {
	// 获取绝对值
	System.out.println(Math.abs(3.14)); // 3.14
	System.out.println(Math.abs(0)); // 0
	System.out.println(Math.abs(-2.5)); // 2.5
	System.out.println("================");

	// 向上取整
	System.out.println(Math.ceil(3.9)); // 4.0
	System.out.println(Math.ceil(3.1)); // 4.0
	System.out.println(Math.ceil(3.0)); // 3.0
	System.out.println("================");

	// 向下取整，抹零
	System.out.println(Math.floor(30.1)); // 30.0
	System.out.println(Math.floor(30.9)); // 30.0
	System.out.println(Math.floor(31.0)); // 31.0
	System.out.println("================");

	System.out.println(Math.round(20.4)); // 20
	System.out.println(Math.round(10.5)); // 11
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22