章六、集合（2）—— 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;
    }



    @Override
    public 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>() {
            @Override
            public 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覆盖oldVal
        Collections.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类型";
    }
}

●  泛型接口

泛型接口与泛型类的定义及使用基本相同。

public interface Demo<T> { //定义一个泛型接口 }

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

class A<T> implements Demo<T>{ }

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

public class A implements Demo<String> { }

●  类型擦除

        泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛到信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为一类型擦除。

泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型。

案例:

public class Demo<T>{

        T name;

        public Demo(T name) {

                this.name= name;

         }

}

Demo是一个泛型类，我们查看它在运行时的状态信息可以通过反射。

Demo<String> demo= new Demo<String>("jim");

Field f = eclz.getField(“name”);

System.out.println(f.getName()+" type:"+f.getType());

name type:java.lang.Object