18.01_集合框架(Map集合概述和特点)
- 查看API可以知道:
- 将键映射到值的对象
- 一个映射不能包含重复的键
- 每个键最多只能映射到一个值
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set是唯一的
- Map集合的数据结构值针对键有效,跟值无关;Collection集合的数据结构是针对元素有效
18.02_集合框架(Map集合的功能概述)
- a:添加功能
- V put(K key,V value):添加元素。
- 如果键是第一次存储,就直接存储元素,返回null
- 如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
System.out.println(map);
}
}
- b:删除功能
- void clear():移除所有的键值对元素
- V remove(Object key):根据键删除键值对元素,并把值返回
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
Integer i = map.remove("张三");
System.out.println(i);
System.out.println(map);
}
}
- c:判断功能
- boolean containsKey(Object key):判断集合是否包含指定的键
- boolean containsValue(Object value):判断集合是否包含指定的值
- boolean isEmpty():判断集合是否为空
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
Integer i = map.remove("张三");
System.out.println(i);
System.out.println(map.containsKey("张三"));
System.out.println(map.containsValue(25));
System.out.println(map);
}
}
- d:获取功能
- Set<Map.Entry<K,V>entrySet():
- V get(Object key):根据键获取值
- Set<KkeySet():获取集合中所有键的集合
- Collection<Vvalues():获取集合中所有值的集合
- e:长度功能
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
Collection<Integer> c = map.values();
System.out.println(c);
System.out.println(map.size());
}
}
18.03_集合框架(Map集合的遍历之键找值)
- map集合不能直接迭代,没有Iterator方法
- 获取所有键的集合
- 遍历键的集合,获取到每一个键
- 根据键找值
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
Integer i = map.get("张三");
System.out.println(i);
Set<String> set = map.keySet();
Iterator<String> it = set.iterator();
while(it.hasNext()){
String key = it.next();
Integer value = map.get(key);
System.out.print(key +" "+ value +" ");
}
}
}
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
Integer i = map.get("张三");
System.out.println(i);
for (String key : map.keySet()) {
System.out.print(key +" "+ map.get(key) +" ");
}
}
}
18.04_集合框架(Map集合的遍历之键值对对象找键和值)
- 获取所有键值对对象的集合
- 遍历键值对对象的集合,获取到每一个键值对对象
- 根据键值对对象找键和值
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("张三",23);
map.put("李四",24);
map.put("王五",25);
map.put("赵六",26);
for (Map.Entry<String,Integer> en : map.entrySet()) {
System.out.print(en.getKey()+" "+en.getValue()+" ");
}
}
}
18.05_集合框架(HashMap集合键是Student值是String的案例)
- HashMap集合键是Student值是String的案例
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student(){
super();
}
public Student(String name,int age){
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<Student,String> hm = new HashMap<>();
hm.put(new Student("张三",23),"北京");
hm.put(new Student("张三",23),"上海");
hm.put(new Student("李四",23),"广州");
hm.put(new Student("王五",23),"深圳");
System.out.println(hm);
}
}
18.06_集合框架(LinkedHashMap的概述和使用)
import java.util.LinkedHashMap;
public class Main {
public static void main(String[] args) {
LinkedHashMap<String,Integer> lnm = new LinkedHashMap<>();
lnm.put("张三",23);
lnm.put("李四",24);
lnm.put("王五",25);
System.out.println(lnm);
}
}
18.07_集合框架(TreeMap集合键是Student值是String的案例)
- TreeMap集合键是Student值是String的案例
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<>();
tm.put(new Student("张三",23),"北京");
tm.put(new Student("李四",24),"上海");
tm.put(new Student("王五",25),"广州");
tm.put(new Student("赵六",26),"深圳");
System.out.println(tm);
}
}
import java.util.Objects;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){
super();
}
public Student(String name,int age){
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public int compareTo(Student o){
int num = this.age - o.age;
return num == 0 ? this.name.compareTo(o.name) : num;
}
}
import java.util.Comparator;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>(){
@Override
public int compare(Student s1, Student s2) {
int num = s1.getName().compareTo(s2.getName());
return num == 0 ? s1.getAge()-s2.getAge() : num;
}
});
tm.put(new Student("张三",23),"北京");
tm.put(new Student("李四",24),"上海");
tm.put(new Student("王五",25),"广州");
tm.put(new Student("赵六",26),"深圳");
System.out.println(tm);
}
}
18.08_集合框架(统计字符串中每个字符出现的次数)
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
String str = "adcaacddca";
char[] arr = str.toCharArray();
HashMap<Character,Integer> hm = new HashMap<>();
for(char c : arr){
hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
}
for(Character key : hm.keySet()){
System.out.print(key+"="+hm.get(key)+" ");
}
}
}
18.09_集合框架(集合嵌套之HashMap嵌套HashMap)
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<Student,String> hm88 = new HashMap<>();
hm88.put(new Student("张三",23), "北京");
hm88.put(new Student("李四",24), "北京");
hm88.put(new Student("王五",25), "上海");
hm88.put(new Student("赵六",26), "广州");
HashMap<Student,String> hm99 = new HashMap<>();
hm99.put(new Student("小明",17), "北京");
hm99.put(new Student("小华",18), "北京");
hm99.put(new Student("小红",19), "上海");
hm99.put(new Student("小花",16), "广州");
HashMap<HashMap<Student,String>,String> hm = new HashMap<>();
hm.put(hm88,"第88期基础班");
hm.put(hm99,"第99期基础班");
for(HashMap<Student,String> h : hm.keySet()){
String value = hm.get(h);
for(Student key : h.keySet()){
String value2 = h.get(key);
System.out.println(key+" "+value2+" "+value);
}
}
}
}
18.10_集合框架(HashMap和Hashtable的区别)
- HashMap和Hashtable的共同点
- HashMap和Hashtable的区别
- Hashtable是JDK1.0版本出现的,是线程安全的
- 效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
- Hashtable不可以存储null键和null值
- HashMap可以存储null键和null值
18.11_集合框架(Collections工具类的概述和常见方法讲解)
public static <T> void sort(List<T> list)
public static <T> int binarySearch(List<?> list,T key)
public static <T> T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("c");
list.add("d");
list.add("b");
Collections.sort(list);
System.out.println(list);
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("c");
list1.add("d");
list1.add("f");
System.out.println(Collections.binarySearch(list1,"d"));
ArrayList<String> list2 = new ArrayList<>();
list2.add("a");
list2.add("c");
list2.add("d");
list2.add("g");
System.out.println(Collections.max(list2));
Collections.reverse(list2);
System.out.println(list2);
Collections.shuffle(list2);
System.out.println(list2);
}
}
18.12_集合框架(模拟斗地主洗牌和发牌)
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] color = {"红桃","黑桃","梅花","方块"};
ArrayList<String> poker = new ArrayList<>();
for(String s1 : color){
for(String s2 : num){
poker.add(s1.concat(s2));
}
}
poker.add("小王");
poker.add("大王");
Collections.shuffle(poker);
ArrayList<String> gaojin = new ArrayList<>();
ArrayList<String> longwu = new ArrayList<>();
ArrayList<String> me = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
for(int i = 0; i < poker.size(); i++){
if(i >= poker.size() - 3){
dipai.add(poker.get(i));
}else if(i % 3 == 0){
gaojin.add(poker.get(i));
}else if(i % 3 == 1){
longwu.add(poker.get(i));
}else{
me.add(poker.get(i));
}
}
System.out.println(gaojin);
System.out.println(longwu);
System.out.println(me);
System.out.println(dipai);
}
}
18.13_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的原理图解)
- 画图说明排序原理
18.14_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的代码实现)
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) {
String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] color = {"红桃","黑桃","梅花","方块"};
HashMap<Integer, String> hm = new HashMap<>();
ArrayList<Integer> list = new ArrayList<>();
int index = 0;
for(String s1 : num){
for(String s2 : color){
hm.put(index, s2.concat(s1));
list.add(index);
index++;
}
}
hm.put(index,"小王");
list.add(index);
index++;
hm.put(index,"大王");
list.add(index);
Collections.shuffle(list);
TreeSet<Integer> gaojin = new TreeSet<>();
TreeSet<Integer> longwu = new TreeSet<>();
TreeSet<Integer> me = new TreeSet<>();
TreeSet<Integer> dipai = new TreeSet<>();
for(int i = 0; i < list.size(); i++){
if(i >= list.size() - 3){
dipai.add(list.get(i));
}else if(i % 3 == 0){
gaojin.add(list.get(i));
}else if(i % 3 == 1){
longwu.add(list.get(i));
}else{
me.add(list.get(i));
}
}
lookPoker(hm,gaojin,"高进");
lookPoker(hm,longwu,"龙五");
lookPoker(hm,me,"我");
lookPoker(hm,dipai,"底牌");
}
public static void lookPoker(HashMap<Integer,String> hm,TreeSet<Integer> ts,String name){
System.out.print(name+"的牌是:");
for(Integer i : ts){
System.out.print(hm.get(i)+" ");
}
System.out.println();
}
}
18.15_集合框架(泛型固定下边界)
import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;
import com.heima.bean.BaseStudent;
import com.heima.bean.Student;
public class Demo2_Genric {
public static void main(String[] args) {
TreeSet<Student> ts1 = new TreeSet<>(new CompareByAge());
ts1.add(new Student("张三", 33));
ts1.add(new Student("李四", 13));
ts1.add(new Student("王五", 23));
ts1.add(new Student("赵六", 43));
TreeSet<BaseStudent> ts2 = new TreeSet<>(new CompareByAge());
ts2.add(new BaseStudent("张三", 33));
ts2.add(new BaseStudent("李四", 13));
ts2.add(new BaseStudent("王五", 23));
ts2.add(new BaseStudent("赵六", 43));
System.out.println(ts2);
}
public static void demo1() {
ArrayList<Student> list1 = new ArrayList<>();
list1.add(new Student("张三", 23));
list1.add(new Student("李四", 24));
ArrayList<BaseStudent> list2 = new ArrayList<>();
list2.add(new BaseStudent("王五", 25));
list2.add(new BaseStudent("赵六", 26));
list1.addAll(list2);
}
}
class CompareByAge implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
return num == 0 ? s1.getName().compareTo(s2.getName()) : num;
}
}
18.16_集合框架(总结)
- List ( 存取有序,有索引,可以重复)
- ArrayList:底层是数组实现的,线程不安全,查找修改快,增删慢
- LinkedList:底层是链表实现的,线程不安全,查找修改慢,增删快
- Vector:底层是数组实现的,线程安全,增删改查都慢
- 如果查找和修改多用ArrayList,如果增删多用LinkedList,如果都多用ArrayList
- Set(存取无序,无索引,不可以重复)
- HashSet:底层是哈希算法实现
- LinkedHashSet:底层是链表实现但是也可保证元素唯一,和HashSet一样
- TreeSet:底层是二叉树算法实现
- 一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet效率比较高
- TreeSet在面试的时候问的比较多,问你有几种排序方式,和几种排序方式的区别
- HashMap:底层是哈希算法,针对键
- TreeMap:底层是二叉树算法,针对键
- 开发者HashMap用的比较多