Day06 排序查找 Map集合 集合的嵌套

TreeSet

1 TreeSet介绍
TreeSet 集合是Set接口的一个实现类，底层依赖于TreeMap，是一种基于红黑树结构的实现，具有以下特点：
元素去重
元素没有索引
元素有排序
TreeSet元素的排序规则，使用元素的自然排序规则，或者根据创建 TreeSet 时提供的 Comparator 比较器进行排序
具体取决于使用的构造方法：
public TreeSet()：根据其元素的自然排序进行排序public TreeSet(Comparator comparator)：根据指定的比较器进行排序
2 TreeSet自然排序实践
一个类只要实现了接口Comparable就具备自然排序能力。**

3 TreeSet自定义排序实践
TreeSet可以实现自定义比较器排序，需要使用自定义比较器的构造方法，可以用来存储不具备自然排序能力的数据，也可以用来覆盖自然排序规则。

public TreeSet(Comparator comparator)：根据指定的比较器进行排序

Comparator 是一个接口，我们需要去实现一个抽象方法compare，我们可以直接定义匿名内部类去实现该方法：
public int compare(E o1,E o2){
Return This.age - o.age; //升序
// 或者
return o.age - this.age; //降序V }
口诀：升序就是1减2，降序就是2减1
1表示第一个参数，2表示第二个参数**

E 如果是数值类型， o1和o2可以直接相减。如果是自定义类型或者其他非数值类型，不能直接相减，应该将对象中要进行排序的属性值拿出来进行比较相减
例如：集合中存储的是学生对象，要求按照学生的年龄升序排序
return o1.getAge()-o2.getAge();
整数类型Integer是具有自然排序升序排序功能的，可以自定义比较器降序覆盖原有自然排序。
自定义类型Student类型，不具备自然排序功能，需要自定义比较器进行实现功能

TreeSet集合

TreeSet去重和equals无关。
TreeSet集合底层结构是什么有什么特点：
底层结构是红黑树，具有去重，排序特点
TreeSet集合如何实现自定义比较器排序：
在创建TreeSet集合的时候，指定Comparator比较器，重写compare方法
升序：o1-o2 返回值用this 减去里面存的数据，如果是复数说明比里面的小，往左边排
降序：o2-o1 如果减去里面的数据有余数说明大，往右边存，等于0就不会存 里面有！

Collections工具类

1 Collections工具类介绍

java.util.Collections 是集合的工具类，里面提供了静态方法来操作集合，乱序，排序….

shuffle方法

public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
使用该方法需要注意的：
乱序只能对List集合进行乱序
集合中元素类型可以任意类型

Collections的shuffle是什么功能:
打乱List集合顺序

shuffle方法使用要注意什么？
(List<?> list)
1.只能打乱List集合
2.集合中的元素可以任意类型

排序方法sort

概念：
sort方法是一个重载的方法，可以实现自然排序及自定义比较器排序。要特别注意的是sort方法只能对List集合进行排序。

public static > void sort (List list)

public static void sort (List list, Comparator<? super T> c)

2 Collections的sort自然排序
public static > void sort (List list) 按照原始自然排序
方法分析：
该方法只能对List集合进行排序
从方法中泛型分析可知，集合中元素类型必须是Comparable的子类型。
3 Collections的sort自定义排序
public static void sort (List list, Comparator<? super T> c)

方法分析：

方法只能对List集合排序
对元素的类型没有要求
需要定义一个比较器Comparator
（规则和之前TreeSet时一样）

使用场景：
List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）
List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需。

Collections的sort方法只能对什么集合进行排序：
List集合

什么时候可以使用自然排序：
当List集合中元素类型实现了Comparable接口时，就可以使用自然排序

什么时候可以使用自定义比较器来进行排序：
List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）
List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需。

可变参数

1 可变参数介绍
在 Java 5 中提供了变长参数，允许在调用方法时传入不定长度的参数。变长参数是 Java 的一个语法糖，本质上还是基于数组的实现，如下：
void test (String… args);void test (String[] args );**

2 可变参数的定义
在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。
上述定义有几个要点需要注意：
可变参数只能作为方法的最后一个参数，但其前面可以有或没有任何其他参数，因此一个方法最多只能有一个可变参数。
可变参数本质上是数组，不能作为方法的重载。如果同时出现相同类型的数组和可变参数方法，是不能编译通过的。可变参数可以兼容数组，反之则不成立。

4 Collections的addAll方法
static boolean addAll(Collection<? super T> c, T… elements) 添加任意多个数据到集合中

分析： 该方法就是一个含有可变参数的方法，使用时可以传入任意多个实参，实用方便！

怎么给方法定义可变参数：
在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。

含有可变参数的方法怎么使用：
方法内部使用：直接当做数组使用
调用方法时：可以传入该类型的数组，也可传入该类型任意多个数据

排序查找算法

1 冒泡排序介绍

冒泡排序（Bubble Sort）算法描述：比较相邻两个元素大小，如果反序，则交换。若按升序排序，每趟将数据序列中的最大元素交换到最后位置，就像气泡从水里冒出一样。若按降序排序则相反。

简要描述什么是冒泡排序：
比较相邻两个元素大小，如果反序，则交换
代码实现冒泡排序时有什么规律：
有n个元素，那么就要比较n-1趟。
每一趟中都会选出一个最值元素，较前一趟少比较一次。

选择排序

1 选择排序介绍
选择排序（Selection Sort）算法描述：它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。
描述选择排序的工作原理：
它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

代码实现选择排序时有什么规律？
有n个元素，那么就要比较n-1趟。
每一趟中都会选出一个最值元素，较前一趟少比较一次。

二分查找

1 二分查找介绍
二分查找，用来查询搜索定位。比如要定位一个元素在数组中的索引位置。前提条件：要求被查询的数组，集合必须有升序排序；

2 二分查找原理分析
二分查找的原理，每次查找最中间的元素，对比中间元素的值与被查找元素的值大小。

1. 刚好相同，找到了结束
2. 如果要找的元素比中间元素小了。将查找的范围缩小到中间的左边一般。继续二分查找
3.如果要找的元素比中间元素大了。将查找的范围缩小到中间的右边一般。继续二分查找
直到找到位置，如果最没有找到返回-1 。

数组要实现二分查找的前提条件：
数组必须是有排序的

描述二分查找的实现原理：
二分查找的原理，每次查找最中间的元素，对比中间元素的值与被查找元素的值大小。
刚好相同，找到了结束
如果要找的元素比中间元素小了。将查找的范围缩小到中间的左边一般。继续二分查找
如果要找的元素比中间元素大了。将查找的范围缩小到中间的右边一般。继续二分查找
直到找到位置，如果最没有找到返回-1 。

Map集合介绍

1 Map集合概述

java.util.Map 集合，里面保存的数据是成对存在的，称之为双列集合。存储的数据，我们称为键值对。 之前所学的Collection集合中元素单个单个存在的，称为单列集合。

2 Map集合特点介绍

Map K：键的数据类型；V：值的数据类型
1.键不能重复，值可以重复
2.键和值是 一 一 对应的，通过键可以找到对应的值
3.（键 + 值） 一起是一个整体 我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”。
使用场景：凡是要表示一一对应的数据时就可以。
举例1：学生的学号和姓名
itheima001 小智
举例2：夫妻的关系
王宝强 马蓉
谢霆锋 张柏芝

3 常用实现类

HashMap：
此前的HashSet底层实现就是HashMap完成的，HashSet保存的元素其实就是HashMap集合中保存的键，底层结构是哈希表结构，具有去重，无序，特点。

LinkedHashMap：
底层结构是有链表和哈希表结构，去重，有序

TreeMap：
底层是有红黑树，去重，排序

4 Map中常用的方法

- public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。- public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。- public V get(Object key) 根据指定的键，在Map集合中获取对应的值。- public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。- public boolean containKey(Object key):判断该集合中是否有此键。
Map集合有什么特点:
1.键不能重复，值可以重复
2.键和值是 一 一 对应的，通过键可以找到对应的值

Map 常见的实现类:
HashMap，LinkedHashMap，TreeMap

Map常用的方法:
put,get,remove,keyset,containsKey，entrySet

Map集合的遍历方式

1 遍历概述
Map集合既不能使用索引来遍历，也不能使用迭代器遍历，如果要进行对Map集合遍历，可以有两种方式：
1 先获取所有的键，遍历键去查找对应的值
2 可以先获取所有的键值对对象，通过键值对对象来遍历

2 键找值方式遍历
操作步骤：
先通过keySet获取所有的键
遍历所有的键，通过键找到值

3 键值对对象遍历
Map中存在Entry接口用来表示键值对对象。
interface Map{ interface Entry{ // 表示某个键值对 K getKey(); V getValue();}}
要获取所有的键值对Entry对象，需要借助Map方法:
public Set> entrySet()
获取到Map集合中所有的键值对对象的集合(Set集合)。**

使用键找值方式遍历的步骤：
1.先通过keySet获取所有的键
2.遍历所有的键，通过键找到值

使用键值对对象方式遍历的步骤
1.调用map集合的entrySet方法获取所有的键值对对象
2.遍历每一个键值对对象（Entry对象）
3.getKey获取键，getValue获取值

HashMap存储自定义类型键

1 HashMap介绍
HashSet中所存储的值，其实底层就放置在HashMap的键当中。底层使用哈希表结构来存储数据，存放数据时会执行hashCode和equals方法来去重。
因此，HashMap使用自定义类型当做键使用时要也要注意： 自定义类型需要重写hashCode和equals方法

HashMap存储自定义类型的键要注意事项：
要达到去重效果，需要重写hashCode和equals方法

LinkedHashMap集合

LinkedHashMap是LinkedHasSet的底层实现。在最底层采用的数据结构，是链表+哈希表。
特点：
去重，有序

TreeMap集合

TreeMap的底层是红黑树实现的，有排序的能力，键去重。
可以自然排序（元素类型要实现Comparable）
可以自定义比较器排序（Comparator）若自定义类型没有自然排序功能，或自然排序功能不满足要求时使用。
两种排序方式对应了TreeMap的两个构造方法：
public TreeMap() 使用自然排序public TreeMap(Comparator<? super K> comparator) 比较器排**

请问TreeMap集合特点：
去重，排序

TreeMap的排序方式支持方式：
自然排序
自定义比较器排序

TreeSet示例：

Student类！
public class Student implements Comparable { private String name; private int age;

@Overridepublic int compareTo(Student o) { // return this.age-o.age; 升序 return o.age-this.age; 降序}
测试类：
public class ComparableDemo2 { public static void main(String[] args) { TreeSetts=new TreeSet<>(); ts.add(new Student(“张三”,20)); ts.add(new Student(“李四”,18)); ts.add(new Student(“赵六”,16)); ts.add(new Student(“和二”,15)); for (Student s1:ts){ System.out.println(“s1 = “ + s1); }}}**

Shuffle示例：

Listlist=new ArrayList<>();list.add(10);list.add(20);list.add(30);list.add(40);System.out.println(“list = “ + list); //list = [10, 20, 30, 40]// 2 添加元素Collections.shuffle(list); //乱序功能打乱last中的集合！ 只能打乱list集合！System.out.println(“list = “ + list); // list = [30, 10, 40, 20]

Sort示例：

ArrayList list = new ArrayList<>();list.add(1);list.add(3);list.add(2);list.add(5);list.add(4);System.out.println(“list = “ + list); //list = [1, 3, 2, 5, 4]
Collections.sort(list); //升序 Collectons.sort(变量名);System.out.println(“list = “ + list); //list = [1, 2, 3, 4, 5]
Collections.sort(list, new Comparator() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; }});System.out.println(“list = “ + list); //list = [80, 45, 30, 15, 10]降序方法
}}

Sort的可变参数示例：

public class Test { public static void main(String[] args) { System.out.println(sum(1, 2, 3, 4)); System.out.println(sum(1, 2, 3)); }
//可变参数当成数组用，可变参数本质上就是数组可以用索引来访问public static int sum(int…num){ int sum = 0; for (int i : num) { sum += i; } return sum; } //任意类型都可以定义可变参数！ public static void Test(ArrayList…list){ }

Collections的addAll方法

使用：addAll可以直接传入任意多个实参！
public static void main(String[] args) { ArrayList list = new ArrayList<>(); Collections.addAll(list, “a”, “b”, “c”, “d”); System.out.println(list); //list=[a, b, c, d]}public static void addElement(List list, T… t) { for (T element : t) { list.add(element); }}**

冒泡排序

public class SortDemo { public static void main(String[] args) { int[] arr = {5, 4, 3, 2, 1}; for (int j = 0; j < arr.length - 1; j++) { // -1为了防止索引越界 for (int i = 0; i < arr.length - 1 - j; i++) { if (arr[i] > arr[i + 1]) { //升序大于号 降序小于号 int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } } } System.out.println(Arrays.toString(arr));

选择排序

示例：
public class SortDemo { public static void main(String[] args) { int[] arr = {55, 11, 44, 22, 33}; int time = arr.length - 1; // 遍历数组 for (int i = 0; i < time; i++) { //次数 int minIdnex = i; //临时定义最小值的变量 for (int j = i + 1; j < arr.length; j++) { if (arr[minIdnex] > arr[j]) {
//剩余未排序的元素中找到最小的索引位置！ minIdnex = j; } } if (minIdnex != i) { //将最小的数据与i位置的数据进行交换 int temp = arr[i]; //i位置的元素 minIndex元素比较 arr[i] = arr[minIdnex]; arr[minIdnex] = temp; } } System.out.println(Arrays.toString(arr));//[11, 22, 33, 44, 55] }}

二分查找步骤

public class BinarySearchDemo { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; //如果有相同元素只能找到其中一个元素。 System.out.println(binarySearch(arr, 9)); } // 方法的功能是 , 接收一个数组和一个元素 , 返回此元素在数组中出现的索引 public static int binarySearch(int[] arr, int num) { // 1，定义两个变量，表示要查找的范围。默认min = 0 ， max = 最大索引 int min=0; int max=arr.length-1; // 2，循环查找，但是min <= max while (min<=max){ // 3，计算出mid的值 int mind=(max+min)/2; // 4，判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引 if(arr[mind]==num){ //找到数据返回 return mind; }else if(num//5，如果要查找的值在mid的左半边那么min值不变，max = mid -1.继续下次循环查找 max=mind-1; }else if(num>arr[mind]) {
//6，如果要查找的值在mid的右半边那么max值不变，min = mid + 1.继续下次循环查找 min=mind+1; }} // min > max return -1; }}

Map集合常用方法

public class MapDemo1 { public static void main(String[] args) { Map map = new HashMap<>(); //public V put(K key, V value): 把指定的键与指定的值添加到Map集合中 //put返回原来键所对应的值， 返回null String put = map.put(“文章”, “马伊利”); System.out.println(“put = “ + put);//null put返回原来键所对应的值， 返回null put = map.put(“文章”, “姚笛”); System.out.println(“put = “ + put);//put = 马伊利 System.out.println(“map = “ + map); map.put(“谢霆锋”,”张柏芝”); map.put(“陈冠希”,”张柏芝”); map.put(“李亚鹏”,”王菲”); System.out.println(“map = “ + map);** //public V remove(Object key):
把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值 String remove = map.remove(“陈冠希”); System.out.println(“remove = “ + remove);//remove = 张柏芝 System.out.println(“map = “ + map);
//map = {文章=姚笛, 谢霆锋=张柏芝, 李亚鹏=王菲}** // public V get(Object key) 根据指定的键，在Map集合中获取对应的值 String get = map.get(“文章”);//get = 姚笛 System.out.println(“get = “ + get); System.out.println(“map = “ + map);
//map = {文章=姚笛, 谢霆锋=张柏芝, 李亚鹏=王菲} //public boolean containKey(Object key): 判断该集合中是否有此键 boolean containsKry= map.containsKey(“李亚鹏”); System.out.println(“containsKry = “ + containsKry);** }}

Map集合的遍历

方法一：
public class MapDemo2 { public static void main(String[] args) { // 1 创建集合对象 Map map = new HashMap<>(); // 2 添加元素 map.put(“周瑜”, “小乔”); map.put(“孙策”, “大乔”); map.put(“刘备”, “孙尚香”); map.put(“诸葛亮”, “黄月英”); // 3 遍历集合 //获取所有 键 Set keys = map.keySet(); for (String key : keys) { String str = map.get(key); System.out.println(key + “,” + str); } }}
方法二：
public class MapDemo3 { public static void main(String[] args) { // 1 创建集合对象 Map map = new HashMap<>(); // 2 添加元素 map.put(“射手”, “孙尚香”); map.put(“战士”, “孙策”); map.put(“法师”, “周瑜，诸葛亮”); map.put(“打野”, “刘备”); map.put(“辅助”, “大乔”);
//获取所有键值对对象！
生成方法 ：Map.entrySet().var Set> entries = map.entrySet(); // 3 遍历集合 生成方法 ：entries.for for (Map.Entry entry : entries) { String key = entry.getKey(); //获取键 getKey() : 获取键 String value = entry.getValue(); //获取值 getValue() : 获取值 System.out.println(key+”,”+value);
//输出： 刘备,孙尚 香孙策,大乔 诸葛亮,黄月英 周瑜,大乔
//键不能重复，值可以重复 也就是后面的数值可以重复出现！但是前面的不行！
}}}**

哈希Map重写后方法！

只要是用哈希表存储数据要达到去重效果都要重写 haxCode和equlas方法！

public class HashMapTest1 { public static void main(String[] args) { // 1 创建HashMap集合对象 MapstudentStringMap=new HashMap<>(); // 2 添加元素 studentStringMap.put(new Student(“迪丽热巴”, 18),”上海”); studentStringMap.put(new Student(“古力娜扎”, 20),”上海”); studentStringMap.put(new Student(“马尔扎哈”, 10),”上海”); studentStringMap.put(new Student(“马尔扎哈”, 10),”上海”); // 3 遍历集合 Set> entries = studentStringMap.entrySet(); for (Map.Entry entry : entries) { Student key = entry.getKey(); String value = entry.getValue(); System.out.println(key+”,”+ value); }}}
Student{name=’马尔扎哈’, age=10},上海
Student{name=’古力娜扎’, age=20},上海
Student{name=’迪丽热巴’, age=18},上海
重写方法之后才会具有去重效果！

LinkedHashMap类对象

public class LinkedHashMapTest { public static void main(String[] args) { LinkedHashMapmap=new LinkedHashMap<>(); // 2 添加元素 map.put(“C”,””); map.put(“A”,””); map.put(“B”,””); map.put(“B”,””); map.put(“A”,””); // 3 遍历集合 System.out.println(“map = “ + map);//map = {C=, A=, B=} //特点： 去重 序！ 底层采用的数据结构 : 是链表 + 哈希表。}}

TreeSet自然排序！

package com.itheima.Day06Work;import java.util.Comparator;import java.util.TreeSet;public class TestTeacher { public static void main(String[] args) { TreeSetts=new TreeSet<>(new TeacherComparator()); ts.add(new Teacher(“jack”,19)); ts.add(new Teacher(“luose”,20)); ts.add(new Teacher(“Rose”,17)); ts.add(new Teacher(“james”,22)); for (Teacher t : ts) { System.out.println(“t = “ + t);}}}class TeacherComparator implements Comparator{ @Override public int compare(Teacher o1, Teacher o2) { if(o1.getAge()==o2.getAge()){ return (o1.getName().compareTo(o2.getName())); }else {return o1.getAge()-o2.getAge(); }}}

Tree集合 Integer类型的自然和自定义排序

public class Demo02 { public static void main(String[] args) { TreeSetts1=new TreeSet<>(); Random sc=new Random(); for (int i = 0; i < 10; i++) { int number= sc.nextInt(51); ts1.add(number); } System.out.println(“ts1 = “ + ts1); //上半部分自然排序 也就是升序！ TreeSetts2=new TreeSet<>(new Comparator() { @Override public int compare(Integer o1, Integer o2) { return o1-o2; } @Override public boolean equals(Object obj) { return false;}}); for (int i = 0; i < 10; i++) { int nimber=sc.nextInt(51)+50; ts2.add(nimber);} System.out.println(“ts2 = “ + ts2);}} //下半部分自定义排序！可升可降！
注意 ：自定义排序的变量名和方法名一起定义！

Collection集合 单列集合

Lisy(有索引，有序，可重复)

ArrayList 数组 （查询快，增删慢）

LinkedList 链表 （查询慢，增删快）

Set（无序 无索引 不可重复）

HashSet 哈希表（去重无序）

|- -linkedHashSet（去重，有序）

TreeSet （去重 ，可排序）

Map双列集合

HashMap（去重无序）

|- —— LinkedHashMap（去重，有序）
（键不可以重复，值可以重复！）
TreeMap（去重 ，可排序）

Shuffle乱序只有list集合可以使用！
ListarrayList=new ArrayList<>(); arrayList.add(10); arrayList.add(12); arrayList.add(13); arrayList.add(14); arrayList.add(113); arrayList.add(15); Collections.shuffle(arrayList); System.out.println(“arrayList = “ + arrayList);
//输出结果arrayList = [13, 10, 12, 14, 113, 15]

ArrayList集合的迭代器使用！iterator

ArrayListlist=new ArrayList();list.add(“A”);list.add(“B”);list.add(“C”);list.add(“D”);list.add(“E”);Iterator it = list.iterator();while (it.hasNext()){ System.out.println(it.next()+” “); //A B C D E }
利用迭代器删除元素
ArrayListlist=new ArrayList<>();list.add(10);list.add(23);list.add(123);list.add(1023);list.add(1234);Iterator it = list.iterator();while (it.hasNext()){ Integer i = it.next(); if(i<200){ it.remove(); }}System.out.println(“list = “ + list); //list= 123 1023 1234

字符串类型同样可取！
list.add(“ok”);list.add(“pl”);list.add(“ok”);list.add(“wqd”);list.add(“qw”);Iterator it = list.iterator();while (it.hasNext()){ String next = it.next(); if(next==”ok”){ it.remove(); }}System.out.println(“list = “ + list); //list = [pl, wqd, qw]

字符类型通过lambda表达式 实现降序！
public class Demo04 {
_public static void main(String[] args) {
List<_String_> list = new ArrayList<>();
Collections._addAll(_list, “cab”, “bac”, “acb”, “cba”, “bca”, “abc”)_;

    Collections._sort(_list, new Comparator_<_String_>() {<br />            _@Override<br />            public int compare_(_String o1, String o2_) {<br />                _return o2.compareTo_(_o1_)_;<br />            _}<br />        })_;<br />        System._out_.println_(_"list = " + list_)_;<br />    _}_

随机生成10个不同的0~50之间的整数，要求按照从小到大进行遍历。
随机生成10个不同的50~100之间的整数，要求按照从大到小进行遍历。
public class Demo01 {
_public static void main(String[] args) {
TreeSet<_Integer_> ts = new TreeSet<>();
Random rc = new Random();
for (int i = 0; i < 10; i++) {
int number = rc.nextInt(51);
ts.add(number);
}
System._out.println(“ts = “ + ts);

TreeSet是具有排序特性的默认按照自然排序。如果自然排序满足不了需求，可以使用自定义比较器。
TreeSet<_Integer> ts2 = new TreeSet<>(new Comparator<>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});

for (int i = 0; i < 10; i++) {
int nem1=rc.nextInt(51)+50;__ //复杂写法 int numbe1=(int)(50+Math.random()*(100-50+1)); 随机数生成控制范围！
ts2.add(_numbe1);
}
System._out.println(“ts2 = “ + ts2);
}
}

1 TreeSet介绍

TreeSet 集合是Set接口的一个实现类，底层依赖于TreeMap，是一种基于红黑树结构的实现，具有以下特点：

元素去重

元素没有索引

元素有排序

TreeSet元素的排序规则，使用元素的自然排序规则，或者根据创建 TreeSet 时提供的 Comparator 比较器进行排序

具体取决于使用的构造方法：

*public TreeSet()：根据其元素的自然排序进行排序
public TreeSet(Comparator comparator)：根据指定的比较器进行排序

2 TreeSet自然排序实践

一个类只要实现了接口Comparable就具备自然排序能力。

3 TreeSet自定义排序实践

TreeSet可以实现自定义比较器排序，需要使用自定义比较器的构造方法，可以用来存储不具备自然排序能力的数据，也可以用来覆盖自然排序规则。

public TreeSet(Comparator comparator)：根据指定的比较器进行排序

Comparator 是一个接口，我们需要去实现一个抽象方法compare，我们可以直接定义匿名内部类去实现该方法：

public int compare(E o1,E o2){

Return This.age - *o.age; //升序*

// 或者

*return o.age - this.age; //降序V
}

口诀：升序就是1减2，降序就是2减1

1表示第一个参数，2表示第二个参数

E 如果是数值类型， o1和o2可以直接相减。如果是自定义类型或者其他非数值类型，不能直接相减，应该将对象中要进行排序的属性值拿出来进行比较相减

例如：集合中存储的是学生对象，要求按照学生的年龄升序排序

  ***return o1.getAge()-o2.getAge();***

*整数类型Integer是具有自然排序升序排序功能的，可以自定义比较器降序覆盖原有自然排序。*

*自定义类型Student类型，不具备自然排序功能，需要自定义比较器进行实现功能*

*TreeSet集合*

TreeSet去重和equals无关。

TreeSet集合底层结构是什么有什么特点：

底层结构是红黑树，具有去重，排序特点

TreeSet集合如何实现自定义比较器排序：

在创建TreeSet集合的时候，指定Comparator比较器，重写compare方法

升序：o1-o2 返回值用this 减去里面存的数据，如果是复数说明比里面的小，往左边排

降序：o2-o1 如果减去里面的数据有余数说明大，往右边存，等于0就不会存 里面有！

Collections工具类

1 Collections工具类介绍

java.util.Collections 是集合的工具类，里面提供了静态方法来操作集合，乱序，排序….

shuffle方法

public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。

使用该方法需要注意的：

乱序只能对List集合进行乱序

集合中元素类型可以任意类型

Collections的shuffle是什么功能:

打乱List集合顺序

shuffle方法使用要注意什么？

(List<?> list)

1.只能打乱List集合

2.集合中的元素可以任意类型

         ***排序方法sort***

概念：

*sort方法是一个重载的方法，可以实现自然排序及自定义比较器排序。要特别注意的是sort方法只能对List集合进行排序。*

public static > void sort (List list)

public static void sort (List list, Comparator<? super T> c)

2 Collections的sort自然排序

public static > void sort (List list) 按照原始自然排序

方法分析：

该方法只能对List集合进行排序

从方法中泛型分析可知，集合中元素类型必须是Comparable的子类型。

3 Collections的sort自定义排序

public static void sort (List list, Comparator<? super T> c)

方法分析：

方法只能对List集合排序

对元素的类型没有要求

需要定义一个比较器Comparator

（规则和之前TreeSet时一样）

使用场景：

List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）

List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需。

*Collections的sort方法只能对什么集合进行排序：*

List集合

*什么时候可以使用自然排序：*

当List集合中元素类型实现了Comparable接口时，就可以使用自然排序

*什么时候可以使用自定义比较器来进行排序：*

List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）

List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需。

可变参数

1 可变参数介绍

在 Java 5 中提供了变长参数，允许在调用方法时传入不定长度的参数。变长参数是 Java 的一个语法糖，本质上还是基于数组的实现，如下：

*void test (String… args);
void test (String[] args );

2 可变参数的定义

在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。

上述定义有几个要点需要注意：

可变参数只能作为方法的最后一个参数，但其前面可以有或没有任何其他参数，因此一个方法最多只能有一个可变参数。

可变参数本质上是数组，不能作为方法的重载。如果同时出现相同类型的数组和可变参数方法，是不能编译通过的。可变参数可以兼容数组，反之则不成立。

4 Collections的addAll方法

static boolean addAll(Collection<? super T> c, T… elements) 添加任意多个数据到集合中

分析： 该方法就是一个含有可变参数的方法，使用时可以传入任意多个实参，实用方便！

*怎么给方法定义可变参数：*

在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。

*含有可变参数的方法怎么使用：*

方法内部使用：直接当做数组使用

调用方法时：可以传入该类型的数组，也可传入该类型任意多个数据

            ***排序查找算法***

1 冒泡排序介绍

冒泡排序（Bubble Sort）算法描述：比较相邻两个元素大小，如果反序，则交换。若按升序排序，每趟将数据序列中的最大元素交换到最后位置，就像气泡从水里冒出一样。若按降序排序则相反。

*简要描述什么是冒泡排序：*

比较相邻两个元素大小，如果反序，则交换

*代码实现冒泡排序时有什么规律：*

有n个元素，那么就要比较n-1趟。

每一趟中都会选出一个最值元素，较前一趟少比较一次。

选择排序

1 选择排序介绍

选择排序（Selection Sort）算法描述：它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

*描述选择排序的工作原理：*

它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

代码实现选择排序时有什么规律？

有n个元素，那么就要比较n-1趟。

每一趟中都会选出一个最值元素，较前一趟少比较一次。

          ***二分查找***

1 二分查找介绍

二分查找，用来查询搜索定位。比如要定位一个元素在数组中的索引位置。前提条件：要求被查询的数组，集合必须有升序排序；

2 二分查找原理分析

二分查找的原理，每次查找最中间的元素，对比中间元素的值与被查找元素的值大小。

1. 刚好相同，找到了结束

2. 如果要找的元素比中间元素小了。将查找的范围缩小到中间的左边一般。继续二分查找

*3.如果要找的元素比中间元素大了。将查找的范围缩小到中间的右边一般。继续二分查找*

直到找到位置，如果最没有找到返回-1 。

数组要实现二分查找的前提条件：

数组必须是有排序的

*描述二分查找的实现原理：*

二分查找的原理，每次查找最中间的元素，对比中间元素的值与被查找元素的值大小。

刚好相同，找到了结束

如果要找的元素比中间元素小了。将查找的范围缩小到中间的左边一般。继续二分查找

如果要找的元素比中间元素大了。将查找的范围缩小到中间的右边一般。继续二分查找

直到找到位置，如果最没有找到返回-1 。

        ***Map集合介绍***

1 Map集合概述

*java.util.Map 集合，里面保存的数据是成对存在的，称之为双列集合。存储的数据，我们称为键值对。 之前所学的Collection集合中元素单个单个存在的，称为单列集合。*

2 Map集合特点介绍

Map K：键的数据类型；V：值的数据类型

1.键不能重复，值可以重复

2.键和值是 一 一 对应的，通过键可以找到对应的值

3.（键 + 值） 一起是一个整体 我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”。

使用场景：凡是要表示一一对应的数据时就可以。

举例1：学生的学号和姓名

itheima001 小智

举例2：夫妻的关系

王宝强 马蓉

谢霆锋 张柏芝

3 常用实现类

HashMap：

此前的HashSet底层实现就是HashMap完成的，HashSet保存的元素其实就是HashMap集合中保存的键，底层结构是哈希表结构，具有去重，无序，特点。

LinkedHashMap：

底层结构是有链表和哈希表结构，去重，有序

TreeMap：

底层是有红黑树，去重，排序

4 Map中常用的方法

*- public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
- public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
- public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
- public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
- public boolean containKey(Object key):判断该集合中是否有此键。

*Map集合有什么特点:*

*1.键不能重复，值可以重复*

*2.键和值是 一 一 对应的，通过键可以找到对应的值*

Map *常见的实现类**:*

HashMap，LinkedHashMap，TreeMap

*Map常用的方法:*

put,get,remove,keyset,containsKey，entrySet

Map集合的遍历方式

1 遍历概述

Map集合既不能使用索引来遍历，也不能使用迭代器遍历，如果要进行对Map集合遍历，可以有两种方式：

1 先获取所有的键，遍历键去查找对应的值

2 可以先获取所有的键值对对象，通过键值对对象来遍历

2 键找值方式遍历

操作步骤：

先通过keySet获取所有的键

遍历所有的键，通过键找到值

3 键值对对象遍历

Map中存在Entry接口用来表示键值对对象。

*interface Map{
interface Entry{ // 表示某个键值对*
K getKey();*
V getValue();}}**

要获取所有的键值对Entry对象，需要借助Map方法:

public Set> entrySet()

获取到Map集合中所有的键值对对象的集合(Set集合)。

使用键找值方式遍历的步骤 ：

*1.先通过keySet获取所有的键*

*2.遍历所有的键，通过键找到值*

使用键值对对象方式遍历的步骤

*1.调用map集合的entrySet方法获取所有的键值对对象*

*2.遍历每一个键值对对象（Entry对象）*

*3.getKey获取键，getValue获取值*

        ***HashMap存储自定义类型键***

1 HashMap介绍

HashSet中所存储的值，其实底层就放置在HashMap的键当中。底层使用哈希表结构来存储数据，存放数据时会执行hashCode和equals方法来去重。

因此，HashMap使用自定义类型当做键使用时要也要注意： 自定义类型需要重写hashCode和equals方法

*HashMap存储自定义类型的键要注意事项：*

要达到去重效果，需要重写hashCode和equals方法

        ***LinkedHashMap**集合*

LinkedHashMap是LinkedHasSet的底层实现。在最底层采用的数据结构，是链表+哈希表。

特点：

去重，有序

TreeMap集合

TreeMap的底层是红黑树实现的，有排序的能力，键去重。

可以自然排序（元素类型要实现Comparable）

可以自定义比较器排序（Comparator）若自定义类型没有自然排序功能，或自然排序功能不满足要求时使用。

两种排序方式对应了TreeMap的两个构造方法：

*public TreeMap() 使用自然排序
public TreeMap(Comparator<? super K> comparator) 比较器排

请问TreeMap集合特点：

去重，排序

TreeMap的排序方式支持方式：

自然排序

自定义比较器排序

TreeSet示例：

Student类！

public class Student *implements Comparable {*
private String name;*
private int age;**

*@Override
public int compareTo(Student o) {
// return this.age-o.age; 升序*
return o.age-this.age; 降序*
}

测试类：

*public class ComparableDemo2 {
public static void main(String[] args) {*
TreeSetts=new TreeSet<>();*
ts.add(new Student(“张三“,20));*
ts.add(new Student(“*李四“,18));
ts.add(new Student(“赵六“,16));*
ts.add(new Student(“*和二“,15));
for (Student s1:ts){*
System.out.println(“s1 = “ + s1);*
}}}**

Shuffle示例：

*Listlist=new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
list.add(40);
*System.out.println(“list = “ + list); //list = [10, 20, 30, 40]*
*// 2 添加元素*
*Collections.shuffle(list); //*乱序功能打乱last中的集合！ 只能打乱list集合！
System.out.println(“list = “ + list); // list = [30, 10, 40, 20]**

              ***Sort示例：***

*ArrayList list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
list.add(5);
list.add(4);
*System.out.println(“list = “ + list); //list = [1, 3, 2, 5, 4]*

Collections.sort(list); *//*升序 Collectons.sort(*变量名);
*System.out.println(“list = “ + list); //list = [1, 2, 3, 4, 5]*

*Collections.sort(list, new Comparator() {
@Override*
public int compare(Integer o1, Integer o2) {*
return o2-o1;*
}});*
*System.out.println(“list = “ + list); //list = [80, 45, 30, 15, 10]降序方法*

}}

             ***Sort的可变参数示例：***

*public class Test {
public static void main(String[] args) {*
System.out.println(sum(1, 2, 3, 4));*
System.out.println(sum(1, 2, 3));*
}*

*//可变参数当成数组用，可变参数本质上就是数组可以用索引来访问
public static int sum(int…num){*
int sum = 0;*
for (int i : num) {*
sum += i;*
}*
return sum;*
}*
//*任意类型都可以定义可变参数！*
public static void Test(*ArrayList…list){
}**

*Collections的addAll方法*

使用：addAll可以直接传入任意多个实参！

*public static void main(String[] args) {
ArrayList list = new ArrayList<>();*
Collections.addAll(list, “a”, “b”, “c”, “d”);*
System.out.println(list); //list=[a, b, c, d]
}
public static void addElement(List list, T… t) {*
for (T element : t) {*
list.add(element);*
}*
}

          冒泡排序

*public class SortDemo {
public static void main(String[] args) {*
int[] arr = {5, 4, 3, 2, 1};*
for (int j = 0; j < arr.length - 1; j++) { // -1为了防止索引越界
for (int i = 0; i < arr.length - 1 - j; i++) {*
if (arr[i] > arr[i + 1]) { /*/升序大于号 降序小于号
int temp = arr[i];*
arr[i] = arr[i + 1];*
arr[i + 1] = temp;*
}*
}*
}*
System.out.println(Arrays.toString(arr));**

选择排序

示例：

*public class SortDemo {
public static void main(String[] args) {*
int[] arr = {55, 11, 44, 22, 33};*
int time = arr.length - 1; // 遍历数组*
for (int i = 0; i < time; i++) { //*次数*
int minIdnex = i; //*临时定义最小值的变量*
for (int j = i + 1; j < arr.length; j++) {*
if (arr[minIdnex] > arr[j]) {**

*//剩余未排序的元素中找到最小的索引位置！*
minIdnex = j;*
}*
}*
if (minIdnex != i) { //将最小的数据与i位置的数据进行交换
int temp = arr[i]; //i*位置的元素 minIndex*元素比较*
arr[i] = arr[minIdnex];*
arr[minIdnex] = temp;*
}*
}*
System.out.println(Arrays.toString(arr));*//[11, 22, 33, 44, 55]
}
}**

二分查找步骤

*public class BinarySearchDemo {
public static void main(String[] args) {*
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};*
//如果有相同元素只能找到其中一个元素。
System.out.println(binarySearch(arr, 9));*
}*
// 方法的功能是 , 接收一个数组和一个元素 , 返回此元素在数组中出现的索引*
public static int binarySearch(int[] arr, int num) {*
// 1，定义两个变量，表示要查找的范围。默认min = 0 ， max = 最大索引*
int min=0;*
int max=arr.length-1;*
// 2*，循环查找，但是min <= max
while (min<=max){*
// 3*，计算出mid的值*
int mind=(max+min)/2;*
// 4，判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
if(arr[mind]==num){*
//*找到数据返回*
return mind;*
}else if(num<arr[mind]){**

*//5，如果要查找的值在mid的左半边那么min值不变，max = mid -1.继续下次循环查找*
max=mind-1;*
}else if(num>arr[mind]) {**

*//6，如果要查找的值在mid的右半边那么max值不变，min = mid + 1.继续下次循环查找*
min=mind+1;*
}}*
// min > max*
return -1;*
}*
}

Map集合常用方法

*public class MapDemo1 {
public static void main(String[] args) {*
Map map = new HashMap<>();*
//public V put(K key, V value): 把指定的键与指定的值添加到Map集合中*
//put*返回原来键所对应的值， 返回null
String put = map.put(“文章“, “马伊利“);*
System.out.println(“put = “ + put);//null put*返回原来键所对应的值， 返回null
put = map.put(“文章“, “姚笛“);*
System.out.println(“put = “ + put);//put = 马伊利*
System.out.println(“map = “ + map);*
map.put(“*谢霆锋“,”张柏芝“);
map.put(“陈冠希“,”张柏芝“);*
map.put(“*李亚鹏“,”王菲“);
System.out.println(“map = “ + map);

//public V remove(Object key):**

***把指定的键 所对应的键值对元素 在**Map****集合中删除，返回被删除元素的值****<br />***    ***String remove = map.remove("****陈冠希****");****<br />***    ***System.out.println("remove = " + remove);//remove =*** ***张柏芝****<br />***    ***System.out.println("map = " + map);****

*//map = {文章=姚笛*, 谢霆锋*=张柏芝, 李亚鹏=王菲}
*
// public V get(Object key) 根据指定的键，在*Map集合中获取对应的值
String get = map.get(“文章“);//get = 姚笛*
System.out.println(“get = “ + get);*
System.out.println(“map = “ + map);**

*//map = {文章=姚笛*, 谢霆锋*=张柏芝, 李亚鹏=王菲}
//public boolean containKey(Object key): 判断该集合中是否有此键*
boolean containsKry= map.containsKey(“*李亚鹏“);
System.out.println(“containsKry = “ + containsKry);

}
}**

Map集合的遍历

方法一：

*public class MapDemo2 {
public static void main(String[] args) {*
// 1 创建集合对象*
Map map = new HashMap<>();*
// 2 添加元素*
map.put(“周瑜“, “小乔“);*
map.put(“*孙策“, “大乔“);
map.put(“刘备“, “孙尚香“);*
map.put(“*诸葛亮“, “黄月英“);
// 3 遍历集合*
//*获取所有 键*
Set keys = map.keySet();*
for (String key : keys) {*
String str = map.get(key);*
System.out.println(key + “,” + str);*
}*
}
}**

方法二：

*public class MapDemo3 {
public static void main(String[] args) {*
// 1 创建集合对象*
Map map = new HashMap<>();*
// 2 添加元素*
map.put(“射手“, “孙尚香“);*
map.put(“*战士“, “孙策“);
map.put(“法师“, “周瑜，诸葛亮“);*
map.put(“*打野“, “刘备“);
map.put(“辅助“, “大乔“);**

***//**获取所有键值对对象！*

*生成方法 ：Map.entrySet().var
Set> entries = map.entrySet();*
// 3 遍历集合*
生成方法 ：entries.for
for (Map.Entry entry : entries) {*
String key = entry.getKey(); //*获取键 getKey() : 获取键*
String value = entry.getValue(); //*获取值 getValue() : 获取值*
System.out.println(key+”,”+value);*

//输出： 刘备,孙尚 香孙策,大乔 诸葛亮,黄月英 *周瑜,大乔*

 ***//键不能重复，值可以重复 也就是后面的数值可以重复出现！但是前面的不行！***

}}}

         ***哈希Map重写后方法！***

只要是用哈希表存储数据要达到去重效果都要重写 *haxCode和equlas**方法！*

*public class HashMapTest1 {
public static void main(String[] args) {*
// 1 创建*HashMap集合对象
MapstudentStringMap=new HashMap<>();*
// 2 添加元素*
studentStringMap.put(new Student(“迪丽热巴“, 18),”上海“);*
studentStringMap.put(new Student(“*古力娜扎“, 20),”上海“);
studentStringMap.put(new Student(“马尔扎哈“, 10),”上海“);*
studentStringMap.put(new Student(“*马尔扎哈“, 10),”上海“);
// 3 遍历集合*
Set> entries = studentStringMap.entrySet();*
for (Map.Entry entry : entries) {*
Student key = entry.getKey();*
String value = entry.getValue();*
System.out.println(key+”,”+ value); }}}*

Student{name=’马尔扎哈’, age=10},上海

Student{name=’古力娜扎’, age=20},上海

Student{name=’迪丽热巴’, age=18},上海

重写方法之后才会具有去重效果！

      ***LinkedHashMap**类对象*

*public class LinkedHashMapTest {
public static void main(String[] args) {*
LinkedHashMapmap=new LinkedHashMap<>();*
// 2 添加元素*
map.put(“C”,””);*
map.put(“A”,””);*
map.put(“B”,””);*
map.put(“B”,””);*
map.put(“A”,””);*
// 3 遍历集合*
System.out.println(“map = “ + map);//map = {C=, A=, B=} //*特点： 去重 序！ 底层采用的数据结构 : 是链表 + 哈希表。}}

           ***TreeSet自然排序！***

*package com.itheima.Day06Work;
import java.util.Comparator;
import java.util.TreeSet;
public class TestTeacher {
public static void main(String[] args) {*
TreeSetts=new TreeSet<>(new TeacherComparator());*
ts.add(new Teacher(“jack”,19));*
ts.add(new Teacher(“luose”,20));*
ts.add(new Teacher(“Rose”,17));*
ts.add(new Teacher(“james”,22));*
for (Teacher t : ts) {*
System.out.println(“t = “ + t);}}}*
class TeacherComparator implements Comparator{
@Override*
public int compare(Teacher o1, Teacher o2) {*
if(o1.getAge()==o2.getAge()){*
return (o1.getName().compareTo(o2.getName()));*
}else {
return o1.getAge()-o2.getAge(); }}}

Tree集合 Integer类型的自然和自定义排序

*public class Demo02 {
public static void main(String[] args) {*
TreeSetts1=new TreeSet<>();*
Random sc=new Random();*
for (int i = 0; i < 10; i++) {*
int number= sc.nextInt(51);*
ts1.add(number);*
}*
System.out.println(“ts1 = “ + ts1); //上半部分自然排序 也就是升序！*
TreeSetts2=new TreeSet<>(new Comparator() {*
@Override*
public int compare(Integer o1, Integer o2) {*
return o1-o2;*
}*
@Override*
public boolean equals(Object obj) {*
return false;}});*
for (int i = 0; i < 10; i++) {*
int nimber=sc.nextInt(51)+50;*
ts2.add(nimber);}*
System.out.println(“ts2 = “ + ts2);}} //下半部分自定义排序！可升可降！*

注意 ：自定义排序的变量名和方法名一起定义！

Collection集合 单列集合

Lisy(有索引，有序，可重复)

ArrayList 数组 （查询快，增删慢）

LinkedList 链表 （查询慢，增删快）

Set（无序 无索引 不可重复）

HashSet 哈希表（去重无序）

|- -linkedHashSet（去重，有序）

TreeSet （去重 ，可排序）

Map双列集合

HashMap（去重无序）

|- —— LinkedHashMap（去重，有序）

           ***（键不可以重复，值可以重复！）***

TreeMap（去重 ，可排序）

Shuffle乱序只有list集合可以使用！

*ListarrayList=new ArrayList<>();
arrayList.add(10);*
arrayList.add(12);*
arrayList.add(13);*
arrayList.add(14);*
arrayList.add(113);*
arrayList.add(15);*
Collections.shuffle(arrayList);*
System.out.println(“arrayList = “ + arrayList);*

*//输出结果arrayList = [13, 10, 12, 14, 113, 15]*

     ***ArrayList集合的迭代器使用！**iterator*

*ArrayListlist=new ArrayList();
list.add(“A”);
list.add(“B”);
list.add(“C”);
list.add(“D”);
list.add(“E”);
Iterator it = list.iterator();
while (it.hasNext()){
System.out.println(it.next()+” “); //A B C D E
}

利用迭代器删除元素

*ArrayListlist=new ArrayList<>();
list.add(10);
list.add(23);
list.add(123);
list.add(1023);
list.add(1234);
Iterator it = list.iterator();
while (it.hasNext()){
Integer i = it.next();*
if(i<200){*
it.remove();*
}*
}
*System.out.println(“list = “ + list); //list= 123 1023 1234*

字符串类型同样可取！

*list.add(“ok”);
list.add(“pl”);
list.add(“ok”);
list.add(“wqd”);
list.add(“qw”);
Iterator it = list.iterator();
while (it.hasNext()){
String next = it.next();*
if(next==”ok”){*
it.remove();*
}*
}
*System.out.println(“list = “ + list); //*list = [pl, wqd, qw]**