Map集合

Map体系集合

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map接口的使用
 * 特点：（1）存储键值对（2）键不能重复，值可以重复（3无序）
 */
public class Demo01 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        //1.添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        //重复元素的值会把原来的替换掉
        map.put("cn","zhongguo");
        System.out.println("元素个数："+map.size());
        System.out.println(map);

        //删除
//        map.remove("usa");
//        System.out.println(map);
        //3.1使用keySet（）
        System.out.println("-----keySet-------");
        //Set<String> set = map.keySet();
        for (String string:map.keySet()) {
            System.out.println(string+"-----"+map.get(string));
        }
        //3.2使用entrySet方法
        System.out.println("-----entrySet-------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry:entries) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }
        //4.判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));


    }
}

Map集合的实现类

• HashMap【重点】
  • JDK1.2版本，线程不安全，运行效率快;允许用null作为key或者是value

import java.util.HashMap;
import java.util.Map;

/**
 * HashMap的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 使用key作为
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        HashMap<Student, String> students = new HashMap<>();
        Student s1 = new Student("孙悟空",22);
        Student s2 = new Student("猪八戒",23);
        Student s3 = new Student("沙和尚",18);
        students.put(s1,"北京");
        students.put(s2,"上海");
        students.put(s3,"杭州");
        students.put(new Student("沙和尚",18),"杭州" );       // students.put(s3,"南京");   值被覆盖
        System.out.println("元素个数："+students.size());
        System.out.println(students);
        //删除
//        students.remove(s1);
//        System.out.println("元素个数："+students.size());
        //3.遍历
        System.out.println("-------keySet---------");
        //3.1使用keySet
        for (Student key: students.keySet()) {
            System.out.println(key.toString()+"------"+students.get(key));
        }
        //3.2使用entrySet
        for (Map.Entry<Student,String> entry: students.entrySet()) {
            System.out.println(entry.getKey()+"-------"+entry.getValue());
        }
        //4.判断
        System.out.println(students.containsKey(s1));
        System.out.println(students.containsValue("杭州"));

    }
}

//学生类
import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

HashMap源码分析

总结：1.HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16

2. 当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的两倍，目的是减少调整元素的个数
3. jdk1.8当每个链表长度大于8，并且元素个数大于64时，会调整为红黑树，目的提高执行效率
4. jdk.8当链表长度小于4时，调整为链表
5. jdk.8以前，链表是头插入，jdk.8后是尾插入

• Hashtable：
  • JDK1.0版本，线程安全，运行效率慢；不允许null作为key或者是value
• Properties：
  • Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。
• TreeMap：
  • 实现了SortedMap接口（是Map的子接口），可以对Key自动排序。

import java.util.Map;
import java.util.TreeMap;
/**
 * TreeMap的使用
 * 存储结构，红黑树
 */
public class Demo03 {
    public static void main(String[] args) {
        //新建集合
        TreeMap<Student,String> treeMap = new TreeMap<Student,String>();
        //1.添加元素
        Student s1 = new Student("孙悟空",25);
        Student s2 = new Student("猪八戒",20);
        Student s3 = new Student("沙和尚",22);
        treeMap.put(s1,"北京");
        treeMap.put(s2,"上海");
        treeMap.put(s3,"西安");
        System.out.println("元素个数："+treeMap.size());
        System.out.println(treeMap);
        //2.删除
//        treeMap.remove(s3);
//        System.out.println(treeMap.size());
        //3.遍历
        //3.1keySet
        System.out.println("------keySet-----");
        for (Student key:treeMap.keySet()) {
            System.out.println(key+"------"+treeMap.get(key));
        }
        //3.2entrySet
        System.out.println("--------entrySet---------");
        for (Map.Entry<Student,String> entry: treeMap.entrySet()) {
            System.out.println(entry.getKey()+"-----"+entry.getValue());
        }
        //4.判断
        System.out.println(treeMap.containsKey(new Student("沙和尚",22)));
    }
}

Collection工具类

1. 概念：集合工具类，定义了除了存取以外的集合常用方法
2. 方法：
   • public static void reverse(List<?> list) //反转集合中元素的顺序
   • public static void shuffle（List <?>list ）//随机重置集合元素的顺序
   • public static void sort（List list）//升序排序（元素类型必须实现Comparable接口）

import java.util.*;

/**
 * 演示Collections工具类的使用
 */
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(5);
        list.add(12);
        list.add(30);
        list.add(6);
        //sort排序
        System.out.println("排序之前："+list);
        Collections.sort(list);
        System.out.println("排序之后："+list);
        //binarySearch二分查找
        int i = Collections.binarySearch(list,12);
        System.out.println(i);//如果未找到则显示负数
        //copy复制
        ArrayList<Integer> dest = new ArrayList<>();
        for (int j = 0; j <list.size() ; j++) {
            dest.add(0);
        }
        Collections.copy(dest,list);
        System.out.println(dest);
        //reverse反转
        Collections.reverse(list);
        System.out.println(list);
        //shuffle打乱顺序
        Collections.shuffle(list);
        System.out.println(list);


        //补充：  list转成数组
        System.out.println("--------list转成数组---------");
        Integer[] arr = list.toArray(new Integer[10]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));

        //数组转成集合
        System.out.println("--------数组转成集合---------");
        String[] names ={"张三","李四","王五"};
        //集合是一个受限集合，不能添加和删除元素
        List<String> list2 = Arrays.asList(names);
        System.out.println(list2);
        //把基本类型数组转换成集合的时候，需要修改为包装类型
        Integer[] nums = {100,200,300,400,500};
        List<Integer> list3 = Arrays.asList(nums);
        System.out.println(list3);
    }
}

集合总结

1. 集合的概念：
   • 对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
2. LIst集合：
   • 有序、有下标、元素可以重复。（ArrayList、LinkedList、Vector）
3. Set集合：
   • 无序、无下标、元素不可重复。（HashSet、TreeSet）
4. Map集合：
   • 存储一对数据，无序、无下标，键不可重复，值可以重复。（HashMap、HashTable、TreeMap）
5. Collections：
   • 集合工具类，定义了除了存取以外的集合常用方法