文章目录
- 集合介绍
- Collection相关方法
- List 相关方法
- LinkedList 特色方法
- LinkedList 介绍
- 举例：LinkedList 基本使用
- 举例：求第n个丑数
- 举例：求第n个丑数进阶版（高效率）
集合介绍
简介
Java 集合类存放在 java.util 包中，是一个用来存放对象的容器，是用来收集一组数据的数据结构。
集合和数组区别
1、数组长度固定，添加数据只能新建数组；而集合类容量可动态改变。
2、数组能存放基本数据类型和对象；而集合类存放的都是对象，比如你存入一个 int 型数据 2 放入集合中，其实它是自动转换成 Integer 类后存入的，Java 中每一种基本数据类型都有对应的引用类型。（数组和集合存放的对象皆为对象的引用地址。）
3、数组无法判断其中实际存有多少元素，length 只告诉了数组的容量；而集合的 size() 可以确切知道元素的个数。
集合分类
Java 集合类型分为 Collection 和 Map。它们是 Java 集合的根接口，这两个接口又包含了一些子接口或实现类。关系如下：
java.util包
Collection相关方法
这些方法属于Collection类，可以被子类继承，因此通用性较强，不仅 List 能用，Set也能用。
返回类型 | 方法名称 | 描述 |
boolean | add(Object o) | 添加元素 |
int | size() | 获取元素个数 |
boolean | contains(Object o) | 判断是否存在指定元素 |
boolean | remove(Object o) | 删除元素 |
void | clear() | 清空 |
boolean | isEmpty() | 判空 |
Object[] | toArray() | 集合转数组 |
List 相关方法
List的派生类对象可以使用，Set不可用。都是和索引相关的方法：
返回类型 | 方法名称 | 描述 |
void | add(int index, E element) | 指定位置添加元素 |
int | indexOf(Object o) | 获取指定元素的索引 |
E | set(int index, E element) | 替换指定位置的元素，返回更新前的元素 |
E | get(int index) | 获取指定索引的元素 |
E | remove(int index) | 删除指定索引的元素 |
LinkedList 特色方法
特色方法 | 解释 |
addFirst() | 头部添加 |
addLast() | 尾部添加 |
removeFirst() | 头部删除 |
removeLast() | 尾部删除 |
push() | 入栈，等效于addFirst() |
pop() | 出栈，等效于removeFirst() |
offer() | 入队列，等效于addLast() |
poll() | 出队列，等效于removeFirst() |
LinkedList 介绍
LinkedList 是采用双向循环链表实现的。数据封装在节点对象内部，前后两个节点，前一个引用前一个对象，后一个引用后一个对象。如果只有一个数据，那么引用自己。
ArrayList 使用数组实现，查询快，增删慢；
LinkedList 使用链表实现，查询慢，增删快。访问中间效率低，访问两端效率高，越往中间效率越低。
创建对象
LinkedList list = new LinkedList();
举例：LinkedList 基本使用
/*
*<>-泛型
* 指定集合中允许存放的数据类型
* 不支持基本类型
* 可以使用基本类型的包装类
*
* 后边的泛型可以省略，默认和前面一样
*/
LinkedList<String> list = new LinkedList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
list.add("ee");
list.add("ff");
System.out.println(list.size());//6
System.out.println(list);//[aa, bb, cc, dd, ee, ff]
list.add(3, "33");
System.out.println(list);//[aa, bb, cc, 33, dd, ee, ff]
list.addFirst("FFF");
list.addLast("LLL");
System.out.println(list);//[FFF, aa, bb, cc, 33, dd, ee, ff, LLL]
System.out.println(list.getFirst());//FFF
System.out.println(list.getLast());//LLL
//返回被移除的数据
System.out.println(list.removeFirst());//FFF
System.out.println(list.removeLast());//LLL
System.out.println(list);//[aa, bb, cc, 33, dd, ee, ff]
System.out.println(list.get(0));//aa
System.out.println(list.get(list.size() - 1));//ff
//返回被移除的数据
System.out.println(list.remove(5));//ee
System.out.println(list);//[aa, bb, cc, 33, dd, ff]
//指定数据移除，如果找到这个数据，移除它返回true;如果没找到这个数据，返回false
//找到第一个相同的数据移除，后面的不被移除
System.out.println(list.remove("ccc"));//false
//返回被替换的值
System.out.println(list.set(4, "444"));
System.out.println(list);//[aa, bb, cc, 33, 444, ff]
//下标遍历，效率并不高，需要从0开始数
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
前边的输出结果放到程序注释里了，最后的遍历结果：
aa
bb
cc
33
444
ff
双向链表下标遍历效率低，每次访问一个下标的值，都要从头遍历，而 Iterator（迭代器）能更高效的遍历
改用迭代器遍历
//迭代器遍历
//对于双向链表，迭代器遍历效率高
//新建迭代器，通过 list 的 iterator 新建迭代器，iterator() 实际上就是 return new Iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
举例：求第n个丑数
丑数就是只包含因子2，3，5的数（Ugly Number)，习惯上我们把 1 当做是第一个丑数
判断方法：首先除 2，直到不能整除为止，然后除 5 到不能整除为止，然后除 3 直到不能整除为止。最终判断剩余的数字是否为 1，如果是 1 则为丑数，否则不是丑数。
public class Main {
public static void main(String[] args) throws ParseException {
System.out.println("求第n个丑数");
int n = new Scanner(System.in).nextInt();
long r = f(n);
System.out.println(r);
}
private static long f(int n) {
//计数变量
int count = 0;
//保存结果变量
long r = 0;
//无限循环从1开始递增
for (int i = 1; ; i++) {
//判断i是不是丑数
//新的变量保存i的值
int j = i;
while (j % 2 == 0) {
j /= 2;
}
while (j % 3 == 0) {
j /= 3;
}
while (j % 5 == 0) {
j /= 5;
}
if (j == 1) {
//i是整数
count++;
if (count == n) {
r = i;
break;
}
}
}
return r;
}
}
运行结果
举例：求第n个丑数进阶版（高效率）
想办法从上一个丑数推断出下一个丑数，而不需要从 1 开始遍历再判断。
从 1 开始的10个丑数分别为1，2，3，4，5，6，8，9，10，12。可以发现除了 1 以外，丑数都是由 某个丑数2 或者 3 或者 5 得到的。如2是丑数 12 得到的，3 是丑数 13 得到的，4 是丑数 14 得到的，5 是丑数 15 得到的，6 是丑数 23 得到的……
所以我们思路如下：
1、准备3个集合，先分别放入2、3、5
2
3
5
2、把最小值取出来（2），分别乘 2、3、5，分别放入3个集合。最后移除最小值。
4
3、6
5、10
第一次的丑数我们得到了就是最小值2
3、重复以上步骤，取出最小值（3），分别乘 2、3、5，分别放入 3 个集合。移除最小值。
4、6、
6、9、
5、10、15、
此时我们得到了丑数：2 3
再来一次，取出最小值（4），分别乘 2、3、5，分别放入3个集合。移除最小值。
6、8、
6、9、12、
5、10、15、20、
此时我们得到了丑数：2 3 4
4、重复以上步骤
有重复的最小值都要取出
5、第一次执行得到第1个丑数，第二次执行得到第2个…第n次执行得到第n个丑数
这里我们没有包含默认的 1 为丑数，这里我们把 2 当作了第一个丑数。
直接看程序：
public class Main {
public static void main(String[] args) throws ParseException {
System.out.println("求第n个丑数");
int n = new Scanner(System.in).nextInt();
long r = f(n);
System.out.println(r);
}
private static long f(int n) {
//创建3个集合
LinkedList<Long> list2 = new LinkedList();
LinkedList<Long> list3 = new LinkedList();
LinkedList<Long> list5 = new LinkedList();
//初始值分别放入2、3、5
list2.add(2L);
list3.add(3L);
list5.add(5L);
//保存结果
long r = 0;
for (int i = 1; i <= n; i++) {
//访问3个头部值
long a = list2.getFirst();
long b = list3.getFirst();
long c = list5.getFirst();
//最小值赋给r
r = Math.min(a, Math.min(b, c));
//移除最小值
if (r == a) {
list2.removeFirst();
}
if (r == b) {
list3.removeFirst();
}
if (r == c) {
list5.removeFirst();
}
//r分别乘2、3、5放入三个集合
list2.add(r * 2);
list3.add(r * 3);
list5.add(r * 5);
}
return r;
}
}
运行程序可以看到速度是非常快的：
