单值集合总复习

1：Object类的核心方法复习

Object 是所有类【引用数据类型】的 直接 / 间接 父类

toString(): 将一个 引用数据类型的对象 转换成 String 类型

class Object{//Sun
//toString()不需要参数：将一个对象转换成字符串 将调用者转换成字符串
public String toString(){
return this.getClass().getName() + "@" + 哈希码值的十六进制;
}
}
class 自定义数据类型 extends Object{
//toString()在没有覆盖的时候和Object类型保持一致
//通常子类都会选择福海toString()
@Override
//jdk5.0一模一样
//jdk5.0 斜变返回类型
public String toString(){//这一行不能修改
//拼装信息少：return xxx + "" + yyy...
//拼装信息多: new StringBuffer(XXX).append(yy)....toString();
}
}

 equals():比较两个引用数据类型的对象是否能被视为相等对象[逻辑相等]

class Object{
public boolean equals(Object obj){
return this == obj;//比较地址
}
}
class 自定义数据类型 extends Object{
@Override
public boolean equals(Object obj){//这一行不能修改
if(!(obj instanceof 当前类型))return false;
if(obj == this)return true;
return this.引用数据类型的属性.equals(((当前类型)obj).属性) &&
this.基本数据类型的属性 == ((当前类型)obj).属性
}

hashCode(): 生成一个引用数据类型的对象的哈希码值 -》 服务于HashSet

class Object{
public native int hashCode();//通过地址生成哈希码值
}
class 自定义数据类型 extends Object{
@Override
public int hashCode(){
return 引用数据类型.hashCode() + 基本数据类型;
}
}
API摘录：
注意：当此方法【equals】被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的
哈希码。

2：目前为止覆盖过父类/父接口的方法

toString () / equals () / hashCode () 都是覆盖的是 Object 类的方法

compareTo () 方法覆盖的是 Comparable 接口的方法

String 类实现 Comparable 接口 覆盖了 compareTo () 方法 按照字符串的每一个位做大小比较

Integer 类实现 Comparable 接口 覆盖 compareTo () 方法 按照数字本身大小做比较

compare () 方法覆盖的是 Comparator 接口的方法

任何一个引用数据类型 想要指定排序规则的话：

1 ：在这个引用数据类型里面制定排序 implements Comparable < 本类泛型 > -> compareTo ( 1 )

2 : 引用数据类型的代码不变 加一个比较器类 implements Comparator < 其他泛型 > -> compare ( 1 , 2 )

3：单值集合框架

 

接口角度

interface Collection{
add(元素) remove(元素) contains(元素)
size() isEmpty() clear()
addAll() removeAll retainAll()
iterator()
}
interface List extends Collection{
// IndexOutOfBoundsException
add(下标,元素); // [0,list.size()]
set(下标,元素); // [0,list.size()-1]
get(下标);
remove(下标);
indexOf(元素);
lastIndexOf(元素);
}
interface Set extends Collection{
}
interface SortedSet extends Set{
first()
pollFirst() 取出+删除
last()
pollLast() 取出+删除
}

4：学过的单值集合有哪些？他们底层的数据结构分别是？

5：ArrayList HashSet TreeSet核心方法的底层比较原理？

ArrayList集合增删改查

ArrayList 如果元素已经装进集合里面之后 想要 修改属性 ：直接修改

HashSet集合增删改查

 

TreeSet集合增删改查

6：谈hashCode()重码问题

String 类的哈希码值： // char[]

"etoak" => 'e'+'t'+'o'+'a'+'k' => 数值 重码率太高了

底层： 31(31*(31(31(31*0+'e')+'t')+'o')+'a')+'k'

hashCode() 编写的内部逻辑尽量贴近 官方

7：String类的contains()参数、集合的contains()参数

String 类的 contains() 参数

String 类的对象 .contains(String 类型的参数 )

集合的 contains() 参数

集合的对象 .contains( 集合的泛型 x);

// 集合的泛型可能： String/Student/Teacher

 

8：ArrayList LinkedList HashSet TreeSet如何选择 

ArrayList 有序 / 下标 查找快

LinkedList 添加 / 删除

HashSet 去重

TreeSet 排序

1 泛型自然顺序

2 比较器的定制顺序

9: ArrayList HashSet TreeSet常用的构造方法整理

// 默认开辟十块空间
ArrayList list = new ArrayList();
// 指定初始化容量的开辟
ArrayList list = new ArrayList(int 初始化容量);
// trimToSize() ensureCapacity(1000)
ArrayList list = new ArrayList(Collection);
// 哈希表 分组组数16 加载因子0.75
HashSet set = new HashSet();
// 分组组数 但是肯定变成2(n) 默认加载因子0.75
HashSet set = new HashSet(int 分组组数);
HashSet set = new HashSet(int 分组组数,float 加载因子);
// 去重
HashSet set = new HashSet(Collection);
// 自然顺序
TreeSet set = new TreeSet();
// 定制顺序
TreeSet set = new TreeSet(Comparator);
// 自然顺序
TreeSet set = new TreeSet(Collection);

 10：集合的遍历如何选择？

list 集合：有下标

                for + 下标/foreach/ 迭代器

                for + 下标：如果遍历集合得到元素的同时 想要得到下标 eg: 打表

                迭代器：如果遍历集合得到元素的同时 还想要进行删除 -》 car.remove()

                foreach：除了上面两种情况 全部使用foreach

Set集合：没有下标

                迭代器：如果遍历集合得到元素的同时 还想要进行删除 -》 car.remove()

                foreach：除了上面两种情况 全部使用foreach

11.fail-fast" 快速失败的原理 【CME】 

每一个集合底层都有一个变量叫 modCount 用来记录对集合的操作 [ 添加 / 删除 ... 任何一个对集合的大小操作的都算一次 ] 次数

当通过集合获得迭代器的时候 [ 集合对象 .iterator()] 迭代器会将 modCount 的值拷贝到它自己的属性 [expectedModCount] 里面

在执行 car.new() 触发两个值的比较

如果两个值一样 正常的取值进行下一步处理

如果两个值不一样 迭代器就会检测到除了它之外还有其他的线程也在处理集合 为了保证安全性直接抛出 CME 异常提示程序员这里有安全隐患

解决方法：

                1 for+下标+ 倒序【 ArrayList 】

                2 迭代器遍历+ 迭代器删除

                3 遍历过程中添加【先加入临时的集合】 + 出去遍历 addAll

场景：

                foreach/迭代器遍历+ 集合的删除 / 集合的添加

12：使用迭代器需要注意的知识点

迭代器

                car.next(); // 光标下移+ 取出元素

                car.hasNext();

                car.remove();// 删除元素+ 光标上移

                光标 默认 第一个的上一个 【-1】

当我们在遍历 A 集合的时候 想要从 A 集合里面删除元素：

                1：使用集合自己的删除方法 - 》 触发 CME 异常

                2: 使用迭代器自己的删除方法【正解】 car.remove()

当我们在遍历 A 集合的时候 想要往 A 集合里面添加元素：

                1：使用A 集合自己的添加方法 -> 触发 CME 异常

                2：使用迭代器的添加方法[ 迭代器没有 add]

                3：遍历A 集合的时候将想要添加的元素添加 B 集合里面 循环结束之后将 B 集合里面的元素装回 A 集合

13：ArrayList集合如何排序 、 TreeSet集合如何排序

ArrayList 有序：

                什么都不处理 -》 默认添加顺序

                调用Collections.sort(list对象 ) -> 自然排序 【泛型类必须有排序规则】

                调用Collections.sort(list对象 , 比较器对象 ); -> 定制排序 【泛型类可以没有排序】

                TreeSet set = new TreeSet(ArrayList对象); 自然排序 【泛型类必须有排序规则】

TreeSet 有序：

                TreeSet set = new TreeSet();//自然排序 [ 泛型类必须有排序规则 ]

                TreeSet set = new TreeSet(比较器对象);// 定制排序 [ 泛型类可以没有排序 ]

 

14 判断集合中是否存在某个元素？底层看什么？

ArrayList

                contains => equals()

HashSet

                contains => hashCode == equals

TreeSet

                contains => compareTo/compare

 

15 Collections集合的工具类提供的核心方法

 

// Collections单独为List提供的方法
static修饰的
Collections.sort(List) 按照泛型的自然顺序进行排序
Collections.sort(List,Comparator) 按照比较器的定制顺序进行排序
Collections.reverse(List); 反转集合中元素的顺序
List ll = Collections.synchronizedList(List对象)
//===================================
Collections单独为Collection提供的方法
Collections.addAll(单值集合对象，T ... x); 向集合中一次性添加多个元素
T Collections.max(Collection)：取集合中的最后一个元素【泛型的自然顺序升序-最大】
T Collections.max(Collection,Comparator):取集合中的最后一个元素【定制顺序-升序 最大的】
T Collections.min(Collection) 取集合中第一个元素【根据自然顺序[升序]返回集合中最小的元素】
T Collections.min(Collection,Comparator) 取集合中第一个元素【根据定制顺序[升序]返回集合中最小的元素】
int Collections.frequency(Collection,元素)
返回元素在集合中出现的次数
frequency底层：[ArrayList-equals() || HashSet equals() || TreeSet equals()]