集合深入------理解底层。
集合的使用
前提：栈、堆、二叉树、hashcode、toString()、quesalus()的知识深入和底层理解。
1、什么是集合
集合就是咋们所说的容器 前面我们学习过数组 数组也是容器 容器：装东西的 生活中有多少的容器呀? 水杯 教室 酒瓶 水库 只要是能装东西的 都可以看成是容器 我们这个集合的容器 是用来装啥的呢? 装数据? 数据? 一切可以被计算机识别的 文字 图片 视频 音频都是数据 说白了 我们今天所学习的这个集合 就跟前面的数组类似 只是底层的实现不一样而已
2、集合的分类
主要根据我们的值的个数 可以分成 单例集合 和 双列集合 单例集合：简单的说 在这个容器中存放的的值 就是一个一个的 value单列集合的爹：Collection 双列集合：他在容器中存储的数据就是 键值对 key---value双列集合的爹：Map
3、单列集合
3.1、List集合
3.1.1、ArrayList
ArrayList<E> 这个集合中的泛型：表示的意思其实就是对这个容器中能存放数据类型的一种约束 比如我们的泛型的数据类型是：User 那么这个容器中只能存放User类型的数据 这个ArrayList底层就是数组 他是有序的 地址空间是连续的 地址空间连续 就意味着能通过开始地址+偏移量来为访问 而且能重复添加数据 有序：一定能通过下标访问数据 List中所有的内容都是可以重复的....
3.1.1.1、集合的使用
public class ArrayListTest {
public static void main(String[] args) {//第一种方式List<String> list = new ArrayList<>();//接下来就可以向这个集合中存放数据了...list.add("123");list.add("456");list.add("789");list.add("789");
List<String> list2 = new ArrayList<>();//接下来就可以向这个集合中存放数据了...list.add("12322");list.add("45622");
//将list2集合中的数据 添加到 list中来list.addAll(list2);
//能不能删除数据呢?//这个就是直接删除某一个元素list.remove("789");
//还可以通过下标删除list.remove(0);
//接下来玩下修改呢?list.set(0,"小波波");
//获取某一个位置的元素String s = list.get(0);
//判断这个集合中是否存在某一个元素boolean contains = list.contains("789");
//判断集合是否为空boolean empty = list.isEmpty();
//返货某一个元素的下标位置int i = list.indexOf("789");
//截取集合中指定位置的元素 生成一个新的集合List<String> stringList = list.subList(0, 5);
System.out.println("list集合的size:"+list.size());
List<User> userList=new ArrayList<>();userList.add(new User(1,"小小","123"));userList.add(0,new User(0,"这里是测试","xxx"));
System.out.println("userList集合的size:"+userList.size());System.out.println("userList中的数据是:"+userList.get(0));}
}
public class ArrayListTest1 {
public static void main(String[] args) {List<String> list = new ArrayList<>();//接下来就可以向这个集合中存放数据了...list.add("123");list.add("456");list.add("789");list.add("789");
//第一种遍历方式：因为这个ArrayList本身底层是数组(Object类型的数组) 数组地址空间连续 所以我们能通过下标来访问for (int i = 0; i <list.size() ; i++) {System.out.println("集合中的值:"+list.get(i));}System.out.println("------------------------------");
//第二种遍历方式 通过增强的for循环来玩for (String val:list){System.out.println("集合中的值:"+val);}
System.out.println("------------------------------");
//第三种遍历方式通过JDK8中的stream流来遍历list.stream().forEach(val->{System.out.println("集合中的值:"+val);});
System.out.println("------------------------------");
//第四种遍历方式：迭代器 迭代器的游标问题/*** 这种情况下不允许对元素进行修改和删除** 其实不止是这种情况 在遍历的情况下 逻辑上都允许修改和删除的产生*/Iterator<String> it = list.iterator();// it.hasNext()：判断下一个节点是否有元素while (it.hasNext()){// it.next() ：取出当前位置的元素String val = it.next();System.out.println("通过迭代器取出来的值:"+val);}
System.out.println("------------------------------");
//第五种遍历方式ListIterator<String> it1 = list.listIterator();while (it1.hasNext()){String next = it1.next();System.out.println("通过迭代器取出来的值:"+next);}}
}
3.1.2、LinkedList
LinkedList底层是链表 链表中包含 一个一个的链条 每一个链条都包含了两部分 当前节点的值 和 下一个元素的地址 链表中 数据存储的地址空间不连续 所以不能使用偏移量来访问
输出的值是连续的。
public class LinkedListTest01 {
public static void main(String[] args) {//申明对象List<String> linkedList1 = new LinkedList<>();linkedList1.add("001");linkedList1.add("002");linkedList1.add("003");linkedList1.add("004");
for (int i = 0; i < linkedList1.size(); i++) {String val = linkedList1.get(i);System.out.println("val:"+val);}for (String val:linkedList1){System.out.println("val:"+val);}
linkedList1.stream().forEach(val->{System.out.println("val:"+val);});}
}
3.1.3、Vector的使用（不常用）
这个底层也是数组 线程安全的 效率不高 这个集合基本不使用 不也用记住
public class VectorTest {public static void main(String[] args){List<String> vector=new Vector<>();vector.add("中国好");vector.add("小日子");for (int i = 0; i <vector.size() ; i++) {System.out.println("数据是:"+vector.get(i));}
}
}
3.1.4、Stack（栈）
public class StackTest {
public static void main(String[] args){//这个其实是栈的数据结构
Stack<String> list=new Stack<String>();list.push("1");list.push("2");list.push("3");list.push("4");list.push("5");
System.out.println("pop:"+list.pop());System.out.println("pop:"+list.pop());System.out.println("pop:"+list.pop());System.out.println("pop:"+list.pop());System.out.println("pop:"+list.pop());
}
}
3.2、Set集合
逻辑上 Set集合逻辑上是无序的 而且Set集合能排重 不能通过下标直接访问Set<E> 的爹 依然是Collection Set这个接口是所有Set集合的爹Set排重的原则是啥?如果在Set集合中存放的是对象比如User 那么他就首先会去调用这个User中的 hashCode方法 然后获取到当前的这个要添加数据的hashCode值去和已经添加数据的HashCode值 做比较 如果是不等 那么说明肯定不是一个元素 那么直接添加元素 如果是HashCode值 遇到了在已经添加的数据中的HashCode值是相等的话 那么都说明有可能这个值是重复的 如果是这个值是重复的话 那就去调用当前这个对象的equals方法 判断equals方法是不是返回true 如果返回true 那么说明值重复 不添加数据 如果返回的是false 那么说明值 不重复 那么就可以添加数据
3.2.1、Set集合的排重问题(HashSet)
public static void main(String[] args) {Set<String> set = new HashSet<>();set.add("123");set.add("345");set.add("234");set.add("345");System.out.println("数据的个数:" + set.size());System.out.println("-----------------------------");Set<User> setUser = new HashSet<>();setUser.add(new User(1, "小小", "112"));setUser.add(new User(1, "小小", "134"));setUser.add(new User(1, "小小", "165"));setUser.add(new User(1, "小小", "178"));System.out.println("数据的个数:" + setUser.size());}
public class User {private Integer id;private String username;private String password;
public User(Integer id, String username, String password) {this.id = id;this.username = username;this.password = password;}
public User() {}
public Integer getId() {return id;}
public void setId(Integer id) {this.id = id;}
public String getUsername() {return username;}
public void setUsername(String username) {this.username = username;}
public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}
@Overridepublic int hashCode() {return this.username.hashCode();}
/*** 用户名一样 那么我们就认为这是同一个数据* @param obj* @return*/@Overridepublic boolean equals(Object obj) {if(obj instanceof User){User user= (User) obj;return this.username.equals(user.getUsername());}return false;}
}
3.2.2、Set集合的遍历问题(HashSet)
public class HashSetTest1 {
public static void main(String[] args) {Set<User> set = new HashSet<>();set.add(new User(1,"xiaobobo","123"));set.add(new User(-1,"tiedan","777"));set.add(new User(3,"gousheng","0"));set.add(new User(4,"gouwa","234"));set.add(new User(1,"ergouzi","234"));
//通过增强的for循环能访问for (User val:set){System.out.println("数据:"+val);}
System.out.println("--------------------------");
Iterator<User> it = set.iterator();while (it.hasNext()){User next = it.next();System.out.println("拿到的数据是:"+next);}
System.out.println("--------------");set.stream().forEach(user -> {System.out.println("读取到的数据是:"+user);});}
}
3.2.3、LinkedHashSet的使用
这个集合的底层是链表 这个集合的数据保存是有序的
public class LinkedHashSetTest {public static void main(String[] args) {Set<User> set = new LinkedHashSet<>();set.add(new User(1, "xiaobobo", "123"));set.add(new User(-1, "tiedan", "777"));set.add(new User(3, "gousheng", "0"));set.add(new User(4, "gouwa", "234"));set.add(new User(1, "gouwa", "234"));Iterator<User> it = set.iterator();while (it.hasNext()) {User next = it.next();System.out.println(next);}}
}
3.2.4、TreeSet（底层实现是红黑树）
TreeSet和其他的Set集合一样 具有 排重的特性 TreeSet的底层是红黑树--->二叉树--->数据结构--->有大小关系 TreeSet集合自动具有排序的功能 这个排序 就涉及到一个大小的问题 自然数的大小 字符串如何比较大小呢? unicode编码值
3.2.5、两个字符串如何比较大小呢？通过编码
// 在String这个类中为我们提供了这个比较两个字符串大小的方法
public static void main(String[] args) {String str = "Ab";String str2 = "Ab";/*** 返回值 0：表示的是前后相等* 返回值-1:表示的是前面小于后面* 返回值是1：表示的是前面大于后面*/System.out.println(str2.compareTo(str));
}
3.2.6、TreeSet的使用
TreeSet的底层使用的是红黑树来实现的
3.2.6.1、TreeSet的基本使用
package com.qfedu.edu.collection.set;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {Set<Integer> set = new TreeSet<>();set.add(123);set.add(0);set.add(345);set.add(77);set.add(77);set.add(89);
//遍历这些数据Iterator<Integer> it = set.iterator();
while (it.hasNext()) {Integer next = it.next();System.out.println("数据是:" + next);}
//--------------下面研究字符串的排序------------System.out.println("-------------------");
Set<String> setStr = new TreeSet<>();setStr.add("Abc");setStr.add("Bc");setStr.add("Ac");
//遍历这些数据Iterator<String> it1 = setStr.iterator();
while (it1.hasNext()) {String next = it1.next();System.out.println("数据是:" + next);}
}
}
3.2.6.2、Comparable接口实现对象的比较
1、编写Employee对象
public class Employee implements Comparable<Employee>{
private Integer id;private String name;private Integer salary;private String address;
public Employee(Integer id, String name, Integer salary, String address) {this.id = id;this.name = name;this.salary = salary;this.address = address;}
public Employee() {}
public Integer getId() {return id;}
public void setId(Integer id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Integer getSalary() {return salary;}
public void setSalary(Integer salary) {this.salary = salary;}
public String getAddress() {return address;}
public void setAddress(String address) {this.address = address;}
/*** 比较的方法* 你需要按照谁排序 那么下面你就按照什么来比较** 我要通过薪资排序* 薪资是int类型 那么下面就直接做减法* @param o the object to be compared.* @return*/
// @Override
// public int compareTo(Employee o) {
// return this.salary-o.getSalary();
// }
/*** 下面演示通过姓名来排序* 姓名是字符串类型* @param o the object to be compared.* @return*//* @Overridepublic int compareTo(Employee o) {return this.getName().compareTo(o.getName());}*/
/*** 如果薪资不为空 那么按照薪资排序* 如果薪资为空 并且姓名不为空 那么按照姓名排序* 如果姓名为空 那么就按照id排序....* @param o the object to be compared.* @return*/@Overridepublic int compareTo(Employee o) {if(o.getSalary()!=null){return this.getSalary()-o.getSalary();}else if(o.getName()!=null&&!("".equals(o.getName()))){return this.getName().compareTo(o.getName());}else{return this.id-o.getId();}}
@Overridepublic String toString() {return "Employee{" +"id=" + id +", name='" + name + '\'' +", salary=" + salary +", address='" + address + '\'' +'}';}
}
2、编写测试类
public class TreeSetTest1 {
public static void main(String[] args) {
Set<Employee> set = new TreeSet<>();set.add(new Employee(1,"xiaobobo",3500,"四川成都"));set.add(new Employee(2,"xiaowangzi",1800,"四川巴中"));set.add(new Employee(3,"tiedan",2600,"四川自贡"));set.add(new Employee(4,"gousheng",15000,"四川绵阳"));set.add(new Employee(5,"gouwa",2700,"四川德阳"));
Iterator<Employee> iterator = set.iterator();while (iterator.hasNext()){Employee next = iterator.next();System.out.println("获取到的数据是:"+next);}}
}
3.2.6.3、使用Comparator来实现对象的排序
1、对象的编写
public class Employee1{
private Integer id;private String name;private Integer salary;private String address;
public Employee1(Integer id, String name, Integer salary, String address) {this.id = id;this.name = name;this.salary = salary;this.address = address;}
public Employee1() {}
public Integer getId() {return id;}
public void setId(Integer id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Integer getSalary() {return salary;}
public void setSalary(Integer salary) {this.salary = salary;}
public String getAddress() {return address;}
public void setAddress(String address) {this.address = address;}
@Overridepublic String toString() {return "Employee{" +"id=" + id +", name='" + name + '\'' +", salary=" + salary +", address='" + address + '\'' +'}';}
}
2、测试的编写
package com.qfedu.edu.collection.set;
import com.qfedu.edu.pojo.Employee;
import com.qfedu.edu.pojo.Employee1;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/*** @author xiaobobo* @title: TreeSetTest* @projectName CD-Java-JY-2401-Simple-Parent* @description: 这个研究下TreeSet的对象的排序问题* @date 2024/3/19 15:26*/
public class TreeSetTest2 {
public static void main(String[] args) {
Set<Employee1> set = new TreeSet<>(new MyComparator());set.add(new Employee1(1,"xiaobobo",3500,"四川成都"));set.add(new Employee1(2,"xiaowangzi",1800,"四川巴中"));set.add(new Employee1(3,"tiedan",2600,"四川自贡"));set.add(new Employee1(4,"gousheng",15000,"四川绵阳"));set.add(new Employee1(5,"gouwa",2700,"四川德阳"));
Iterator<Employee1> iterator = set.iterator();while (iterator.hasNext()){Employee1 next = iterator.next();System.out.println("获取到的数据是:"+next);}
}
/*** 自定义了一个比较器 这个跟上一个接口是一样的*/static class MyComparator implements Comparator<Employee1>{/**** @param o1 新数据* @param o2 老数据* 按照薪资排序 做减法 按照谁排序 就用谁来做比较* @return*/@Overridepublic int compare(Employee1 o1, Employee1 o2) {return o1.getSalary()-o2.getSalary();}}
}