Java基础学习第二十四天（Map接口、HashMap类、TreeMap类、Hashtable类、 Collections类、Arrays类）

一、Map接口

1、双列集合
在现实生活中有些数据是以映射关系存在的，也就是成对存在的

2、如果是实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。

Map接口的方法	解释
增加
put(K key, V value)	增加新元素
putAll(Map m)	把map2的元素添加到map集合中
删除
remove(Object key)	根据键删除
clear()	清空集合中的所有数据
获取
get(Object key)	根据指定的键获取对应的值
size()	获取map集合键值对个数
判断
containsKey(Object key)	判断map集合是否包含指定的键
containsValue(Object value)	判断map集合中是否包含指定的值
isEmpty()	判断map集合是否为空元素
迭代
keySet()	遍历方式一
values()	遍历方式二
entrySet()	遍历方式三

public class Demo24.1{
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String, String>();
        //添加方法
        map.put("汪峰", "章子怡");
        map.put("文章", "马伊琍");
        map.put("谢霆锋","张柏芝");        
        System.out.println("返回值："+map.put("谢霆锋","王菲"));、
        // 如果之前没有存在该键，那么返回的是null，如果之前就已经存在该键了，那么就返回该键之前对应的值  
        System.out.println("集合的元素："+ map);                  

        Map<String,String> map2 = new HashMap<String, String>();
        map2.put("我", "双双");
        map.putAll(map2); // 把map2的元素添加到map集合中。

        //删除
        System.out.println("删除的数据是:"+map.remove("汪峰"))；
        //根据键删除一条map中的数据，返回的是该键对应的值。
        map.clear(); //清空集合中的所有数据

        //获取
        System.out.println("根据指定的键获取对应的值:"+ map.get("文章"));
        System.out.println("获取map集合键值对个数："+map.size());

        //判断
        System.out.println("判断map集合是否包含指定的键："+ map.containsKey("文章"));
        System.out.println("判断map集合中是否包含指定的值："+ map.containsValue("张柏芝"));
        map.clear();
        System.out.println("判断map集合是否为空元素："+ map.isEmpty());

        //map集合中遍历方式一：使用keySet方法进行遍历
        //缺点：keySet方法只是返回了所有的键，没有值。 
        Set<String> keys = map.keySet();  //keySet()：把Map集合中的所有键都保存到一个Set类型的集合对象中返回。
        Iterator<String> it = keys.iterator();
        while(it.hasNext()){
            String key = it.next();
            System.out.println("键："+ key+" 值："+ map.get(key));
        }

        //map集合的遍历方式二： 使用values方法进行遍历 
        //缺点：values方法只能返回所有的值，没有键。
        Collection<String>  c = map.values(); //values() 把所有的值存储到一个Collection集合中返回。
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            System.out.println("值："+ it.next());
        }

        //map集合的遍历方式三：entrySet方法遍历
        Set<Map.Entry<String,String>> entrys = map.entrySet(); 
        Iterator<Map.Entry<String,String>> it = entrys.iterator();
        while(it.hasNext()){
            Map.Entry<String,String> entry = it.next();
            System.out.println("键："+ entry.getKey()+" 值："+ entry.getValue());
    }
}

二、HashMap实现类

1、HashMap的底层也是基于哈希表实现的。

2、HashMap的存储原理
往HashMap添加元素的时候，首先会调用键的hashCode方法得到元素的哈希码值，然后经过运算就可以算出该元素在哈希表中的存储位置。
① 情况1： 如果算出的位置目前没有任何元素存储，那么该元素可以直接添加到哈希表中；
② 情况2：如果算出的位置目前已经存在其他的元素，那么还会调用该元素的equals方法与这个位置上的元素进行比较，如果equals方法返回的是false，那么该元素允许被存储，如果equals方法返回的是true，那么该元素被视为重复元素，不允许存储。

class Person{   
    int id; 
    String name;
    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }   
    @Override
    public String toString() {
        return  "[编号："+this.id+" 姓名："+ this.name+"]";       
    }       
    @Override
    public int hashCode() {
        return this.id;
    }   
    @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        return this.id== p.id;
    }
}
public class Demo24.2{
    public static void main(String[] args) {
        HashMap<Person, String> map = new HashMap<Person, String>();
        map.put(new Person(110,"狗娃"), "001");
        map.put(new Person(220,"狗剩"), "002");
        map.put(new Person(330,"铁蛋"), "003");
        map.put(new Person(110,"狗娃"), "007"); //如果出现了相同键，那么后添加的数据的值会取代之前的值
        System.out.println("集合的元素："+ map);      
    }   
}

三、TreeMap实现类

1、TreeMap也是基于红黑树（二叉树）数据结构实现 的， 特点：会对元素的键进行排序存储。

2、TreeMap 要注意的事项
① 往TreeMap添加元素的时候，如果元素的键具备自然顺序，那么就会按照键的自然顺序特性进行排序存储；
② 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性， 那么键所属的类必须要实现Comparable接口，把键的比较规则定义在CompareTo方法上；
③ 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，而且键所属的类也没有实现Comparable接口，那么就必须在创建TreeMap对象的时候传入比较器。

class Emp {//implements Comparable<Emp>{    
    String name;    
    int salary;
    public Emp(String name, int salary) {
        super();
        this.name = name;
        this.salary = salary;
    }   
    @Override
    public String toString() {
        return "[姓名："+this.name+" 薪水："+ this.salary+"]";
    }
    @Override
    public int compareTo(Emp o) {
        return this.salary - o.salary;
    }   
}
//自定义一个比较器
class MyComparator implements Comparator<Emp>{
    @Override
    public int compare(Emp o1, Emp o2) {
        return o1.salary - o2.salary;
    }   
}
public class Demo24.3 { 
    public static void main(String[] args) {
        TreeMap<Character, Integer> tree = new TreeMap<Character, Integer>();
        tree.put('c',10);
        tree.put('b',2);
        tree.put('a',5);
        tree.put('h',12);
        System.out.println(tree);

        //创建一个自定义比较器
        MyComparator comparator = new MyComparator();       
        TreeMap<Emp, String> tree = new TreeMap<Emp, String>(comparator);
        tree.put(new Emp("张三", 1000),"001");
        tree.put(new Emp("李四", 6000),"002");
        tree.put(new Emp("王五", 8000),"003");
        tree.put(new Emp("赵六", 5000),"005");        
        System.out.println(tree);   
    }
}

3、需求： 定义一个TreeMap，键存储的是书对象，值存储的是字符串。 根据书的出版出版日期排序。

import java.util.TreeMap;
class Book implements Comparable<Book>{
    String name;
    String date; //出版日期 
    public Book(String name, String date) {
        super();
        this.name = name;
        this.date = date;
    }   
    //利用字符串的compareTo方法进行排序
    @Override
    public int compareTo(Book o) {
        return this.date.compareTo(o.date);
    }
    @Override
    public String toString(){
        return "[书名："+this.name+" "+this.date+"]";
    }   
}
public class Demo24.4{
    public static void main(String[] args) {
        TreeMap<Book, String>  map = new TreeMap<Book, String>();  //值存储书名
        map.put(new Book("红楼梦","1990-02-20"), "001");
        map.put(new Book("西游记","1923-04-20"), "002");
        map.put(new Book("水浒传","1987-07-20"), "003");
        map.put(new Book("三国演义","1910-12-20"), "004");      
        System.out.println(map);
    }
}

四、Hashtable实现类（了解）

底层也是依赖了哈希表实现的，也就是实现方式与HashMap是一样的，但是Hashtable是线程安全的，操作效率低。

五、Collections类

1、对list进行二分查找：前提该集合一定要有序
int binarySearch(list,key);
//必须根据元素自然顺序对列表进行升级排序
//要求list 集合中的元素都是Comparable 的子类
int binarySearch(list,key,Comparator);
2、对list集合进行排序
sort(list); //对list进行排序,其实使用的事list容器中的对象的compareTo方法
sort(list,comaprator);//按照指定比较器进行排序
3、对集合取最大值或者最小值
max(Collection)
max(Collection,comparator)
min(Collection)
min(Collection,comparator)
4、对list集合进行反转
reverse(list);
5、可以将不同步的集合变成同步的集合
Set synchronizedSet(Set s)
Map synchronizedMap(Map

六、Arrays类

1、二分查找,数组需要有序
binarySearch(int[])
binarySearch(double[])
2、数组排序
sort(int[])
sort(char[])……
3、将数组变成字符串： toString(int[])
4、复制数组： copyOf();
5、复制部分数组：copyOfRange():
6、比较两个数组是否相同：equals(int[],int[]);
7、将数组变成集合：List asList(T[]);

这样可以通过集合的操作来操作数组中元素，但是不可以使用增删方法，add，remove。因为数组长度是固定的，会出现UnsupportOperationExcetion。
可以使用的方法：contains，indexOf。
① 如果数组中存入的基本数据类型，那么asList会将数组实体作为集合中的元素。
② 如果数组中的存入的引用数据类型，那么asList会将数组中的元素作为集合中的元素。

扫描二维码关注公众号，回复： 2010226 查看本文章

class Demo24.5{
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(4);
        list.add(3);
        list.add(1);
        list.add(2);
        list.add(3);
        //排序
        Collections.sort(list);
        //折半查找的前提是排序好的元素
        System.out.println(Collections.binarySearch(list,8));         
        //找不到返回-插入点-1
        //反序集合输出
        Collections.reverse( list );
        System.out.println( list );
        //求最值
        System.out.println( Collections.max( list ) );   // 4
        //fill()使用指定的元素替换指定集合中的所有元素
        //Collections.fill( list, 5 );
        System.out.println( list );

        //将数组转换为集合
        Integer is[] = new Integer[]{6,7,8};
        List<Integer> list2 = Arrays.asList(is);
        list.addAll(list2);
        System.out.println(list);
        //将List转换为数组
        Object [] ins = list.toArray();
        System.out.println(Arrays.toString(ins));
    }
}