java集合容器至 Comparable/tor 的笔记


================ ArrayList 查的快========================
主要的索引的方法: index对应元素的
1: 存取的是一致:
2: 有索引
3: 可存取重复
注意:就是 关于 索引的 越界的异常
———-。主要的方法
add(加一个) addAll(全加)
remove 删除指定一个的 removeAll(删除指定全部的)

get(获取 ) set(替换) 返回的是以替换的 位置

ArrayList 的底层 是 数组扩容的
######list集合的几个遍历的方法
1:普通for、 2:增强 for 3:迭代器Iteration

====linkdeList 增删改的快
lastAdd()lastAddAll()
endAdd()endAddAll()

linkdeList:底层是 双循环 链表结构

节点的原因:看源码—– 数组转 链表
add linkedlast类里的 函数

—遍历慢— 每次 都是
加速的功能 的 —》在里面找get方法 里nodenode方法 里
在 长度大于二分之一的就 会 从头往后找 往 小于 , 就从后往头找
现在问的都是 1.7 的 hashMap 1.8 的就会很少的
比如——过时的单线程的线程安全模式———查的也是慢

===============set ===================
唯一 无序的 没有索引 是原始简单的集合
查询 快 的优势
用hash表来实现的
没有索引值的
》不能普通的for循环

底层的hash表结构
@@@ ==》普通for循环是不行的 : 因为没有索引值 的
迭代器 增强for 都可以的 需要Collcetion 的 Iteractor
—————–hash 太常见 了 因为继承于 Object

哈希表的最大的特点:查询快 哈希表本质 就是 一个Map集合

hash 是什么 对象的地址值 系统随机给出的十进制的
重写hascode 的方法
模拟了地址值 :列举 当hash值一样 物理地址值 就有不一样的
所以就要有 qrulse 来比较重复的值
equlse 的比较 有重复的就不存
hashSet:JDK8之前 :数组+链表
JDK8之后 :数组+ 链表 还有 + 红黑树:
链表长度超过8位的就转为红黑树 的快查机制

数组 把元素 做为 数组里的分组 (相同的元素为一组)
然后再把相同的一组 :用 链表与红黑树 来进行
而链表在过于长的时候就查是的慢了 这时候
链表长度超过8位的就转为红黑树 的快查接力

set集合的存储机制:避免重复元素的 原理

横为数组 竖 为链表 或红黑树

  • hash表是模拟物理地址的 有可重复的元素
  • 在通过equals 就决定了比较怕重复的不予存储的 去重
    最终追溯 源码的

哈希表 就是 一个Map集合

================ Collections 集合工具类 —————–
Collections 集合工具类 util 对于集合的操作
都是 静态方法
public static boolean addAll: 往集合里添加一些元素
publictatic void shuffle(List list): 打乱集合的元素——-比如打牌游戏 的 洗牌 就是一个shuffle
public static void sort(List list):将集合元素按照 默认的规则来排序
public static void sort(List list,comparator):
按照指定的(自定义的)=规则来排序

====》通过分析方法定义的参数:指定专属 List 类型的 使用的就是 参数里有List的
sort’方法的参数 的底层 是实现了 1:comparable接口里的compareTo方法 compraeTo()方法里定义了 比较的规则
===>泛型里类型 就实现了 这个方法 于是 就查看这个泛型的源码

public final class Integer extends Numble implements Comparable{}

也就是 集合里的泛型 包装类 的 都是实现了 comparable比较器
String实现了 内比较器 :采用的是 JDK提供 源码的定义的规则
同在 Java.lang 系统的
public final class String implements Java.io.Serializable,Comparable
,CharSequence{}

举例说: 集合里 存储的是 person类 有name 与age的属性

索引的0减一 根据一个差值 来决定 二分叉的
sort 方法参数 2:
按照首字母进行排序 使用匿名类进行的不太理解

——————————————————————————————————

比较器的接口 分为: 内比较器 comparable (内ble) 外比较器 comparator (外tor)

=======>内比较器 comparable 内部的就写的是固定的版本方法 所以通过源码的 比较器
=======>外比较器 comparator 外部 的自定义的来进行 降序 与升序的编码
====》这是 要学的 编码

@@@@@外比较器 comparator— 自定义 的

这是 要学写的编码 灵活的使用在 你要比较的地方直接的实现比较的规则就可以
多用于匿名类的方式 来实现灵活的完成
匿名类依赖 产生的接口:Comparator 大括号里重写 compare()

数字的是:
前减后 :升序 前要减的 为升—前减为升
后减前 :降序 后要减的 为降— 后减为降
对象的引用的是:
前 调用 后的==》 为升 —–前调 为升
后 调用 前的==》 为降序 —– 后调 为降
你可以转成 接口的实现类里来完成 理解后 在进行 匿名类的方式

comparator 外比较器 与 Comparable内比较器的区别

Comparable:内比较器:是直接就实行了整体排序 自动的排序无需指定 只能用一次 写死的硬编码的
compareTo()
类在定义的时候就已产生了比较的规则:升序了Comparable 并完成compareTo方法 你可以设置你的排序 降序与升序 天生就具

备了比较的规则

Comparator :外比较器:作为sort里的参数 以匿名实现类的方式 进行
重写方法里的 控制 降序 或 升序 的 还可以控制 数据结构 和 为没有自然排序的对象提供排序
compare()
在类 没有实现 内比较器 的时候 我们在 测试类里 使用
——》外比较器 用于 已经实现 内比较器的使用
@@@ 还可以在 你的使用了(实现)内比较器 的方式 还可以在 测试类里 完成 外比较器的 再次设置

在内部类里 的匿名类的使用率高的 要记住掌握 匿名类
匿名内部类的 范围: 大括号里的
集合里的线程
ArrayList 与linkedList 是多线程的 线程是安全吗??

########################### Map #####################################

先讲的出 增加激情 与自信 做的好

key 的值是不可重复的: 键找值的方法 keySet();
添add重复的key 就是要更新 对应的 value 值 然后替换(覆盖)==》还是唯一了

最常用的就是=====》HashMap
JDK 1.8与1.8 之前 :
每个集合 对用的 常用的集合类:3个代表: Arraylist HashSet HashMap

@@@ map 不适用 普通的for 与Intarator迭代器

增强for的遍历是:使用类型==》 数组 Collection 接口
map 中的键与值的映射关系
put 方法里 就是通过键 值的依赖作用来更新对应 认识达到了
、 键找值的 和值找键 的方式
加上 遍历的循环查找
put 的认识是 和add不同的是 在map键与值的映射的特点里、
可以 键找值 与值找 键的映射 依赖的关系 来 (更新 获取) 彼此
put() remove() get() containsKey()

get() :直接的get ()就可以获取 键 与 值 彼此的 映射

—-》键 与 值的一对 还可以是个Entry 对象
也可以说map集合里的泛型就是一个Entry对象

hash 表就是 Map集合?????

Map的获取 直接是的输出 就是一对一对的 键 值 或者 Entry

其中基于Map 键与值 的 映射中的获取
—–》这两种获取 的区别
单纯的通过键找值的==》 keySet()理解记忆key就是键 键存储在Set里确保唯一
值找 键==》values
Entry对象的获取 的 getKey() getValue()
Entry 就是map的内部类的

HashMap hash确保 键与值各自 唯一
创建实体类 在测试类里进行存取 的Demo 发现了 存与获取的顺序是不一致的

LinkedHashMap 增加了 Linked可以确保存取的顺序是一致是的


————-map——–
hashMap : key 值唯一的 ,value 为null
hashset 的:
底层是 使用的code值 唯一的 要说 hash 肯还会问的
Entry 对象数据
hashMap—看源码:当前编辑器里 ctrl+N 搜索–看源码

到了这个阶段我们应该需要 怎样 的目标的 感觉

总结:
1 利用 key的hashcode ——–理论唯一 并不代表 实现是唯一的
Entry 数组是的默认的大小16 0.75 12 到原来的 长度的0.75 就加载 =必问
Load加载因子
=扩容机制
再看put 就多了
扩容 2的幂次方 一千个 –2048
扩容的问题: 在进行扩容机制是非常损耗资源的 —-因为 数组 对象 还要节点
所以 最好要给与一个新的 已知 map好你的初始化 的数组

hashMap 不安全的 加了一整把锁 效果差一点把
解决 —ConcurrentHashMap 分段锁 机制
默认16个段(就是锁 : HashMap)然后分段的存储的 解耦 的锁机制还可以扩容

笔试题:——–》手写单项列表

拍的技术的核心就是原理—-大公司 的就是不需要有多大的项目

== 与 equals 是没有区别的 —-普通认知是的 误区
源码里有一个的
return==obj
GC 机制 的
单例模式

====================集合之间的转换,存储元素的 转存 ========================
Set paihao = new HashSet<>();——>
ArrayList pokerhao=new ArrayList<>();
pokerhao.addAll(paihao)

=》使用map方法的 的案例应用《========
的思路:
1:字符串的获取 : Scanner 的键盘输入
2:手动的fori 生成 循环 将 获取的字符串对象 遍历
3:字符串对象 调用 字符的获取方法,返回字符变量
4:使用map 调用的containsKey()的参数是这个字符变量 –》进行否定的判断
map 调用put方法 传入字符变量与 次数为1
else:map调用get()获取kye键字符 返回value数量的对象 这个次数 自增
map调用put 传入字符与自增的变量
5:map获取Entry对象类遍历 打印输出
map遍历2种方法 1:增强for与 2: Intrator迭代器

map 键找值的认知:
1:键找值的方法遍历map ,必须要用上keySet 、可以不用get()
:2:HashMap存储自定义练习的键值对 的说法:
可以存储自定义 放在键或者 值的对方 在键上的就必须重写 hashcode()yu
与equals() 来确 唯一
3:map存储的是键值对的数据 双列集合 键与值 的数据类型都可以 但是键的唯一 是必须的
4:键值对的找键和值 对于map 遍历说法:
5: Map的键key 只能是引用类型的数据 value值 也存放基本数据 引用类型的
map集合是通过entrySet()来获取键值对 对象的
map是 不能用普通for来遍历的 要在获取对象之后 就可以用:增强for与迭代器Intarator

1: null 0
2: 键找值的 不只要键找值的 还可以get()
3: key是可以的 存放 引用的 基本的都可以

@#@@@ next(只 读到有效的 字符)不管是 nextInt 还是 NextDuble 都会有问题的
nextline(读到 Enter键) 一行一行的读

注意:集合 双方的《泛型》数据类型要一致