2021-10-18

Java学习 day16 泛型<> 迭代器Iterator、ListIterator 生成迭代器

Iterator it = list.Iterator;
ListIterator it = list.ListIterator;

Iterator it = list.iterator();
		while(it.hasNext()){
			String next = it.next();
			if(next.equals("椎名空")){
				//意识到：使用Iterator遍历数据时，不能在Iterator中使用list进行添加、删除、插入
				//list.remove(next);
				//解决方案：
				it.remove();
			}
		}

遍历List

//foreach()遍历，底层由Iterator实现
for (String element : list) {
			System.out.println(element);
		}
//底层实现
String element;
for(Iterator it = list.iterator();it.hasNext();System.out.println(element)){
	elsment = it.next();
}

使用ListIterator遍历，遍历到椎名空时，删除该元素

ListIterator it = list.listIterator();
		while(it.hasNext()){
			String next = it.next();
			if(next.equals("椎名空")){
				it.remove();
			}
		}

使用ListIterator遍历，遍历到椎名空时，插入元素

ListIterator it = list.listIterator();
		while(it.hasNext()){
			String next = it.next();
			if(next.equals("椎名空")){
				it.add("张志豪");
			}
		}

使用ListIterator遍历，遍历到椎名空时，插入替换元素

ListIterator it = list.listIterator();
		while(it.hasNext()){
			String next = it.next();
			if(next.equals("椎名空")){
				it.set("张志豪");
			}
		}

使用ListIterator倒叙遍历

ListIterator it = list.listIterator(list.size());
		while(it.hasPrevious()){//判断是否有上一个可遍历的元素
			String previous = it.previous();//获取上一个元素
			System.out.println(previous);
		}

使用ListIterator指定下标开始遍历

ListIterator it = list.listIterator(2);
		while(it.hasNext()){
			String next = it.next();
			System.out.println(next);
		}

其中Iterator迭代器可以用于List与Set集合，而ListIterator只能用于List集合,ListIterator可以在遍历时，删除、添加、替换、从特定下标遍历、倒序输出，Iterator只可以用来删除。

ArrayList

见上一章。

linkedList<>() 创建对象

linkedList< String > list = new linkedList<>();

linkedList<>()与ArrayList一样，是有序号的，同时linkedList不同于ArrayList有队列模式（顺序输出）和栈模式（倒序输出），两种模式最终都会将集合中的数据取出来，最终集合的size()为零。
队列模式：

while(!list.isEmpty()){
	//删除第一个元素，并返回
	String element = list.removeFirst();
	System.out.println(element);
}

栈模式：

while(!list.isEmpty()){
	//删除最后一个元素，并返回
	String element = list.removeLast();
	System.out.println(element);
}

Vector<>()

Vector是JDK1.0版本就有的集合里，集合框架的概念是JDK1.2开始的，为了保留住Vector，就让Vector多实现了List接口，才将其保留下来。

Stack<>()

注意：Stack extends Vector
Stack有栈模式（倒序输出）：

Stack() list = new Stack<>();
list.push("111");//将元素压入栈顶
list.push("222");
list.push("333");
int search = stack.search("222");
System.out.println(search);//距栈顶的距离，从1开始
while(!stack.empty()){
	String name = stack.pop();//删除栈顶元素，并返回
	System.out.println(name);
}

HashSet<>() 创建对象

HashSet< Object >() hs = new HashSet<>();

HashSet基本学习

public static void main(String[] args) {

		HashSet set = new HashSet<>();
		//将集合加到集合后面
		HashSet newSet1 = new HashSet<>();
		Collections.addAll(newSet1, "111", "222", "333");//批量添加
		set.addAll(newSet1);
		//判断集合是否含有元素
		System.out.println("判断是否含有某个元素：" + set.contains("111"));
		//判断是否包含
		System.out.println("判断是否包含：" + set.containsAll(newSet1));
		//判断集合是否为空 true---空， false---非空
		System.out.println("判断是否空：" + set.isEmpty());
		//删除元素
		set.remove("222");
		//根据条件删除元素
		set.removeIf(new Predicate() {
			@Override
			public boolean test(String t) {
				int len = t.length();
				if(len == 5){
					return true;
				}
				return false;
			}
		});
		//去除交集
		set.removeAll(newSet1);
		//获取元素个数
		System.out.println("获取元素个数：" + set.size());
		//清空集合中所有的元素
		//set.clear();
		//保留交集
		//set.retainAll(newSet1);
		//转化为数组
		Object[] strs = set.toArray();
//		set.toArray(strs);
//		strs = set.toArray();
		//遍历集合
		System.out.println(Arrays.toString(strs));
		System.out.println("----------------");
		for (String str : set) {
			System.out.println(str);
		}	
		System.out.println("----------------");
		Iterator it = set.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}	
	}

深入学习HashSet<>()

理解HashSet无序且去重：
无序：（无序不代表随机，无序表示存入顺序与取出顺序不一致）
HashSet存入数据步骤：1、获取存入数据的hash值 2、通过hash值计算出数据在数组中的下标（HashSet底层使用数组存储数据）3、检查这个下标是否有元素（没有元素就加入，有元素就判断hash、==、equals，相等不添加，不同就添加）
取出数据顺序：从头到尾遍历数组
去重：由于HashSet添加元素的顺序，所以不存在重复数据

linkedHashSet<>() 创建对象

linkedHashSet< Object > lhs = new linkedHashSet<>();

注意：linkedHashSet extends HashSet
linkedHashSet是有序且去重。
去重的原因与HashSet一样，至于为什么是有顺序的，这是由于linkedHashSet在存储数据的时候，在其中的内存单元中还存储了上一个存入数据的节点地址以及下一个存入数据的节点地址，可以通过查询其中的属性得知上一个数据以及下一个数据，当遍历数组的时候按照其中的属性进行遍历，所以linkedHashSet是有序的。

public static void main(String[] args) {
		linkedHashSet set = new linkedHashSet<>();
		//添加数据
		set.add("111");
		set.add("222");
		set.add("333");
		set.add("333");
		//遍历 - Iterator
		Iterator it = set.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}//输出111,222,333
	}

TreeSet 创建对象

TreeSet< Object >() th = new TreeSet<>();

TreeSet与HashSet都是继承AbstractSet的，所以在大部分方法都是一样的。
其中TreeSet有一个很重要的特性，自然排序（根据不同的元素进行排序），对于去重，可以自己编写排序方法达到去重与否的设置。

深入TreeSet自然排序

1、内置比较器：在class中实现Comparable<>接口，重写compareTo()方法

public class Student implements Comparable{
	//内置比较器
	@Override
	public int comparaTo(Student stu){
	}
}

2、外置比较器（外置比较器 > 内置比较器）
在创建TreeSet的时候new一个匿名类并重写compare方法

TreeSet set = new TreeSet<>(new Comparator() {
	//外置比较器
	@Override
	public int compare(Student o1, Student o2) {});
}