Java——集合（合集，简单的概括）

JAVA ——集合

集合
- 概念：
- 1 、Collection接口与Iterator接口
- 2 、Collection<>接口
- 3 、 List<>接口
- - 3 .1 ArrayList<>类
  - 3.2 LinkedList<>类
- 4 、 Set<>接口
- - 4.1 HashSet类
- 4 、 Map<>接口(键/值映射)
- 5 、 HashMap

分享最近听到的几首歌曲山海 ——万豹孤独——王佳杨不知所措是想你的声音啊我很好——刘大壮厚颜无耻——那些你冒险的梦

集合

概念：

在面向对象编程中，用类来描述数据结构，同时包含对该数据结构的操作的方法。在Java中对常用的数据结构和算法做的一些接口与实现接口的类，通过这些方法抽象出来的数据结构和操作称为集合。它主要由一组用来操作对象的接口组成，不同接口描述不同数据的类型。核心主要接口有Collection、List、Set和Map。理解了接口就间接的理解了集合这框架。集合由对象元素组成，因此允许类型不同，个数也可以动态的增减，与数组的差异巨大，后面对集合和数组进行一个对比总结。

1 、Collection接口与Iterator接口

collection接口是层次接口的跟接口，是构造集合框架的基础，可以用于表示任何对象或者元素数组。构成collection的单位被称为元素。collection的接口不能直接使用，但是接口提供了添加，删除等管理数据的方法。它有两个派生接口分别是List与Set。List实现java.util.List接口的相关类，在容器中顺序排列对象。Set接口实现java.util.Set相关类，不接受重复对象，拥有自己的一套无序排列规则。
如何遍历Collection中的数据，在Collection中的所有类型所实现的接口都只有一个——Iterator方法，使用Iterator方法来返回一个实现Iterator接口的对象。Itera-tor对象是一个集合的迭代器，用于实现对容器内部数据的遍历操作，它不关心集合的实现。

Iterator接口定义方法有：boolean hasNext();//是否还有下一个元素Object next(); //返回下一个元素void remove(); //删除当前元素
//为什么要提这个，因为接下来的学习中需要它

2 、Collection<>接口

Collection接口是List接口与Set接口的父接口，通常不能被直接使用，但在Collection接口中定义了许多方法，通过这些方法对集合实现基本操作。

Collection接口定义的常用方法：boolean add()：添加元素（一次一个）。boolean addAll()：把小集合添加到大集合中 。boolean contains() ： 如果此 collection 包含指定的元素，则返回 true。boolean isEmpty() ：如果此 collection 没有元素，则返回 true。Iterator<E> iterator()：返回在此 collection 的元素上进行迭代的迭代器。boolean remove() ：从此 collection 中移除指定元素的单个实例。boolean removeAll() ：从此 collection 中移除指定元素的多个实例。boolean retainAll(): 保留指定集合中的元素，不同的会被删除void clear();直接将元素集合清空int size() ：返回此 collection 中的元素长度（个数）。Objec[] toArray()：返回对象数组Iterator iterator()：取出元素的方式

//一个栗子：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;//测试 collection 接口
public class Text_Collection {public static void main(String[] args) {//创建对象Collection co = new ArrayList();//调用方法System.out.println(co.add(1));//写入整形1co.clear();//清除所有元素System.out.println(co.add(3));System.out.println(co.add(4));System.out.println(co.contains(3));//检查是否包含此元素System.out.println(co.equals(3));//判断与指定对象是否相等System.out.println(co.hashCode());//返回哈希值System.out.println(co.isEmpty());//判断是否为空System.out.println(co.remove(3));//移除3这个元素System.out.println(co.size());//获取集合的长度/元素的个数Object[] os = co.toArray();//将co的数据存入object集合//集合间的操作Collection co1 = new ArrayList();co1.add(123);System.out.println(co.addAll(co1));//将co1加入coSystem.out.println(co.containsAll(co1));//co1在co里？判断System.out.println(co.removeAll(co1));//移除co1的元素与co的元素的交集
//        System.out.println(co.retainAll(co1));//保留co1的元素与co的元素的交集Collection co2 = new ArrayList();co2.add(123);co2.add(124);co2.add(126);Iterator it = co2.iterator();while (it.hasNext()){//判断是否有元素Object o = it.next();//获取元素System.out.println(o);}}
}

3 、 List<>接口

List集合包括List接口与实现List接口的所有实现类。在List集合中，允许元素重复存放。数据是有序的，数据的顺序就是对象插入的顺序。每一个数据都是有索引的，类似于数组却不同于数组，因此可以对列表中的每个元素精确控制。List是接口不能以自己来实现自己，只能通过派生类来实现自己。

List继承了Collection接口，List拥有Collection接口提供的功能，不同的是List是列表类型，还拥有了适合于自己的一些常用方法。

常用方法有：
ListIterator<E> listIterator()==>返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E> listIterator(int index)==>返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
void add(int index, E element)==>在列表的指定位置插入指定元素（可选操作）。
boolean addAll(int index, Collection<? extends E> c)==>将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
List<E> subList(int fromIndex, int toIndex)==> 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
E get(int index)==> 返回列表中指定位置的元素。
int indexOf(Object o)==>返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
E set() ==>数据元素替换

然实现List<>接口的集合类有ArrayList<>、LinkedList 、Vector<>、Stack<>等，这些类的对象均可以调用List的方法，按照索引进行增删查。

展示List类的一个栗子：（包含了对数据的多种遍历）

package list;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;//测试List的常用方法与多种遍历
public class Test_List {public static void main(String[] args) {method();}public  static void method(){//创建对象List<Integer> list = new ArrayList<>();//添加泛型来约束数据元素//调用方法list.add(1);//向容器添加数据元素list.add(2);list.add(3);list.add(4);list.add(5);list.add(6);System.out.println(list.add(7));//返回boolean显示是否添加成功System.out.println(list);//[1, 2, 3, 4, 5, 6, 7]list.add(1,8);//在下标为1处添加数据元素8System.out.println(list.get(6));//根据下标获取元素并返回System.out.println(list.indexOf(6));//获取数据元素第一次出现的下标位置System.out.println(list.lastIndexOf(6));//获取数据元素最后一次出现的下标位置System.out.println(list.remove(4));//移除下标为4的数据元素System.out.println(list.set(2, 520));//替换下标为2元素System.out.println(list);//[1, 8, 520, 3, 5, 6, 7]//集合的多种遍历结构//1、基本的下标遍历System.out.print("1、基本的下标遍历：");for (int i = 0; i < list.size(); i++) {System.out.print(list.get(i)+",");}System.out.println();//换行显示//2、增强for遍历System.out.print("2、增强for遍历");for (Integer integer :  list){System.out.print(integer+",");}System.out.println();//3、Collection提供的IteratorSystem.out.print("3、继承Collection提供的Iterator<>:");Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()){System.out.print(iterator.next()+",");}System.out.println();//4、List自己扩展的ListIterator（正序遍历）System.out.print("4、List自己扩展的ListIterator（正序遍历）：");ListIterator<Integer> listIterator = list.listIterator();while (listIterator.hasNext()){System.out.print(listIterator.next()+",");}System.out.println();//5、List自己扩展的ListIterator（反序遍历）System.out.print("5、List自己扩展的ListIterator（反序遍历）：");ListIterator<Integer> listIterator1 = list.listIterator();while (listIterator.hasPrevious()){System.out.print(listIterator.previous()+",");}/**结果输出* 1、基本的下标遍历：1,8,520,3,5,6,7,* 2、增强for遍历1,8,520,3,5,6,7,* 3、继承Collection提供的Iterator<>:1,8,520,3,5,6,7,* 4、List自己扩展的ListIterator（正序遍历）：1,8,520,3,5,6,7,* 5、List自己扩展的ListIterator（反序遍历）：7,6,5,3,520,8,1,*/}
}

3 .1 ArrayList<>类

ArrrayList<>实现了可变的数组，允许所有元素包括null，可以根据索引位置对集合进行快速的访问。ArrayList类实现的List集合采用了数组结构来保存对象（封装了数组），内部数组默认初始容量为10，如果长度不够则以1.5倍的容量去增长。因此对于索引查询在这方面效果比其他的类更好。但是在增删动作上，ArrayList需要对数组元素重新调整索引顺序，就表现的非常的乏力了，只能说能完成这一个动作，却没有任何的优势。

new ArrayList()：初始容量是10

一个栗子：（展示实现）

package list;import java.util.ArrayList;
import java.util.Iterator;//练习ArrayList
public class Test_ArrayList {public static void main(String[] args) {//创建对象（）ArrayList<Object> list = new ArrayList<>();//初始容量为10//方法调用（基本就是调用实现List接口的常用方法）list.add(1);list.add("join");list.add(null);list.add('a');System.out.println(list);//[1, join, null, a]Iterator<Object> iterator = list.iterator();//封装了下标while (iterator.hasNext()){//判断是否还有下一个数据元素System.out.print(iterator.next()+",");//打印数据元素}//1,join,null,a,}
}

3.2 LinkedList<>类

LinkedList类是List接口的实现类,拥有List接口的所有特点，它是有序、有索引同样可重复、可以存null的一个链表结构，不在是ArrayList类一样的数组结构。
LinkedList底层维护了一个链表的结构，在增删业务方面有良好的特性。同样的在查询这一方面就有了很大的缺陷。

创建对象
--LinkedList()

常用方法：（除了实现List接口的一些常用方法外拓展的一些常用方法）
void addFirst(E e)==> 将指定元素插入此列表的开头。
void addLast(E e) ==>将指定元素添加到此列表的结尾。
boolean offer(E e) ==>将指定元素添加到此列表的末尾（最后一个元素）。
boolean offerFirst(E e) ==>在此列表的开头插入指定的元素。
boolean offerLast(E e) ==> 在此列表末尾插入指定的元素。
E getFirst()==> 返回此列表的第一个元素。
E getLast()==> 返回此列表的最后一个元素。
E remove()==>获取并移除此列表的头（第一个元素）。
E removeFirst()==>移除并返回此列表的第一个元素。
E removeLast()==>移除并返回此列表的最后一个元素。
boolean removeFirstOccurrence(Object o)==>从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
E poll()==> 获取并移除此列表的头（第一个元素）
E pollFirst() ==>获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()==> 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pop() ==> 从此列表所表示的堆栈处弹出一个元素。
void push(E e) ==> 将元素推入此列表所表示的堆栈。

package list;import java.util.Iterator;
import java.util.LinkedList;//测试LinkedList
public class Test_LinkedList {public static void main(String[] args) {//创建对象LinkedList<String> linkedList = new LinkedList<>();//添加数据元素linkedList.add("刘备");linkedList.add("孙尚香");linkedList.add("刘禅");linkedList.add("关羽");linkedList.add("张飞");System.out.println("原始数据元素："+linkedList);//原始数据元素：[刘备, 孙尚香, 刘禅, 关羽, 张飞]method(linkedList);//常用方法调用LinkedList<Integer> linkedList1 = new LinkedList<>();for (int i = 0; i < 10000; i++) {linkedList1.add(i);}method1(linkedList1);//体现在两个遍历方法的优越性（本身就慢！）}private static void method(LinkedList<String> linkedList) {//添加收尾数据元素的两套API//1、add 无返回值linkedList.addFirst("刘备爹爹");linkedList.addLast("刘禅儿子");System.out.println(linkedList);//[刘备爹爹, 刘备, 孙尚香, 刘禅, 关羽, 张飞, 刘禅儿子]//2、offer 有返回值System.out.println(linkedList.offerFirst("刘备爷爷"));//加入成功返回true，失败返回falseSystem.out.println(linkedList.offerLast("刘禅孙子"));//加入成功返回true，失败返回falseSystem.out.println(linkedList);/*** true* true* [刘备爷爷, 刘备爹爹, 刘备, 孙尚香, 刘禅, 关羽, 张飞, 刘禅儿子, 刘禅孙子]*/System.out.println(linkedList.getFirst());//返回列表的第一个数据元素System.out.println(linkedList.getLast());//返回列表的最后一个元素System.out.println(linkedList);//移除首尾元素的两套APIlinkedList.removeFirst();//移除并返回此列表的第一个元素。linkedList.removeLast();//移除并返回此列表的最后一个元素。System.out.println(linkedList);//[刘备爹爹, 刘备, 孙尚香, 刘禅, 关羽, 张飞, 刘禅儿子]linkedList.pollFirst();//>获取并移除此列表的第一个元素；如果此列表为空，则返回 null。linkedList.pollLast();//> 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。System.out.println(linkedList);//[刘备, 孙尚香, 刘禅, 关羽, 张飞]System.out.println(linkedList.removeFirstOccurrence("关羽"));//从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。System.out.println(linkedList);//[刘备, 孙尚香, 刘禅, 张飞]}private static void method1(LinkedList<Integer> linkedList) {//体现在两个遍历方法的优越性（本身就慢！）//1、下标遍历long time = System.currentTimeMillis();//获取当前时间for (int i = 0; i < linkedList.size(); i++) {Integer a = linkedList.get(i);}System.out.println("下标遍历的时间："+ (System.currentTimeMillis() - time));//打印时间差//2、迭代器遍历long time1 = System.currentTimeMillis();Iterator<Integer> iterator = linkedList.listIterator();while (iterator.hasNext()){Integer a = iterator.next();}System.out.println("迭代遍历的时间："+ (System.currentTimeMillis() - time1));//打印时间差/*** 下标遍历的时间：57* 迭代遍历的时间：1*/}
}

4 、 Set<>接口

Set集合为集类型，集是最简单的一种集合。存在在集中的对象不安特定的方式去排序（无序排列，没有下标），并且在Set集中不存在重复对象。Set集合包括了Set接口以及实现Set接口的所有实现类。它同样继承与Collection，所有也拥有Collection接口提供的所有方法。

创建对象：  Set set = new HashSet ();//接口不能自身实现，同过调用子类来实现

常用方法：
boolean add(E e)：添加元素。
boolean addAll(Collection  c)：把小集合添加到大集合中 。
boolean contains(Object o) ： 如果此 collection 包含指定的元素，则返回 true。
boolean isEmpty() ：如果此 collection 没有元素，则返回 true。
Iterator<E> iterator()：返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o) ：从此 collection 中移除指定元素的单个实例。
int size() ：返回此 collection 中的元素数。
Objec[] toArray()：返回对象数组

package set;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;//测试Set
public class Test_Set {public static void main(String[] args) {//创建对象Set set = new HashSet();set.add("hello");set.add("b");set.add("a");set.add("world");set.add("b");//不存重复元素，元素无序System.out.println(set);//[a, b, world, hello]  添加了5个元素，1个重复，只存入了不重复的4个//迭代遍历Iterator it = set.iterator();while(it.hasNext()) {System.out.print(it.next()+",");}//a,b,world,hello,}
}

Set接口常用的实现了有HashSet类和TreeSet类，这里仅说一下HashSet类。

4.1 HashSet类

HashSet的排序规则是利用哈希法，根据对象的哈希码值（实际上是一个 HashMap 实例）来确定对象的存储位置，同样可以根据哈希码值来寻找对象。它不保证该顺序恒久不变，此类允许使用 null 元素。

添加Hash类实现的对象时，需要定义HashCode()方法。在比较两个加入HashSet容器的对象是否相同时，会先比较HashCode()方法返回的值是相同，如果相同则在使用equals()方法去比较，如果两者相同，既视为相同。

package set;import java.util.HashSet;
import java.util.Iterator;//测试HashSet
public class Test_HashSet {public static void main(String[] args) {//创建对象（）多态HashSet<Object> hashSet = new HashSet();//调用方法hashSet.add(1);hashSet.add(null);hashSet.add('a');hashSet.add("关羽");hashSet.add(1);System.out.println(hashSet);//[null, 关羽, 1, a]  无序，不重复 可null 无下标//迭代遍历Iterator iterator = hashSet.iterator();while (iterator.hasNext()){System.out.print(iterator.next()+",");}System.out.println();//增强for遍历for (Object o : hashSet){System.out.print(o+".");}/*** null,关羽,1,a,* null.关羽.1.a.*/}
}

4 、 Map<>接口(键/值映射)

Java中键值映射是指Map集合来保存成对的“键——值”（key - value）信息，在映射中不包含重复的键，并且每个键最多映射一个值，重复会产生覆盖（栗子：一个人只能有一个身份证号码，一个号码只有一个名字，如果你重新改名，则以改的为准，不会存在两个名字）。存放的都是无序数据并且有初始容量，默认是16，默认的加载因子是0.75。Map集合提供的键值映射机制更好的保存各种数据，与其拓展。

Map集合包括了Map接口以及Map接口的所有实现类，主要实现类有HashMap<K,V>哈希映射类和TreeMap。Map接口提供的操作集合的常用方法有：

常用方法：
void clear()==>从此映射中移除所有映射关系（可选操作）。
boolean containsKey(Object key)==>如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)==>如果此映射将一个或多个键映射到指定值，则返回 true。
V get(Object key)==>返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
boolean isEmpty()==> 如果此映射未包含键-值映射关系，则返回 true。
V put(K key, V value)==>将指定的值与此映射中的指定键关联（可选操作）。
void putAll(Map<? extends K,? extends V> m)==> 从指定映射中将所有映射关系复制到此映射中（可选操作）。
V remove(Object key)==> 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int size()==>返回此映射中的键-值映射关系数。
Set<Map.Entry<K,V>> entrySet()==> 返回此映射所包含的映射关系的 Set 视图。

package map;import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;//测试Map
public class Test_Map {public static void main(String[] args) {//创建对象Map<Integer,String> map = new HashMap<>();//泛型约束map.put(2001, "钢铁侠");map.put(2002, "蜘蛛侠");map.put(2003, "绿巨人");map.put(2004, "灭霸");map.put(2005, "美国队长");map.put(2006, "凤姐");System.out.println(map);//{2001=钢铁侠, 2002=蜘蛛侠, 2003=绿巨人, 2004=灭霸, 2005=美国队长, 2006=凤姐}//调用方法System.out.println(map.isEmpty());//如果此映射未包含键-值映射关系，则返回 true。System.out.println(map.size());//返回此映射中的键-值映射关系数。System.out.println(map.containsKey(2003));//如果此映射包含指定键的映射关系，则返回 true。System.out.println(map.containsValue("钢铁侠"));//如果此映射将一个或多个键映射到指定值，则返回 true。System.out.println(map.get(2004));//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。System.out.println(map.remove(2006));//如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。System.out.println(map);/***false* 6* true* true* 灭霸* 凤姐* {2001=钢铁侠, 2002=蜘蛛侠, 2003=绿巨人, 2004=灭霸, 2005=美国队长}*/Map<Integer,String> map2 = new HashMap ();map2.put(999, "刘德华");//将指定的值与此映射中的指定键关联（可选操作）map.put(null,null);//可以存入键为null，值也null的数据map.putAll(map2);//从指定映射中将所有映射关系复制到此映射中（可选操作）System.out.println(map);//{null=null, 2001=钢铁侠, 2002=蜘蛛侠, 2003=绿巨人, 2004=灭霸, 2005=美国队长, 999=刘德华}//keySet()返回键的set集合,把map的key形成set集合Set set = map.keySet();System.out.println(set);//[null, 2001, 2002, 2003, 2004, 2005, 999]//遍历集合:// 1 、返回此映射所包含的映射关系的 Set 视图。Set<Map.Entry<Integer,String>> entries = map.entrySet();for(Map.Entry<Integer,String> value : entries){System.out.print(value+",");}//null=null,2001=钢铁侠,2002=蜘蛛侠,2003=绿巨人,2004=灭霸,2005=美国队长,999=刘德华,System.out.println();//换行// 2 、keySet()：把map中的可以放入set集合//上面有调用Set,所有就直接用了:Set set = map.keySet();Iterator iterator = set.iterator();while (iterator.hasNext()){//            System.out.println(iterator.next());//直接输出只有key值Integer key = (Integer) iterator.next();String value = map.get(key);System.out.print(key+"="+value+",");}//null=null,2001=钢铁侠,2002=蜘蛛侠,2003=绿巨人,2004=灭霸,2005=美国队长,999=刘德华,System.out.println();// 3 、 entrySet ()Set set1 = map.entrySet();Iterator iterator1 = set1.iterator();while (iterator1.hasNext()){//两种输出方式
//            Map.Entry en = (Map.Entry) iterator1.next();
//            Integer key = (Integer) en.getKey();
//            String value = map.get(key);//String value = (String) en.getValue();
//            System.out.print(key+"="+value+",");System.out.print(iterator1.next()+",");}//null=null,2001=钢铁侠,2002=蜘蛛侠,2003=绿巨人,2004=灭霸,2005=美国队长,999=刘德华,}
}

5 、 HashMap<K,V>（哈希映射类）

HashMap的键要同时重写hashCode()和equals()hashCode()用来判断确定hash值是否相同equals()用来判断属性的值是否相同-- equals()判断数据如果相等，hashCode()必须相同-- equals()判断数据如果不等，hashCode()尽量不同
常用方法与Map一致。

HashMap类实现了Map接口，由HashMap类实现的Map集合允许以null作为键对象也就可以使用null值，但是因为键对象不可以重复，所以这样的键对象只能有一个。如果经常需要添加、删除和定位映射关系，利用HashMap类实现Map集合，缺点是在遍历集合时得到的映射关系是无序的。

在使用由HashMap类实现的Map集合时，如果想有效使用，就必须重写作为主键对象类的hashCode（）方法。在重写hashCode（）方法时，有以下两条基本原则：
（1）不唯一原则。不必为每个对象生成一个唯一的哈希码，只要通过hashCode（）方法即可生成哈希码，利用get（）方法能够得到利用put（）方法添加的映射关系即可。
（2）分散原则。生成哈希码的算法应尽量使哈希码的值分散一些，不要将很多哈希码值都集中在一个范围内，这样有利于提高由HashMap类实现的Map集合的性能。
HashMap底层是一个Entry数组，当存放数据时会根据hash算法计算数据的存放位置。算法：hash(key)%n，n就是数组的长度。当计算的位置没有数据时，就直接存放，当计算的位置有数据时也就是发生hash冲突的时候/hash碰撞时，采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

没有什么扩展的方法，简单测试一下遍历：

package map;import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;//测试HashMap
public class Test_HashMap {public static void main(String[] args) {//创建对象HashMap hashMap = new HashMap();//调用方法hashMap.put(112,"救救我");hashMap.put(120,"加油救");hashMap.put(110,"你玩了");hashMap.put(119,"大发了");System.out.println(hashMap);//迭代的几种方式Set set = hashMap.keySet();Iterator iterator = set.iterator();while (iterator.hasNext()){Integer key = (Integer) iterator.next();String value = (String) hashMap.get(key);System.out.print(key+"="+value+",");}System.out.println();Set set1  = hashMap.entrySet();Iterator iterator1 = set1.iterator();while (iterator1.hasNext()){Map.Entry entry = (Map.Entry) iterator1.next();System.out.print(entry.getKey()+"="+entry.getValue()+",");
//            Integer key = (Integer) entry.getKey();
//            String valur = (String) entry.getValue();
//            System.out.print(key+"="+valur+"，");}System.out.println();Set<Map.Entry<Integer,String>> entries = hashMap.entrySet();for (Map.Entry<Integer,String> entry : entries){System.out.print(entry+",");}}
}

5.1 重写一下里面的返回值与HashCode

package set;import java.util.HashSet;
import java.util.Iterator;//测试HashSet
public class Test011_HashSet {public static void main(String[] args) {Person  person = new Person("刘备",18);Person  person1 = new Person("关羽",17);Person  person2 = new Person("张飞",16);Person  person3 = new Person("黄忠",17);Person  person4 = new Person("黄忠",17);//创建对象HashSet<Object> hashSet = new HashSet<>();hashSet.add(person);hashSet.add(person1);hashSet.add(person2);hashSet.add(person3);
//        System.out.println(hashSet);//迭代遍历Iterator iterator = hashSet.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
}class Person{private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Override//重写方法，返回我们想要的值public String toString() {return "Person{" + "name='" + name + '\'' +", age=" + age + '}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;if (age != person.age) return false;return name != null ? name.equals(person.name) : person.name == null;}//HashSet默认：添加时查找对象的hash值，没有查到就存起来//所以必须让hash值一致才可以//必须用算法，不然的话，hash值相同时会挂一串@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;//让基本类型*31，引用类型就用自己的hash值return result;}
}