章六、集合（1）—— Set 接口及实现类、集合迭代、Map 接口、Collections类

一、 Set 接口及实现类

Set接口不能存储重复元素

Set接口继承了Collection接口。Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的

Set接口有两个实现类：

● HashSet ：HashSet类中的元素不能重复

● TreeSet ：可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。

● HashSet

import java.util.HashSet;public class HashSetDemo {public static void main(String[] args) {/*Set:元素不重复HashSet：元素是无序的*/HashSet<String> set = new HashSet<>();set.add("a");set.add("b");set.add("c");set.add("a");set.add("d");System.out.println(set);//set.clear();set.contains("a");set.isEmpty();set.remove("a");//没有索引,故而不能用for循环，只能用增强for和迭代器set.size();set.iterator();}
}

HashSet在添加元素时，是如何判断元素重复的：

当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低
在底层会调用hashCode()方法
-- 在Object中的hashCode()返回的是地址，不能用
-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值

遍历时，会先比较内容的哈希值是否相等，会提高比较的效率，
但是Hash值会可能存在问题：内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）此种情况下再调用 equals()内容

import javax.xml.transform.Source;
import java.sql.SQLOutput;
import java.util.HashSet;public class HashSetDemo2 {/*HashSet在添加元素时，是如何判断元素重复的:当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低在底层会调用hashCode()方法-- 在Object中的hashCode()返回的是地址，不能用-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值遍历时，会用哈希值先比较是否相等，会提高比较的效率，但是Hash值会可能存在问题，内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）此种情况下再调用 equals()内容*/public static void main(String[] args) {HashSet<String> set = new HashSet<>();set.add("a");set.add("b");set.add("c");set.add("a");set.add("d");System.out.println(set);for (String s : set){System.out.println(s);}}
}

● TreeSet

可以给Set集合中的元素进行指定方式的排序。由于这些自定义的类型的数据没有实现Comparable接口，因此无法直接在TreeSet集合中进行排序操作。

解决方案：

要求TreeSet集合中存储的元素所在的类必须实现Comparable接口，并重写comoareTo()方法，然后TreeSet集合就会对该类型使用compareTo()方法进行比较，并默认进行升序排序

public class Student implements Comparable<Student>{private int num;private String name;public Student() {}public Student(int num, String name) {this.num = num;this.name = name;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic int compareTo(Student o) {int temp = this.num - o.num;return temp == 0 ? this.name.compareTo(o.name) : temp;}}

import java.util.Iterator;
import java.util.TreeSet;/*
放入学生信息
要给自定义数据要实现compareTo接口*/
public class TreeSetDemo2 {public static void main(String[] args) {Student s1 = new Student(20,"张三1");Student s2 = new Student(21,"张三2");Student s3 = new Student(20,"张三3");Student s4 = new Student(23,"张三4");Student s5 = new Student(20,"张三1");TreeSet<Student> treeSet = new TreeSet<>();treeSet.add(s4);treeSet.add(s2);treeSet.add(s3);treeSet.add(s1);treeSet.add(s5);System.out.println(treeSet);}
}

● Set 接口集合迭代

• 增强for循环

import java.util.Iterator;
import java.util.TreeSet;/*
放入学生信息
要给自定义数据要实现compareTo接口*/
public class TreeSetDemo2 {public static void main(String[] args) {Student s1 = new Student(20,"张三1");Student s2 = new Student(21,"张三2");Student s3 = new Student(20,"张三3");Student s4 = new Student(23,"张三4");Student s5 = new Student(20,"张三1");TreeSet<Student> treeSet = new TreeSet<>();treeSet.add(s4);treeSet.add(s2);treeSet.add(s3);treeSet.add(s1);treeSet.add(s5);System.out.println(treeSet);Iterator<Student> iterator = treeSet.iterator();for(Student a : treeSet){System.out.println(a.getNum()+a.getName());}}
}

• 迭代器遍历

二、 Map 接口 ※

将键映射到值的对象

Map接口的特性
数据存储是以 (键,值) 的形式存储
键不能重复，值可以重复
一个键只能映射到一个值

一个映射不能包含重复的键，每个键最多只能映射到一个值，即 值 -> 键 是 一对多 的形式

● Map 接口常用方法

V put(K key,V value) //一次向Map里放入一个键值对

V remove(Object key) //通过键删除

void clear() //清空 map

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

int size()

V get(Object key)

Collection<V> values()

Set<K> keySet()

Set<Map.Entry<K,V>> entrySet()

● HashMap ※

HashMap中元素的key值不能重复，排列顺序是不固定的，可以存储一个为null的键。

其在存储时到底是什么结构？※

首先用到 Hash数组（查询快，定位快），长度默认为16，创建Hash数组主要是用来定位

然后通过输入的 key 来计算出一个 int类型的 hash值（hash%数组长度），然后在该 hash值的索引处创建一个 Next = NULL 的链表

当下一个 key 计算出来的hash值与存在的相同时（即hash冲突），比较该位置的值，如果不相同，则向下链接新节点（拉链法），即将后来的元素添加到之前元素的Next节点；如果相同，则用后来的键的值覆盖原来的值

当某一hash节点处的链表过长（ >=8 ）时（会影响速度），且哈希数组长度 >=64时，链表会自动转为红黑树

当哈希表的负载因子为0.75时，会自动扩容为原来数组长度的2倍

• HashMap方法

import java.util.Collection;
import java.util.HashMap;public class HashMapDemo {public static void main(String[] args) {/*Map接口的特性数据存储是 (键,值)的形式存储键不能重复，值可以重复一个键只能映射到一个值*/HashMap<String,String> map = new HashMap<>();map.put("a","aa"); //(键,值)map.put("b","bb");map.put("w","ww");map.put("c","cc");map.put("d","bb"); //值可以重复map.put("a","aaa"); //用第二次加进的值覆盖了第一次键的值System.out.println(map);//删除指定的键并返回对应的值System.out.println(map.remove("a"));System.out.println(map);//清除 map/*map.clear();System.out.println(map);*///判断map中键值对的个数是否为空System.out.println(map.isEmpty());//判断是否有输入的键System.out.println(map.containsKey("b"));//判断是否有输入的值System.out.println(map.containsValue("bb"));//获得 键的值System.out.println(map.get("b"));//返回map的所有值System.out.println(map.values());}
}

● TreeMap

TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。

import java.util.TreeMap;
/*
TreeMap
键可以排序
键元素必须实现 Comparable接口，重写compareTo()*/
public class TreeMapDemo1 {public static void main(String[] args) {TreeMap<Integer,String> treeMap  = new TreeMap<>();treeMap.put(2,"aa");treeMap.put(1,"bb");treeMap.put(3,"aa");treeMap.put(5,"cc");treeMap.put(4,"ee");treeMap.put(2,"bb");System.out.println(treeMap);}
}

● HashTable

/*
在HashMap中可以存储一个键或者值为null的对象
但Hashtable不能存储，会直接报错
*/

三、 Map集合遍历

● 根据键找值

• 获取所有键的集合

• 遍历键的集合，获取到每一个键

• 根据键找值

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Traverse1 {public static void main(String[] args) {/*方法一：先拿到所有的键，遍历键，根据键找值*///        Collection<String> values = Map.values();
//        System.out.println(values);HashMap<String,String> map = new HashMap<>();map.put("a","aa");map.put("b","bb");map.put("w","ww");map.put("c","cc");System.out.println(map);//第一种遍历方式Set<String> keyset = map.keySet();for(String key : keyset){System.out.println(key+":"+map.get(key));}}
}

● 根据键值对对象找键和值

• 获取所有键值对对象的集合

• 遍历键值对对象的集合，获取到每一个键值对对象

• 根据键值对对象找键和值

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Traverse1 {public static void main(String[] args) {//        Collection<String> values = Map.values();
//        System.out.println(values);HashMap<String,String> map = new HashMap<>();map.put("a","aa");map.put("b","bb");map.put("w","ww");map.put("c","cc");System.out.println(map);//推荐的遍历方式Set<Map.Entry<String,String>> entries = map.entrySet();for(Map.Entry entry : entries){System.out.println(entry.getKey()+":"+entry.getValue());}}
}

四、 Collections类

Collections是集合类的工具类，与数组的工具类Arrays类似

addAll(Collection<? super T> c , T ... elements); //向集合中添加一个可变长度的数组

binarySearch(List<? extends Comparable<? super T >> list, T key)

sort(List<T> list) //根据元素的自然顺序对指定列表按升序进行排序

sort(List<T> list, Comparator<? super T> c) //根据指定比较器产生的顺序对指定列表进行排序。

swap(List<?> list, int i , int j) //在指定List的指定位置 i , j 处交换元素

copy(List<? super T> dest , List<? extends T> src) ; //将集合复制

// 注意 dest size >= src.size

fill(List<? super T> list, T obj) //覆盖

max(Collection<? extends T> coll) //最大值

min(Collection<? extends T> coll) //最小值

replaceAl l(List<T> list , T oldVal , T newVal) //用 newVal 覆盖 list 中的 oldVal

reverse(List<?> list) //反转列表中元素的顺序

shuffle(List<?> list) //对List集合元素进行随机排序

copy(dest , src) //集合复制

addAll（）：向集合中添加一个可变长度的数组

import java.util.*;public class CollectionsDemo1 {public static void main(String[] args) {HashMap<String,String> map = new HashMap<>();map.put("a","aaa");map.put("b","bbb");map.put("c","ccc");map.put("d","ddd");map.put("e","eee");/*addAll(Collection < ? super T > c, T... elements);父类对象（可以传进Collection接口的所有对象）T ... elements ：可变长度的 T类型的参数作用：向集合中添加元素*/ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);Collections.addAll(list,3,4,5,6);System.out.println(list);//test(1,2,3,4);}/*int ... a 可变长度的参数，本质是一个数组一个参数列表中只能有一个可变长度参数且必须放在参数列表最后*/
//    public static void test(int ... a){
//        System.out.println(Arrays.toString(a));
//    }}

sort（）：排序，需要根据元素重写

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class CollectionsDemo2 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);Collections.addAll(list,3,5,2,4);System.out.println(list);//排序---自定义排序规则//创建了一个实现Comparator接口的匿名内部类对象，就是省去创建一个类，简化了语法Collections.sort(list, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2.intValue()-o1.intValue();}});Collections.sort(list);System.out.println(list);}
}

copy（）：将原集合的值复制到目标集合

注：目标集合必须非空，且目标集合的size>=原集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class CollectionsDemo3 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);System.out.println(list);//交换指定位置上的元素Collections.swap(list,0,1);System.out.println(list);System.out.println();//将一个集合的元素复制到另一个集合去ArrayList<Integer> list1 = new ArrayList<>();//如果目标集合的为空，那copy事会报错list1.add(5);list1.add(6);list1.add(7);//且目标集合的 size >= 原集合的 size，否则报错list1.add(8);Collections.copy(list1,list);System.out.println(list);System.out.println(list1);}
}

其他：

import java.util.ArrayList;
import java.util.Collections;public class CollectionsDemo4 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);System.out.println(list);//最大值System.out.println(Collections.max(list));//最小值System.out.println(Collections.min(list));//用newVal覆盖oldValCollections.replaceAll(list,3,5);System.out.println(list);Collections.replaceAll(list,5,3);//翻转集合元素顺序Collections.reverse(list);System.out.println(list);//对集合元素随机排序Collections.shuffle(list);System.out.println(list);}
}

五、泛型

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

● 什么是泛型

● 泛型，即“参数化类型” 。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

● 参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。

● Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。

● 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口

public class Demo<T>{

/ /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型

        private T key; / /key这个成员变量的类型为T,T的类型由外部指定

        public Demo(T key) {

        / /泛型构造方法形参key的类型也为T，T的类型由外部指定

                this.key = key;

        }

        public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定

                return key;

        }

}

传入的实参类型需与泛型的类型参数类型相同，即为Integer.

1.泛型的类型参数只能是类类型

2.泛型的类型参数可以有多个

3.如果没有定义具体类型,默认为Object

● 从泛型类派生子类

父类：

public class A<T> {T data;
}

子类也是泛型类，子类和父类的泛型类型要一致

class A<T> extends Demo<T>

/*
父类是泛型类
方法一：直接给子类也定义为泛型类
*/
public class B<T> extends A<T>{public static void main(String[] args) {B b = new B();b.data = "String类型";}
}

子类不是泛型类，父类要明确泛型的数据类型

class A extends Demo<String>

/*
父类是泛型类方法二：若子类不是泛型类，那就要在子类中明确指出父类中的泛型
//public class B extends A<String>{*/public class B extends A<String>{public static void main(String[] args) {B b = new B();b.data = "String类型";}
}