JAVA基础集合（一）

---

一、整体结构

    Collection接口为一些单列集合的根接口，其常用子接口为List接口、Set接口。List接口常用实现子类为ArrayList（数组）
LinkedList（链表）。Set接口常用实现子类为HashSet（哈希表）LinkedHashSet（哈希表和链表结合）。

二、Collection接口

Collection接口作为根接口，为我们提供了集合的一些常用操作：
（1）增加、add(E e) - 返回值为boolean（是否添加成功）。
（2）清除、clear() - 除去此数组的所有操作。
（3）是否包含某一元素、contains(Object o) - 如果包含返回为true（可以用于进行if判断），如果集合里边的元素为自定义
类的话需要重写自定类的equals方法（contains方法就是基于equals实现的）否则比较的是地址。
（4）比较此collection与指定对象是否相等、equals(Object o) - 返回值为boolean（true为相等）。
（5）此collection是否包含某元素、isEmpty() - 返回值为boolean（true为不包含）。
（6）获取此collection的迭代器、iterator() - 用于遍历集合（此迭代器只能遍历集合，不能对集合进行修改，否则会报并发
修改异常-ConcurrentModificationException）。
（7）删除指定元素、remove(Object o) - 返回值为boolean（true表示删除成功）。
（8）返回元素数（集合的长度）、size() - 返回值为int(集合中元素的个数)。
（9）返回此集合中所有元素的数组、toArray() - 返回值是一个数组。

举例：

public static void main(String[] args) {
//创建集合，这里为多态-向下转型
Collection a = new ArrayList();
//在集合里添加元素
a.add("hello");
a.add("world");
//获取此集合的迭代器
Iterator iterator = a.iterator();
//通过迭代器遍历集合
while (iterator.hasNext()) {
String s = (String) iterator.next();
System.out.println(s);
}
//集合里是否包含"hello"元素
System.out.println(a.contains("hello"));
//这个是调皮的分割线
System.out.println("---------------------------");
System.out.println(a.isEmpty());
System.out.println("---------------------------");
//删除某元素
a.remove("world");
System.out.println(a);
//清空集合
a.clear();
System.out.println(a);
}

三、List接口

List派系的数组特点为有序、具有索引、可以重复。他可以使用其父的所有方法，同时他还有一些自己的方法:
（1）根据索引返回指定位置的元素、get(int index) - 返回值为指定位置的元素。
（2）返回第一次出现指定元素的索引、indexOf(Object o) - 返回值为int（索引如果不存在则返回-1）。
（3）返回最后一次出现指定元素的索引、lastIndexOf(Object o) - 返回值为int（索引如果不存在则返回-1）。
（4）获取此列表的迭代器、listIterator() - 用于遍历集合（此迭代器同iterator()的别在于，此迭代器可以对
数组进行增加等操作，因为ListIterator遍历的元素所在的容器都有索引）。
（5）替换指定索引位置的元素、set(int index, E element)。
举例：

public static void main(String[] args) {
// 创建集合
List c = new ArrayList();
// 添加元素
c.add("aaaa");
c.add("wqe");
c.add("eqw");
c.add("eqwe");
c.add("aatyaa");
// 获取迭代器
ListIterator iterator = c.listIterator();
while (iterator.hasNext()) {
String s = (String) iterator.next();
//如何集合里遇到"aaaa",则添加元素"哈哈哈哈"
if (s.equals("aaaa")) {
iterator.add("哈哈哈哈");
}
}
System.out.println(c);
}

1、ArrayList类

ArrayList类可以使用Collection、List的全部方法，具有List的特点-有序、具有索引、可以重复。常用的构造
方法：ArrayList<泛型> 变量名=new ArrayList<>();

2、LinkedList类

LinkedList类为List接口的链表实现，常用构造方法与一般的集合一样，而除了其根类的方法外还有其自己的独有方法：
（1）将元素添加到集合开头、addFirst(E e)。
（2）将元素添加到集合结尾、addLast(E e)。
（3）返回此集合的第一个元素、getFirst()。
（4）返回此集合的最后一个元素、getLast()。
（5）返回此集合中最后出现的指定元素的索引、lastIndexOf(Object o) - 返回值为int(索引)。
（6）移除并返回此列表的最后一个元素、removeLast() - 返回值为被删除的元素。
举例：

public static void main(String[] args) {
LinkedList ll = new LinkedList();
ll.add("hello");
ll.add("world");
// 再集合首位增加元素
ll.addFirst("java");
System.out.println(ll);
// 再集合末位增加元素
ll.addLast("py");
System.out.println(ll);
// 获取末尾索引的元素
System.out.println(ll.getLast());
// 获取首位索引位置
System.out.println(ll.getFirst());
// 删除末尾元素
ll.removeLast();
System.out.println(ll);
// 删除首位元素
ll.removeFirst();
System.out.println(ll);
// contains里边用的也是equals方法比较，比的是谁。用的谁的equals
boolean b = ll.contains("hekko");
}

四、Set接口

Set接口则是Collection里的另一个派系，Set派系的特点是无序的、没有索引、不能重复。同样的他也可以
使用Collection接口的全部方法。（学习类和方法时要从根开始学可以减少很多的无用功）。

1、HashSet

此类是以哈希表结构为基础，不保证其迭代顺序，所以说是无序的。
其常用初始化方法：HashSet< > 变量名=new HashSet<>();
举例：

//主方法
public static void main(String[] args) {
//创建集合
HashSet<Student> ah = new HashSet<>();
//添加元素
Student student = new Student("zhangsan1", 11);
Student student2 = new Student("sA", 1313);
Student s3 = new Student("sA", 1313);
ah.add(student2);
ah.add(student);
ah.add(s3);
for (Student s1 : ah) {
System.out.println(s1);
}
}

//学生类
class Student {
String name;
int age;

public Student() {
super();
// TODO Auto-generated constructor stub
}

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

@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}

注意：这里如果你自己定义的学生类就要重写hashCode和equals方法，因为add()方法底层默认比对的是其地址值，所
以每个对象一定是不同的，就会有重复的情况。而重写了hashCode和equals方法后，他会根据自定义类里的属性
生成hashCode，如果相同在比较地址或equals。如果都相同则被认定为重复。
（1）重写hashCode和equals方法的快捷方式：
Alt+Shift+S，在按h或鼠标选择重写hashCode和equals。
（2）判断是否重复的源码逻辑：
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

2、LinkedHashSet类

此类是哈希表和链表的结合，因此他具有不可重复、有序的特点。如果需要对数组进行去重,但是还不能改变数组中原来
数字的大小顺序就可以用这个类。
举例：

public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 1, 2, 6, 7, 10 };
// 定义集合
LinkedHashSet<Integer> lh = new LinkedHashSet<>();
for (int i = 0; i < arr.length; i++) {
lh.add(arr[i]);
}
//遍历集合
for (Integer integer : lh) {
System.out.println(integer);
}
}