3.1集合-Set+集合-list

一、数据结构

1.1什么是数据结构

数据结构就是用来装数据以及数据与之间关系的一种集合，如何把相关联的数据存储到计算机，为后续的分析提供有效的数据源，是数据结构产生的由来。数据结构就是计算机存储、组织数据的方式。好的数据结构，让我们做起事来事半功倍。精心选择的数据结构可以带来更高的计算速度和存储效率。

1.2常见的数据结构

数组：操作数组利用下标，查询快，但是增删慢

链表：不依赖下标每个链表环环相扣，增删慢，查询快

队列：

树形结构

二、ArrayList

2.1ArrayList的介绍

内部基于数组的集合类

ArrayList中有哪些方法：增加，删除，修改，查询，插入...

ArrayList的线程是不同步的。

2.2ArrayList的使用

对它进行基本的增删改查插入。

 public static void main(String[] args) {ArrayList list = new ArrayList();ArrayList list01 = new ArrayList(list);ArrayList list02 = new ArrayList(14);list.add(1);list.add("a");list.add(true);list.add(new Date());list.add(1);list.add(null);//向指定下标插入元素。list.add(1,"xxx");System.out.println(list);list.remove(1);//删除指定元素//修改指定元素list.set(0,9);//查询getSystem.out.println(list.get(2));System.out.println(list.size());//集合有效长度。}

2.3遍历方式

1普通for循环

2增强for循环

3使用迭代器进行遍历

Iterator 就是一个迭代器（也是一个接口）其中的方法如下：

boolean hasNext() 判断是否有下一个元素，如果返回true表示有下一个；

Object next() 调用一次获得一个元素（每调用一次指针会向后移动一个）；

void remove() 会从迭代器指向的结合容器中删除一个元素

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.ListIterator;public class LoopText {public static void main(String[] args) {ArrayList list = new ArrayList();list.add(1);list.add("a");list.add(true);list.add(new Date());list.add(1);list.add(null);//向指定下标插入元素。list.add(1,"xxx");//for遍历集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}System.out.println("-------增强for------");for (Object o : list) {System.out.println(o);}System.out.println("---------第一次单项迭代器----------");Iterator iterator = list.iterator();//获取迭代器while (iterator.hasNext()){//判断迭代器后面是否还有数据System.out.println(iterator.next());//有数据就打印}System.out.println("------第二次迭代----------");while (iterator.hasNext()){//判断迭代器后面是否还有数据System.out.println(iterator.next());//第二次迭代没有数据输出因为迭代器的指针指向最后一位，后面没有数据了}System.out.println("----------双向迭代--------");ListIterator listIterator = list.listIterator();while (listIterator.hasNext()){System.out.println(listIterator.next());}System.out.println("----------------");while (listIterator.hasPrevious()){System.out.println(listIterator.previous());}}
}

双向迭代器：单向迭代器有的功能双向迭代器也有。不过它可以从数据的最后一位数往前迭代，原理与单项迭代器差不多，就是判断前一个元素，然后获取上一个元素。

三、LinkedList

1、内部是基于链表结构实现的。插入和删除比较快，查询相对ArrayList比较慢

2、内部相对于ArrayList而言多了一些操作头和尾的方法

3、可以充当队列，堆栈

4、不是线程安全的（同步的）

四、HashSet

4.1HashSet的介绍

无序不可重复，可存放null值
去重机制equals＋hashcode
线程不安全
快速将一个集合元素去重

4.2验证上面原则

打印上面示例中的元素的hashCode和equals的结果

2．尝试自定义类，覆写hashCode 和 equals 这两个方法中的代码随便写

(1) 尝试修改两个方法的值来测试容器中添加了几个对象

创建一个user类
package org.lzh.set;import java.util.Objects;public class User implements Comparable{private String name;private Integer age;public User() {}public User(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;User user = (User) o;return Objects.equals(name, user.name) &&Objects.equals(age, user.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Object o) {User a = (User)o;if(this.age>a.age){return 1;}else if(this.age < a.age){return -1;}else {return this.name.compareTo(a.name);}}
}//测试代码
public class HashSetText {public static void main(String[] args) {HashSet hashSet = new HashSet();ArrayList arrayList = new ArrayList();HashSet hashSet1 = new HashSet(arrayList);hashSet.add(1);hashSet.add("c");hashSet.add(new Date());hashSet.add(true);hashSet.add(1);hashSet.add(null);hashSet.add(new User("za",14));hashSet.add(new User("za",1));System.out.println(hashSet);//不能用普通for迭代for (Object o : hashSet) {System.out.println(o);}//迭代器，只能用单向迭代器System.out.println("-------------------");Iterator iterator = hashSet.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
}

五、TreeSet

5.1TreeSet的介绍

无序：不保证（不记录）我们的添加顺序；但是排序了

2．不重复：不能够添加重复元素（多个心眼）如何判断重复的呢？

3．感觉内部存储有一定的顺序

**注意：TreeSet一旦添加了第一个元素后就不能添加其它数据类型的元素了，只能添加相同数据类型的元素，除非将容器中所有的元素全部清空，才能添加新的数据类型的元素

5.2简单体验

*体验1*：**不重复及不保证添加顺序和打印顺序一致

TreeSet ts = new TreeSet();
ts.add("B");
ts.add("A");
ts.add("C");
ts.add("C");
System.out.println(ts.size());
System.out.println(ts);

1．结果：虽然打印结果的顺序和添加顺序可能不一致，但是**感觉结果是有某种规则排序的

2．说明String类也实现了Comparable接口，String对象可以调用compareTo方法

*体验2*：**添加了一种类型不能在添加其他类型

TreeSet ts = new TreeSet();
ts.add("B");
ts.add("A");
ts.add("C");
ts.add("C");
ts.add(10);
System.out.println(ts.size());
System.out.println(ts);
---------------------------------------------Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integerat java.lang.Integer.compareTo(Unknown Source)at java.util.TreeMap.put(Unknown Source)at java.util.TreeSet.add(Unknown Source)at cn.itsource._07TreeSet.TestTreeSet.main(TestTreeSet.java:12)

1．结果：居然不能够放不同的类型，但是编译没有错

**体验3：添加自定义的类的对象 Student对象

TreeSet ts = new TreeSet();
Student stu1 = new Student("王者",18);
ts.add(stu1);
System.out.println(ts.size());
System.out.println(ts);
-----------------------------------------Exception in thread "main" java.lang.ClassCastException: cn.itsource._07TreeSet.Student cannot be cast to java.lang.Comparableat java.util.TreeMap.compare(Unknown Source)at java.util.TreeMap.put(Unknown Source)at java.util.TreeSet.add(Unknown Source)at cn.itsource._07TreeSet.TestTreeSet.main(TestTreeSet.java:9)

1．结果：

2．疑问1：上面的代码添加的都是同种类型的数据，为什么还报错；

3．疑问2：为什么提示要把Student转成Comparable

4．正常情况 ----> TreeSet 或者 Comparable的文档

5.3 TreeSet的结构（存储原理）分析

1．TreeSet内部是按照大小进行排序的，大小有对象与对象之间比较进行决定的

2．设计TreeSet之前：Java设计了一个接口Comparable接口，其中提供了对象之间比较的方法CompareTo

3．TreeSet会调用对象的CompareTo方法，比较对象，所以我们放入的对象需实现Comparable

5.4 自然排序与定制排序（比较器）

5.4.1 自然排序 Comparable

**什么是自然排序

1．例如：大家排队，按照高矮个排队，那么同学们自己相互之间就能进行对比，每个对象具备自我比较判断的能力，称之为自然排序

*Comparable*中API**文档中的描述：

2．此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法

**理解：

3．如果一个类实现了Comparable接口，可以认为这个类的对象具有自然排序的能力（本质就是这个对象可以调用比较的方法compareTo），这种比较和排序的规则就是自然排序

@Override
public int compareTo(Object o) {if(o==null){return 0;}Student stu = (Student)o;if(this.age>stu.age){//如果大于的时候返回负数表示降序，返回负数表示升序return -1;}else if(this.age<stu.age){//如果大于的时候返回负数表示降序，返回负数表示升序return 1;}else{//如果年龄不大于也不小于说明等于，那么有名字来决定对象是否相同String已经写好排序规则return this.name.compareTo(stu.name);}
}

测试代码

TreeSet ts = new TreeSet();
Student stu1 = new Student("XXX",20);
Student stu2 = new Student("XXX",20);
ts.add(stu1);
ts.add(stu2);
System.out.println(ts.size());
System.out.println(ts);
-------------------------------------1
[Student [name=XXX, age=20]]

**自然排序小结

5.4.2 定制排序（比较器）Comparator

1、什么是定制排序

定制排序，相当于给容器提供了一个裁判：例如操场就是一个容器，那么体育老师就是这个裁判，每个同学进入操场同学们相互之间可以比较谁比较帅，或者不可以比较谁帅都可以，有了老师这个裁判，老师可以负责比较每一位同学

2、为什么需要定制排序

(1) 原来的比较规则不符合所有人的使用需求

(2) 不存在比较规则的对象，无法放入容器，我可以给容器提供定制比较器

3、定制排序如何实现

(1) Comparator 是一个比较器的接口（标准），必须得有进行比较的方法：compare(Object o1,Object o2);

(2) 自定义一个类实现Comparator接口，其中写比较规则 ---> 比较器的模板，我们现在需要的是一个具体的比较器对象

public class MyComparator implements Comparator{@Overridepublic int compare(Object o1, Object o2) {if(o1==null||o2==null){//判断，若两个有一个为null都直接返回return 0;}if(o1 instanceof Student && o2 instanceof Student){//如果类型匹配才转换Student stu1 = (Student)o1;Student stu2 = (Student)o2;if(stu1.age>stu2.age){//先判断年龄后判断姓名return 1;}else if(stu1.age<stu2.age){return -1;}else{return stu1.name.compareTo(stu2.name);}}return 0;}
}

测试代码

MyComparator mc = new MyComparator();
TreeSet ts = new TreeSet(mc);
Student stu1 = new Student("XXX",19);
Student stu2 = new Student("OOO",18);
Student stu3 = new Student("YYY",18);
Student stu4 = new Student("ZZZ",18);
Student stu5 = new Student("QQQ",18);
ts.add(stu1);
ts.add(stu2);
ts.add(stu3);
ts.add(stu4);
ts.add(stu5);
System.out.println(ts.size());
System.out.println(ts);
---------------------------------------5
[OOO-18, QQQ-18, YYY-18, ZZZ-18, XXX-19]