一、数据结构
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);
//查询get
System.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;
}
@Override
public 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);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public 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.Integer
at 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.Comparable
at 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{
@Override
public 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]
7.5 TreeSet判断重复的标准小结
1、如果采用的是自然排序调用对象的compareTo方法,如果返回0 表示相等;
大于且返回正数,升序排列 => 小于且返回负数,升序排列 对应
大于且返回负数,降序排列 => 小于且返回正数,降序排列 对应
2、如果使用的定制排序(比较器),调用比较器的方法compare 返回0 表示相等;
大于且返回正数,升序排列 => 小于且返回负数,升序排列 对应
大于且返回负数,降序排列 => 小于且返回正数,降序排列 对应