单值集合总复习

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 方法的常规协定，该协定声明相等对象必须具有相等的
哈希码。

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集合增删改查

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()]