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);
 }
 }