Java day14

迭代器

List list = new ArrayList();
// 获取迭代器
Iterator< String> it = list.iterator();
// Java中不可以一边遍历一边进行增删元素,迭代器的删除方法是拷贝一份新的集合进行操作，然后再和原来的集合合并.
//Collection中的iterator的方法是从Iterable接口中继承过来的。
// Iterable—实现了这个接口的类产生的对象可以被增强for循环遍历 – 增强for循环本质上就是再进行迭代遍历

// sort方法需要传入一个接口，这里使用匿名内部类来实现接口的方法
// 根据元素的首字母进行排序(升序 从小到大)
list.sort(new Comparator< String>() {
// 重写接口源码中的int compare(T o1,T o2)方法
// 返回值int如果是负值，那么参数o1排在o2前面
// 返回值int如果是正值，那么参数o1排在o2后面
@Override
public int compare(String o1, String o2) {
return o1.charAt(0) - o2.charAt(0);
}
});

栈Stack

底层数据结构是数组
// 栈 stack 遵循LIFO原则 后进先出
// 子弹 行李箱
// 入栈\压栈 :就是向栈中存入元素，把元素从栈的顶端位置，依次放入到栈底的位置
// 出栈\弹栈:就是取元素。把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置
// 创建栈
Stack< String> stack = new Stack< String>();
// 压栈
stack.add(“adf”);
stack.add(“ios”);
stack.add(“for”);
stack.add(“pro”);
// 打印顺序依然是正向
System.out.println(stack);

// 弹栈 --会直接将栈中元素弹出
// 如果栈中没有数据，那么会出现异常 EmptyStackException
// String str = stack.pop();
// System.out.println(str);
// System.out.println(stack);

// 弹栈 --不影响栈中的元素
// 如果栈中没有数据，那么会出现异常 EmptyStackException
// String str = stack.peek();
// System.out.println(str);
// System.out.println(stack);
if (!stack.empty()){//判断栈是否为空
// stack.pop();
}

// 入栈
stack.push(“a”);
stack.push(“b”);
stack.push(“c”);
System.out.println(stack);

// 从栈顶向栈底从1开始搜索
System.out.println(stack.search(“a”));

Vector

// vector是最早的集合，从JDK1.0就出现了
// vector大部分方法和list接口重复
// 内部数据结构是数组
// 内存连续 查询速度快 增删速度慢 线程安全的集合 运行速度相对慢
// vector 初始容量是10 扩容是原来容量的一倍

// 迭代器–>用于遍历集合
// 获取迭代器
Enumeration< String> e = v.elements();
// 遍历
while (e.hasMoreElements()){
// 获取下一个元素
String s = e.nextElement();
System.out.println(s);
}

// 容量
System.out.println(v.capacity());
System.out.println(v.size());

泛型

// 泛型:安全机制
// JDK1.5特性
// 保证了程序的安全险，减少了代码量，避免了类型强转
// 将运行期间出现的类型转换错误提前到了编译期
// 在jdk1.7之后创建后面=右边的泛型只需要给一个<>即可
ArrayList< String> list = new ArrayList<>();

// 泛型用在类上面 在类名后面用<大写字母>表示泛型，如果有多个泛型，用，隔开即可
常用大写字母表示
// E:element
// T:type
// R:result
// K:key
// V:value
// 泛型在方法上面的使用
public < M> void add(M m){
System.out.println(m.getClass());
}
// 泛型的上限 格式 ? extends 类
// 作用:规定了泛型的最大范围
// 决定了所能传入的最大的类型范围
public static void print(List<? extends Number> list){
}
// 泛型的下限 格式 ? super 类
// 作用:规定了泛型的最小范围
// 决定了所能传入的最小的类型范围
public static void demo(List<? super Number> list){
}
// 泛型在接口中使用，在接口名后面跟上<大写字母>即可。如果有多个泛型，用,隔开
public interface MyInter< E> {
public abstract void show(E e);
}
// 在实现类中就已经确定了泛型的类型
// 在接口后面跟上<实际类型>
class MyInterImpl2 implements MyInter< Integer>{
@Override
public void show(Integer integer) {
}
}

// 在实现类后面跟上<大写字母> 还要在接口后面<大写字母>
class MyInterImpl implements MyInter< E>{
@Override
public void show(E e) {
}
}

Queue

// 队列 (FIFO) 先进先出
// 创建队列
Queue< String> queue = new LinkedList< String>();
// 添加元素
// queue.add(“abc”);
// queue.add(“cde”);
// // 添加元素
// queue.offer(“kkk”);

删除队列的头部(先进先出)
如果队列中没有元素，那么抛出NoSuchElementException
// queue.remove();

删除元素
// 如果队列中没有元素，那么返回null
// String str = queue.poll();
// System.out.println(str);
// System.out.println(queue);

获取队列头部的元素
// 如果没有数据，抛出NoSuchElementException
// String str1 = queue.element();
// System.out.println(str1);
// 如果队列中没有元素，返回null
String str2 = queue.peek();
System.out.println(str2);

Set

// set接口的特点:元素不重复
// HashSet的特点:存储不重复的元素，元素的位置不是一成不变的，是无序的，线程不安全的
// HashSet底层的数据结构是HashMap，HashMap底层的数据结构是数组+链表
// HashSet的指定容量的构造方法，会自动将数字提升为它最近的2的n次方的数
// 比如设定初始容量为20 那么会变成32
// JDK1.8开始，当哈希表中的链表的长度大于8，那么会将链表扭转成红黑二叉树,提高查询的效率
// LinkedHashSet 是HashSet的子类
// 特点:有序的集合，存储和取出的顺序相同的
// 底层数据结构哈希表(数组+链表)
// 线程不安全的集合，运行速度快

TreeSet

TreeSet< String> set = new TreeSet< String>();
set.add(“ac”);
set.add(“ab”);
set.add(“d”);
set.add(“e”);
set.add(“b”);
// 会对字符串进行排序
System.out.println(set);
// 要求放入TreeSet中元素所对应的类必须实现Comparable
// 拿当前的对象和传入的对象进行比较
// 如果返回值是正，那么当前对象放在传入对象的后面
// 如果返回值是负，那么当前对象放在传入对象的前面
@Override
public int compareTo(Student o) {
return this.age - o.age;
}

Stream

// stream，不是流，是操作集合的流式结构
// 提供了大量的批量操作集合数据的方法 — JDK1.8出现的
// 获取stream
Stream< String> stream = list.stream();
stream.filter(str->str.startsWith(“C”)).
map(str->str.toUpperCase()).
sorted((s1,s2)->s1.compareTo(s2)).
forEach(str-> System.out.println(str));

集合体系