博客介绍了Java集合相关知识。Java提供集合类保存数据，位于java.util包下，主要由Collection和Map派生。还介绍了List集合，其元素有序、可重复。此外，讲解了Comparable和Comparator两个排序相关接口，前者使类支持排序，后者可用于控制未实现排序的类的次序。
1、Java集合概述
为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类，所有的集合类都位于 java.util包下。
集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量）；而集合里只能保存对象（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。
Java的集合类主要由两个接口派生而出： Collection和Map， Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。如下所示是 Java集合简单结构图
2、List集合
List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。Lst集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引，例如第一次添加的元素索引为0，第二次添加的元素索引为1…
List常用方法2019-04-09 08:24:08 星期二
返回值 方法(形参) 说明
boolean add(E e) 向列表的尾部添加指定的元素。
void add(int index, E element) 在列表的指定位置插入指定元素。
boolean addAll(Collection c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean addAll(int index, Collection c) 将指定 collection 中的所有元素都插入到列表中的指定位置。
void clear() 从列表中移除所有元素。
boolean contains(Object o) 如果列表包含指定的元素，则返回 true。
boolean containsAll(Collection c) 如果列表包含指定 collection 的所有元素，则返回 true。
boolean equals(Object o) 比较指定的对象与列表是否相等。
E get(int index) 返回列表中指定位置的元素。
int hashCode() 返回列表的哈希码值。
int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean isEmpty() 如果列表不包含元素，则返回 true。
Iterator iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
示例代码（以ArrayList为例）：
1. import java.util.ArrayList;
2. import java.util.Iterator;
3. import java.util.List;
4. /**
5. * list是有序且允许元素重复,允许元素为null
6. * @author sxj
7. *
8. */
9. public class ListDemo {
10. public static void main(String[] args) {
11. List<String> list = new ArrayList<>();
12.
13. // 添加元素
14. list.add("A");
15. list.add("B");
16. list.add("C");
17. list.add("D");
18. list.add("E");
19. list.add("A");//允许元素重复
20.
21. list.add("F");
22. list.add("G");
23. list.add(null);//允许元素为null
24. list.add(null);
25.
26. // 移除
27. list.remove(1);// 通过索引移除
28. list.remove("D");// 通过对象移除
29.
30. List<String> listRemove = new ArrayList<>();
31. listRemove.add("E");
32. listRemove.add("F");
33. listRemove.add("K");
34. list.removeAll(listRemove);// 移除多个
35.
36. // 输出list
37. // 调试使用或者转字符串
38. System.out.println(list);
39. // 遍历
40. System.out.println("for循环遍历");
41. // 获取list的元素个数list.size()
42. for (int i = 0; i < list.size(); i++) {
43. // 获取list中某个元素 list.get(index)
44. System.out.print(list.get(i) + "\t");
45. }
46. System.out.println("\nforeach 循环：");
47. for (String string : list) {
48. System.out.print(string + "\t");
49. }
50. // Iterator迭代器
51. System.out.println("\nIterator 迭代器 while 遍历：");
52. Iterator<String> iterator = list.iterator();
53. while (iterator.hasNext()) {// iterator.hasNext()判断是否有下一个元素
54. System.out.print(iterator.next() + "\t");// iterator.next()获取下一个元素
55. }
56. System.out.println("\nIterator 迭代器 for 遍历：");
57. for (Iterator<String> iterator2 = list.iterator(); iterator2.hasNext();) {
58. String string = iterator2.next();
59. System.out.print(string + "\t");
60. }
61.
62. System.out.println();
63. // 返回对象o在List集合中第一次出现的位置索引。
64. System.out.println("A元素第一次出现的位置：" + list.indexOf("A"));
65. // 返回对象o在List集合中最后一次出现的位置索引。
66. System.out.println("A元素最后一次出现的位置：" + list.lastIndexOf("A"));
67. // 返回对象o在List集合中是否存在该元素
68. System.out.println("List集合中是否存在元素：" + list.contains("A"));
69.
70. // 替换元素
71. list.set(1, "D");
72. System.out.println(list);
73.
74. //返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图 [fromIndex,toIndex)
75. List<String> sList = list.subList(1, 2);
76. System.out.println(sList);
77.
78. // 判断集合是否为空
79. System.out.println("List集合否为空：" + list.isEmpty());
80. // 清空集合
81. list.clear();
82. System.out.println("List集合否为空：" + list.isEmpty());
83. }
84. }
3、Comparable和Comparator
一、Comparable简介
Comparable是排序接口。若一个类实现了Comparable接口，就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。
此外，实现此接口的对象可以用作有序映射中的键或有序集合中的集合，无需指定比较器。
此接口只有一个方法compare，比较此对象与指定对象的顺序，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
示例代码：
1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.Iterator;
4. import java.util.List;
5.
6. //Comparable 排序接口 是在类的内部实现
7. public class ListComparable {
8. public static void main(String[] args) {
9. List<PersonComparable> persons = new ArrayList<PersonComparable>();
10.
11. persons.add(new PersonComparable("小A", 35));
12. persons.add(new PersonComparable("小B", 25));
13. persons.add(new PersonComparable("小C", 25));
14. persons.add(new PersonComparable("小D", 12));
15. persons.add(new PersonComparable("小X", 33));
16. persons.add(new PersonComparable("小M", 33));
17. persons.add(new PersonComparable("小E", 33));
18.
19. //第三步 调用sort 排序
20. Collections.sort(persons);
21.
22. //使用迭代器遍历输出列表数据
23. Iterator<PersonComparable> iterator = persons.iterator();
24. while (iterator.hasNext()) {
25. PersonComparable persion = iterator.next();
26. System.out.println(persion.getName()+"\t"+persion.getAge());
27. }
28. }
29. }
30.
31. // 第一步 ：实现接口Comparable<T>
32. class PersonComparable implements Comparable<PersonComparable> {
33. private int age;
34. private String name;
35.
36. public PersonComparable() {
37.
38. }
39.
40. public PersonComparable(String name, int age) {
41. this.name = name;
42. this.age = age;
43. }
44.
45. public int getAge() {
46. return age;
47. }
48.
49. public void setAge(int age) {
50. this.age = age;
51. }
52.
53. public String getName() {
54. return name;
55. }
56.
57. public void setName(String name) {
58. this.name = name;
59. }
60.
61. /**
62. * 第二步 实现compareTo方法 o 表示和当前对象比较的另外一个对象
63. */
64. @Override
65. public int compareTo(PersonComparable o) {
66. // 从小到大 ：this-o
67. // 从大到小：o-this
68. // return this.age - o.age;
69. //改进比较方法：先根据年龄排序，如果年龄一样，根据姓名排序
70. if (this.age!=o.age) {
71. return this.age - o.age;
72. } else {
73. return this.name.compareTo(o.name);
74. }
75. }
76. }
二、Comparator简介
Comparator是比较接口，我们如果需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)，那么我们就可以建立一个“该类的比较器”来进行排序，这个“比较器”只需要实现Comparator接口即可。也就是说，我们可以通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序。
注意：
• 若一个类要实现Comparator接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
• int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。
示例代码：
1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.Comparator;
4. import java.util.Iterator;
5. import java.util.List;
6.
7. public class ListComparator {
8. public static void main(String[] args) {
9. List<PersonComparator> persons = new ArrayList<PersonComparator>();
10.
11. persons.add(new PersonComparator("小A", 35));
12. persons.add(new PersonComparator("小B", 25));
13. persons.add(new PersonComparator("小C", 25));
14. persons.add(new PersonComparator("小D", 12));
15. persons.add(new PersonComparator("小X", 33));
16. persons.add(new PersonComparator("小M", 33));
17. persons.add(new PersonComparator("小E", 33));
18.
19. // 调用sort 排序
20. Collections.sort(persons, new Comparator<PersonComparator>() {
21. @Override
22. public int compare(PersonComparator o1, PersonComparator o2) {
23. /**
24. * 从小到大：o1-o2 从大到小：o2-o1
25. */
26. //改进比较方法：先根据年龄排序，如果年龄一样，根据姓名排序
27. if (o1.getAge() != o2.getAge()) {
28. return o1.getAge() - o2.getAge();
29. } else {
30. return o2.getName().compareTo(o1.getName());
31. }
32. }
33. });
34.
35. //使用迭代器遍历输出列表数据
36. Iterator<PersonComparator> iterator = persons.iterator();
37. while (iterator.hasNext()) {
38. PersonComparator persion = iterator.next();
39. System.out.println(persion.getName()+"\t"+persion.getAge());
40. }
41. }
42. }
43.
44. class PersonComparator {
45. private int age;
46. private String name;
47.
48. public PersonComparator() {
49.
50. }
51.
52. public PersonComparator(String name, int age) {
53. this.name = name;
54. this.age = age;
55. }
56.
57. public int getAge() {
58. return age;
59. }
60.
61. public void setAge(int age) {
62. this.age = age;
63. }
64.
65. public String getName() {
66. return name;
67. }
68.
69. public void setName(String name) {
70. this.name = name;
71. }
72. }
扫一扫
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
