集合问题小结

一、泛型

1、泛型的用处
在封装时，提高代码的可复用性，使用了泛型可以根据用户要求选择传递的数据类型。

2.泛型的格式

3.泛型在方法中的使用

public static <T> T test(T t) {
return t;
}

Integer test = test(123);
String test2 = test("你好");
Demo1 test3 = test(new Demo1());

用泛型定义的方法，可以传递不同类型的参数进行调用这个方法。

4.泛型在类中的使用

class TypeA<T> {
 
public T test1(T t) {
return t;
}
 

这里是定义了一个类

TypeA<String> typeA = new TypeA<String>();
String test1 = typeA.test1("北京烤
鸭");
typeA.test2("卤煮火烧", "豆汁");

生成一个类对象，这里生成的类对象是String类型的，所以后面添加也是String类型的，也可以生成别的类型。

注意点：1.如果没有约束类声明泛型，所有使用到泛型的位置都是Object
2.类声明的自定义泛型不能用于类内的静态方法。

4.在接口中使用

interface A<T> {
void test(T t);
}

这里定义了一个接口类 ，使用了泛型

自由模式：

 class TypeB<T> implements A<T> {
 
public void test(T t) {
System.out.println("自由模式");
}
}
 

这里定义了一个泛型类继承了接口

 TypeB<Integer> typeB = new
TypeB<Integer>();
typeB.test(10);
TypeB<Character> typeB2 = new
TypeB<Character>();
typeB2.test('A');

由于是自由模式，那么在这个类生成对象时，可以是各种数据类型

二、匿名内部类

1.用法
对于核心代码的替换
2.具体实现
题目：两个学生的各种成绩以及年龄的比较

 interface MyComparator {
boolean compare(Student stu1, Student
stu2);
}
 

这里定义了一个接口，接口中定义了一个方法，比较对象是两个学生类，
这时就可以采用一种方法：生成各种不同的类，每一种类完成不同的
数据的比较，这些类都继承了这个接口。但是这种方法比较麻烦，因为会生成很多的类，解决办法就是内部类。

三、集合

1.集合的必要性
用数组存放相同的数据类型时，由于数组的可用方法太少，所以引出了集合。

2.集合架构
总接口：Collection
有序可重复: interface List list
可变长数组结构： class ArrayList
双向链表结构： class LinkedList

3.collection接口下常用方法

增加： boolean add（E e）
boolean addAll（Collection <? extends E> c）要求存入的元素要么是E类，要不然就是他的子类。

删除：
void clear（） ；清空整个集合
boolean remove（Object obj； 删除集合中的指定元素
boolean removeAll(Collection<?> c);删除两个集合的交集
boolean retainAll(Collection<?> c);保留两个集合的交集

查找：
int size()； 返回集合中有效元素的个数
boolean isEmpty（）；判断当前集合是不是为空
boolean contains（Object obj）；判断指定元素在当前集合中是否存在
boolean containsAll（Collection<?> c）; 判断集合c是不是当前集合的子集 这里是说的连续的。

Collection<String> c = new ArrayList<String>();

这里是集合的声明，之后就可以使用集合的各种方法了。

三（1）集合之迭代器（用于集合操作的一种工具）

1.迭代器的获取

Iterator<String> iterator =c.iterator();

这里声明了集合c的迭代器

2.迭代器的常用方法

while (iterator.hasNext()) {
iterator.next();
iterator.remove();
}
 

boolean hasNext(); 判断当前Iterator是否可以继续运行。
E next(); 获取Iterator当前指向元素，并且指向下一个
元素。
void remove(); 删除

迭代器在使用remove方法时，可能会出现冲突问题

三（2）集合之List接口（类似高级数组）

1.特征：添加顺序和存储顺序一致 相同的元素可以重复添加
2 .两种结构：ArrayList linkedList
3.操作

增加：
add（E e）； 尾插法
addAll(Collection<? extends E> c)； List接口下，当前方法是添加另一个集合
到当前集合末尾
add(int index, E e); 在指定的下标位置，添加指定元素
addAll(int index, Collection<?extends E> c);在指定的下标位置，添加指定的集合

删除：

void clear();
清空整个集合
remove(Object obj);
删除集合中的指定元素
removeAll(Colletion<?> c);
删除两个集合的交集
retainAll(Colletion<?> c);
保留两个集合的交集
E remove(int index);
删除指定下标的元素。返回值是被删除的元素。

改:
E set(int index, E e);
使用指定元素替换指定下标index的元

查：
int size();
有效元素个数
boolean isEmpty();
判断当前集合是否为空
boolean contains(Object obj);
查看当前集合是不是包含这个元素
boolean containsAll(Collection<?> c);
查看当前结合是不是包括这个集合
int indexOf(Object obj);
找出指定元素在集合中的第一次出现位置
int lastIndexOf(Object obj);
找出指定元素在集合中最后一次出现位置
E get(int index);
获取指定下标的元素
List subList(int fromIndex, intendIndex);
获取当前集合的子集（前闭后开）

三（3）集合之ArrayList可变长数组

1.使用方法基本上都是从List接口中遵从的方法
2.自定义方法

Constructor构造方法

add(E e); 添加

add(int index, E e); 指定位置添加

addAll(自定义ArrayList e) 添加一个集合 尾插
addAll(int index,自定义ArrayList e) 给定位添加数组
remove(Object obj); 删除

remove(int index);
set(int index, E); 设置元素
E get(int index);获取
int indexOf();
int lastIndexOf();
boolean contains(Object obj);
boolean containsAll(自定义ArrayList类型
list)
boolean isEmpty();
int size();
ArrayList subList(int fromIndex,int endIndex);

三（4）集合之 LinkedList 双向链表

1.ADT：

class Node {
private Node prev;
private Node next;
private Object value;
// 构造方法存储元素，进入链接
}

一个指向前一个元素的地址 一个指向后一个元素的地址 一个保存当前元素的内容

2.管理节点的MyLinkList
为了便于操作，引入了一个头结点： 存放第一个节点的地址以及这个链表的长度。
3，实现方法

add(E e);
addFirst(E e);
addLast(E e);
E getFirst();
E getLast():
E get(int index);
removeFirst();
removeLast();
remove(int index);
remove(Object obj);
E set(int index, E);
size();