第十九天 集合-Map接口&容器工具类&集合框架总结【悟空教程】

​第十九天 集合-Map接口&容器工具类&集合框架总结【面试+工作】​

​​第19天 集合​​

第1章 Map接口

​​1.1 Map概念及使用​​

​1.1.1 ​Map概念​​

Map集合的特点，如是否可重复，是否有序仅作用在键上，如HashMap集合的键不得重复，值可以重复。

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

• Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

• Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

• Collection中的集合称为单列集合，Map中的集合称为双列集合。

• 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

• Map中常用的集合为HashMap集合、LinkedHashMap集合。Hashtable也是Map集合的一种已被HashMap取代。

​1.1.2 ​Map接口中常用集合概述​​

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

• ​HashMap<K,V>：​存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• ​LinkedHashMap<K,V>：​HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• ​注意：​Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

​1.1.3 ​Map的常用方法​​

Map(HashMap)的使用：创建对象时加入两个泛型。

Map<k,v>

    key - 此映射所维护的键的类型

    value - 映射值的类型

• put方法：将指定的键与值对应起来，并添加到集合中

• 方法返回值为键所对应的值

               使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

               使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

• get方法：获取指定键(key)所对应的值(value)

• remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。

​Map接口的方法演示​

​​public​ ​class​ MapDemo {​

​​public​ ​static​ ​void​ main(String[] args) {​

​//创建Map对象​

​Map<String, String> map = ​new​ HashMap<String,String>();​

​//给map中添加元素​

​map.put("星期一", "Monday");​

​map.put("星期日", "Sunday");​

​System.​out​.println(map); // {星期日=Sunday, 星期一=Monday}​

​//当给Map中添加元素，会返回key对应的原来的value值，若key没有对应的值，返回null​

​System.​out​.println(map.put("星期一", "Mon")); // Monday​

​System.​out​.println(map); // {星期日=Sunday, 星期一=Mon}​

​//根据指定的key获取对应的value​

​String en = map.get("星期日");​

​System.​out​.println(en); // Sunday​

​//根据key删除元素,会返回key对应的value值​

​String value = map.remove("星期日");​

​System.​out​.println(value); // Sunday​

​System.​out​.println(map); // {星期一=Mon}​

​}​

​}​

​put方法：​

import java.util.HashMap;

/*

 * Map  地图 .  映射 .  

 *

 *  一个对一个.

 *  Map 双列集合. Key 键,  Value值 . 一个键对应一个值.  

 *  

 *  保存元素 :

 *  1.key -values  

 *  2.键是唯一.值随意.

 *  3.如果键重复,老值会被新值替换,作为返回值返回.

 */

public class Demo {

public static void main(String[] args) {

 //创建 HashMap 对象

HashMap<String,String > hashMap = new HashMap<>();

//添加 元素   put 方法

hashMap.put("大郎", "金莲");   //{大郎=金莲}

hashMap.put("西门", "金莲");   //{西门=金莲, 大郎=金莲}

hashMap.put("老王", "柳岩");

String put = hashMap.put("老王", "武松");   // 如果键 重复了, 值会被替换.

System.out.println(put);

System.out.println(hashMap);

}

}

​get方法：​

import java.util.HashMap;

/*

 * 获取 元素.  通过 键 获取值.  

 *

 * V  get (key) .

 */

public class Demo2 {

public static void main(String[] args) {

// 创建 HashMap 对象

HashMap<String, String> hashMap = new HashMap<>();

// 添加 元素 put 方法

hashMap.put("大郎", "金莲"); // {大郎=金莲}

hashMap.put("西门", "金莲"); // {西门=金莲, 大郎=金莲}

hashMap.put("老王", "柳岩");

String value = hashMap.get("老王");

System.out.println(value);

String value2 = hashMap.get("大郎");

System.out.println(value2);

String value3 = hashMap.get("西门");

System.out.println(value3);

}

}

​1.1.4 ​其他方法：​​

• ​void clear() ​从此映射中移除所有映射关系（可选操作）。 

• ​boolean containsKey(Object key) ​ 如果此映射包含指定键的映射关系，则返回 true。

• ​boolean containsValue(Object value)​   如果此映射将一个或多个键映射到指定值，则返回 true。

• ​boolean isEmpty() ​ 如果此映射未包含键-值映射关系，则返回 true。 

• ​V remove(Object key)  ​如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 

• ​int size() ​返回此映射中的键-值映射关系数。

import java.util.HashMap;

/*

 * 其他方法  

 void clear() 从此映射中移除所有映射关系（可选操作）。

 boolean containsKey(Object key)  如果此映射包含指定键的映射关系，则返回 true。

 boolean containsValue(Object value)   如果此映射将一个或多个键映射到指定值，则返回 true。

 boolean isEmpty()  如果此映射未包含键-值映射关系，则返回 true。

 V remove(Object key)  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

 int size() 返回此映射中的键-值映射关系数。

 */

public class Demo {

public static void main(String[] args) {

//创建 HashMap

 HashMap<String,String > hashMap = new HashMap<>();

 // 保存角色名字和书名.   

 hashMap.put("东方不败", "<<笑傲江湖>>");

 hashMap.put("岳不群", "<<笑傲江湖>>");

 hashMap.put("林平之", "<<笑傲江湖>>");

 hashMap.put("乔峰", "<<天龙八部>>");

 hashMap.put("段誉", "<<天龙八部>>");

 hashMap.put("虚竹", "<<天龙八部>>");

 System.out.println(hashMap.containsKey("乔峰"));

 System.out.println(hashMap.containsKey("梅超风"));

 System.out.println("=======");

 System.out.println(hashMap.isEmpty());

 //hashMap.clear();

// System.out.println(hashMap);

 String remove = hashMap.remove("乔峰");

 System.out.println(remove);

 System.out.println(hashMap);

}

}

​Collection<V> values()​    //返回所有值的集合

​​import​ java.util.Collection;​

​​import​ java.util.HashMap;​

​​import​ java.util.Set;​

​/*​

​ * 遍历方式1 :  通过键的集合,获取值 .​

​ * 演示方法 Collection<V> values()  ​  ​//返回所有值的集合​

​ */​

​​public​ ​class​ Demo3 {​

​​public​ ​static​ ​void​ main(String[] args) {​

​// 创建 HashMap 对象​

​HashMap<String, String> hashMap = ​new​ HashMap<>();​

​// 添加 元素 put 方法​

​hashMap.put("大郎", "金莲"); // {大郎=金莲}​

​hashMap.put("西门", "金莲"); // {西门=金莲, 大郎=金莲}​

​hashMap.put("老王", "柳岩");​

​Set<String> keySet = hashMap.keySet();​

​​for​ (String key : keySet) {​

​String value = hashMap.get(key); // 通过 键 获取值​

​System.​​out​​.println(key + " -- " + value);​

​}​

​// 打印所有的值​

​Collection<String> values = hashMap.values(); // 应用不多 .​

​​for​ (String v : values) {​

​System.​​out​​.println(v);​

​}​

​}​

​}​

​1.1.5 ​遍历键值方法（遍历方式1）​​

键找值方式：即通过元素中的键，获取键所对应的值

操作步骤与图解：

​1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键​

​2.遍历键的Set集合，得到每一个键​

​3.根据键，获取键所对应的值​

​代码演示：​

​​public​ ​class​ MapDemo {​

​​public​ ​static​ ​void​ main(String[] args) {​

​//创建Map对象​

​Map<String, String> map = ​new​ HashMap<String,String>();​

​//给map中添加元素​

​map.put("邓超", "孙俪");​

​map.put("李晨", "范冰冰");​

​map.put("刘德华", "柳岩");​

​//获取Map中的所有key​

​Set<String> keySet = map.keySet();​

​//遍历存放所有key的Set集合​

​Iterator<String> it =keySet.iterator();​

​​while​(it.hasNext()){​

​//得到每一个key​

​String key = it.next();​

​//通过key获取对应的value​

​String value = map.get(key);​

​System.​out​.println(key+"="+value);​

​}​

​}​

​}​

import java.util.Collection;

import java.util.HashMap;

import java.util.Set;

/*

 * 遍历方式1 :  通过键的集合,获取值 .

 * 演示方法 Collection<V> values()    //返回所有值的集合

 */

public class Demo3 {

public static void main(String[] args) {

// 创建 HashMap 对象

HashMap<String, String> hashMap = new HashMap<>();

// 添加 元素 put 方法

hashMap.put("大郎", "金莲"); // {大郎=金莲}

hashMap.put("西门", "金莲"); // {西门=金莲, 大郎=金莲}

hashMap.put("老王", "柳岩");

Set<String> keySet = hashMap.keySet();

for (String key : keySet) {

String value = hashMap.get(key); // 通过 键 获取值

System.out.println(key + " -- " + value);

}

    fun1(hashMap);

// 打印所有的值

//Collection<String> values = hashMap.values(); // 应用不多 .

for (String v : values) {

System.out.println(v);

}

}

private static void fun1(HashMap<String, String> hashMap) {

// 获取所有的key

Set<String> keySet = hashMap.keySet();

for (String key : keySet) {

String value = hashMap.get(key); // 通过 键 获取值

System.out.println(key + " -- " + value);

}

}

}

​1.1.6 ​遍历方式1练习-菜单：​​

/*

 *  菜品类. 名字 ,价格, id.   corsh  顶配的类.

 */

public class Cai {

private String name; // 菜名

private double price ;//价格

private String id ; // 菜id .   001

public Cai() {

super();

}

public Cai(String name, double price, String id) {

super();

this.name = name;

this.price = price;

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

@Override

public String toString() {

return  id + "--[" + name +":"+ price+"]" ;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((id == null) ? 0 : id.hashCode());

result = prime * result + ((name == null) ? 0 : name.hashCode());

long temp;

temp = Double.doubleToLongBits(price);

result = prime * result + (int) (temp ^ (temp >>> 32));

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Cai other = (Cai) obj;

if (id == null) {

if (other.id != null)

return false;

} else if (!id.equals(other.id))

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price))

return false;

return true;

}

}

import java.util.HashMap;

import java.util.Set;

/*

 * map保存 元素, 键 String id , 值  Cai 对象 .

 */

public class Demo4 {

public static void main(String[] args) {

//创建map

HashMap<String,Cai> hashMap = new HashMap<>();

//创建 菜对象  

Cai cai = new Cai("香菇油菜", 8.8, "001");

Cai cai2 = new Cai("耗油西红柿鸡蛋豆腐",28.8, "002");

Cai cai3 = new Cai("醋溜白菜",18.8, "003");

Cai cai4 = new Cai("皮蛋豆腐",28.8, "004");

//添加元素

hashMap.put("001", cai);

hashMap.put("002", cai2);

hashMap.put("003", cai3);

hashMap.put("004", cai4);

System.out.println(hashMap);

// 遍历map

Set<String> keySet = hashMap.keySet();

for (String key  : keySet) {

Cai c  = hashMap.get(key);

System.out.println(key +" -- "+ c.getName() +":"+c.getPrice());  

}

}

}

​1.1.7 ​Entry键值对对象​​

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

• Entry是Map接口中提供的一个静态内部嵌套接口。

• getKey()方法：获取Entry对象中的键

• getValue()方法：获取Entry对象中的值

• entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

​1.1.8 ​Map集合遍历键值对方式​​（​​遍历方式2​​）​​

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry对象中的键与值。

​​public​ ​class​ MapDemo {​

​​public​ ​static​ ​void​ main(String[] args) {​

​//创建Map对象​

​Map<String, String> map = ​new​ HashMap<String,String>();​

​//给map中添加元素​

​map.put("邓超", "孙俪");​

​map.put("李晨", "范冰冰");​

​map.put("刘德华", "柳岩");​

​//获取Map中的所有key与value的对应关系​

​Set<Map.Entry<String,String>> entrySet = map.entrySet();​

​//遍历Set集合​

​Iterator<Map.Entry<String,String>> it =entrySet.iterator();​

​​while​(it.hasNext()){​

​//得到每一对对应关系​

​Map.Entry<String,String> entry = it.next();​

​//通过每一对对应关系获取对应的key​

​String key = entry.getKey();​

​//通过每一对对应关系获取对应的value​

​String value = entry.getValue();​

​System.​out​.println(key+"="+value);​

​}​

​}​

​}​

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

​1.1.9 ​遍历方式2-练习​​

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

/*

 *  遍历方式2: 拿一对. Entry  一个Entry 包含一对儿元素.   

 *  getKey:获取键  

 *  getValue : 获取值

 */

public class Demo {

public static void main(String[] args) {

//创建 HashMap

 HashMap<String,String > hashMap = new HashMap<>();

 // 保存角色名字和书名.   

 hashMap.put("东方不败", "<<笑傲江湖>>");

 hashMap.put("岳不群", "<<笑傲江湖>>");

 hashMap.put("林平之", "<<笑傲江湖>>");

 hashMap.put("乔峰", "<<天龙八部>>");

 hashMap.put("段誉", "<<天龙八部>>");

 hashMap.put("虚竹", "<<天龙八部>>");

 // 第二种方式遍历map

 // a.获取 键值对 对象的集合 , entrySet  .

 Set<Entry<String,String>> entrySet = hashMap.entrySet();

 // b.通过 entry 的方法, 获取键, 和 值

 for (Entry<String, String> entry : entrySet) {

String key = entry.getKey();

String value = entry.getValue();

System.out.println(key +" -- "+ value);

}

}

}

​1.1.10 ​HashMap​​存储自定义类型键值​​

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

• 学生类

​​public​ ​class​ Student {​

​​private​ String name;​

​​private​ ​int​ age;​

​//编写构造方法，文档中已省略​

​//编写get,set方法，文档中已省略​

​//编写toString方法，文档中已省略​

​}​

• 测试类

​​public​ ​class​ HashMapTest {​

​​public​ ​static​ ​void​ main(String[] args) {​

​//1,创建hashmap集合对象。​

​Map<Student,String> map = ​new​ HashMap<Student,String>();​

​//2,添加元素。​

​map.put(​new​ Student("lisi",28), "上海");​

​map.put(​new​ Student("wangwu",22), "北京");​

​map.put(​new​ Student("zhaoliu",24), "成都");​

​map.put(​new​ Student("zhouqi",25), "广州");​

​map.put(​new​ Student("wangwu",22), "南京");​

​//3,取出元素。键找值方式​

​Set<Student> keySet = map.keySet();​

​​for​(Student key : keySet){​

​String value = map.get(key);​

​System.​​out​​.println(key.toString()+"....."+value);​

​}​

​//取出元素。键值对方式​

​Set<Map.Entry<Student, String>> entrySet = map.entrySet();​

​​for​ (Map.Entry<Student, String> entry : entrySet) {​

​Student key = entry.getKey();​

​String value = entry.getValue();​

​System.​​out​​.println(key.toString()+"....."+value);​

​}​

​}​

​}​

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。

• 如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

第2章 容器工具类

​​2.1 Collections​​

Collections是集合工具类，专门对集合进行操作。常用方法：

• public static <T> void sort(List<T> list) // 集合元素排序（自然顺序）

​//排序前元素list集合元素 [33,11,77,55]​

​Collections.sort( list );​

​//排序后元素list集合元素 [11,33,55,77]​

• public static void shuffle(List<?> list) //  集合元素存储位置打乱

​//list集合元素 [11,33,55,77]​

​Collections.shuffle( list );​

​//使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱​

• public static <T> int binarySearch(List<?> list,T key) //查找元素索引

​​2.2 Arrays​​

Arrays是数组工具类，常用方法：

public static int binarySearch(Xxx[] a,Xxx key)  //查找元素索引

public static void sort(Xxx[] a)     //排序

public static String toString(Xxx[] a)   //返回字符串内容

集合ArrayList转为数组的方法为ArrayList的以下两个方法：

public Object[] toArray()       //集合转数组

public <T> T[] toArray(T[] a)

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

/*

 * Collections  和 Arrays   

 */

public class Demo {

public static void main(String[] args) {

// fun();

//fun2();

//fun3(arrayList);

ArrayList<Integer> arrayList = new ArrayList<>();

arrayList.add(255);

arrayList.add(5);

arrayList.add(5);

arrayList.add(5);

arrayList.add(5);

arrayList.add(15);

arrayList.add(200);

Object[] array = arrayList.toArray();

System.out.println(array);

String string = Arrays.toString(array);

System.out.println(string);

}

private static void fun3(ArrayList<Integer> arrayList) {

Collections.sort(arrayList);

System.out.println(arrayList);

int binarySearch = Collections.binarySearch(arrayList, 15);

System.out.println(binarySearch);

}

private static void fun2() {

ArrayList<String> arrayList = new ArrayList<>();

arrayList.add("5");

arrayList.add("255");

arrayList.add("15");

arrayList.add("200");

System.out.println(arrayList);

Collections.sort(arrayList);

System.out.println(arrayList);

}

private static void fun() {

ArrayList<Integer> arrayList = new ArrayList<>();

arrayList.add(5);

arrayList.add(255);

arrayList.add(15);

arrayList.add(200);

System.out.println(arrayList);

Collections.sort(arrayList);

System.out.println(arrayList);

}

}

​​2.3 可变参数​​

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

​修饰符 返回值类型 方法名(参数类型... 形参名){  }​

其实这个书写完全等价与

​修饰符 返回值类型 方法名(参数类型[] 形参名){  }​

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：    

​​public​ ​class​ ParamDemo {​

​​public​ ​static​ ​void​ main(String[] args) {​

​​int​[] arr = {21,89,32};​

​​int​ sum = ​add​(arr);​

​System.​out​.println(sum);​

​sum = ​add​(21,89,32);//可变参数调用形式​

​System.​out​.println(sum);​

​}​

​//JDK1.5之后写法​

​​public​ ​static​ ​int​ add(​int​...arr){​

​​int​ sum = 0;​

​​for​ (​int​ i = 0; i < arr.length; i++) {​

​sum += arr[i];​

​}​

​​return​ sum;​

​}​

​//原始写法​

​/*​

​public static int add(int[] arr) {​

​int sum = 0;​

​for (int i = 0; i < arr.length; i++) {​

​sum += arr[i];​

​}​

​return sum;​

​}​

​*/​

​}​

• 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。可变参数方法本质是数组，所以不可以与数组类型参数重载。

public class Demo2 {

public static void main(String[] args) {

//  int add = add(10,20);

//  System.out.println(add);

//  int add2 = add(10,20,30);

//  

int add3 = add(10,20,30 , 100,200,300 );

System.out.println(add3);

}

// public static int add(int i,int j){

//  return i + j;

// }

// public static int add(int i,int j , int h ){

//  return i + j  + h ;

// }

//

// public static int add(int i,int j ,int h , int g ){

//  return i + j  + h + g;

// }

public static int add(int a  ,int​...​  x){

System.out.println("可变参数方法 ");

System.out.println(a);

// x 就是 一个数组.

System.out.println(x[0]);

 for (int i = 0; i < x.length; i++) {

a +=x[i] ;

}

return a;

}

}

​​2.4 静态导入​​

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入，而在日常开发中几乎没有人使用。

静态导入格式：

import static XXX.YYY;   导入后YYY可直接使用。

import java.util.ArrayList;

import java.util.Collections;

import  static java.util.Collections.shuffle;

/*

 * 静态导入

 * 在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。

 * 在源码中经常会出现静态导入，而在日常开发中几乎没有人使用。

 * 静态导入格式：

 * import static XXX.YYY;   导入后YYY可直接使用。

 */

public class Demo3 {

public static void main(String[] args) {

ArrayList<Object> arrayList = new ArrayList<>();

arrayList.add("7");

arrayList.add("8");

arrayList.add("9");

arrayList.add("17");

System.out.println(arrayList);

shuffle(arrayList);

System.out.println(arrayList);

}

public static void shuffle( ArrayList<Object>  al){

System.out.println("自己的 ");

}

}

第3章 集合框架总结

​​3.1 集合体系图​​

​​
​​

第4章 Java集合框架知识总结

​​4.1 Collection:​​

​​4.1.1 List 接口 :​​

List:里面对象全部是有序的（通过三种方法来遍历）
ArrayList,LinkedList,Vertor

​​ArrayList：本质上 ArrayList 里维护的就是动态可变长度的数组。​​

​​　​常用方法：
 　　增：add(4) 对象 位置+对象  集合 集合+位置。
　　 删：remove（2）下标删对象,直接删对象。
 　　改：set(1) 下标  对象。
　　 查：get() 下标得对象, indexOf()对象得下标。

 　　contains()必须是同一个对象才返回true  iterator() size()。

​​LinkedList:本质上 LinkedList 里维护的是动态可变长度的双向链表​​

　常用方法：
 　　增：add(4) 对象 位置，对象 集合 位置，集合 +2（对象） 新增：addFirst() addLast()。
 　　删：remove（2）下标删对象，直接删对象 +2（对象） 新增：removeFirst() removeLast()。
 　　改：set(1) 下标 对象
 　　查：get() 下标得对象 indexOf()对象得下标 +2（对象） 新增：getFirst() getLast()。

  　　 contains() iterator()size()。

​​Vertor：线程安全，执行效率非常低​​

​​ ​​　常用方法：
 　　增：add(4) 对象 位置，对象 集合 位置，集合 addElement(对象) insertElement(对象)。
　　 删：remove（2）下标删对象，直接删对象 removeElement(对象) removeAllElment()。
　　 改：set(1) 下标，对象 setElementAt(对象,下标)。
　　 查：get() 下标得对象 indexOf()对象得下标。

 　　 contains() iterator() size()。

　　 iterator() :hasNext()判断有没有下一个元素。
 　　next()获取下一个元素。
 　　remove()在迭代器中移除元素。

​4.1.2 ​Set接口：​​

不允许出现重复的方法，允许有一个null值，都没有顺序索引(通过增强for循环和迭代来遍历)，所以查不了，改不了。
　　要想存入Set，必须重写equals()和hashCode()方法（String已经重写），两者返回值都为真表明相等，比的是内容。
　　其实一个equals()就可以，但是当存入数据量大的时候，一一比较效率非常低，加入hashCode，就是来判断不是同一个对象的。
　　用hashCode()无法判断是同一个对象。

　　因为所有的已经存入的对象保存在一个table里面，比较的效率非常高。
      如果已存在，是不能再往里面添加(而Map是后面覆盖前面)。

​​HashSet:​​

​　　内部维护的是HashMap的一个实例，存的是key的集合。
　　元素的表现是无序的，但一旦添加完元素，元素位置是固定的(也就是说你无论再运行多少遍，这个显示的顺序都一样)，再添加新元素，不会影响前面元素的位置，给添加的元素分配位置，只要不打乱前面的元素位置，前面的元素位置就不会再发生变化。

　常用方法：
　　增：add(对象)。
　　删:clear()移除所有对象 ，remove(对象)。
　　改：没有，没下标。
　　查：除了遍历出所有，没有，因为没有下标。
　　contains()内容相同就返回true  iterator() size()

​​LinkedHashSet:​​

HashSet的子类，只有四个新增的构造器，没有其他新增方法，内部维护的是LinkedHashMap的一个实例，是双向链表结构。
　　元素存放顺序和迭代顺序一样（按顺序）。
　　常用方法同HashSet。

​​TreeSet：​​

 　 确保元素处于排序状态,底层为树结构。使用它可以从Set中提取有序的序列。

 　 两种排序方法：自然排序和定制排序，默认采用自然排序。
 　 自然排序：会调用集合元素的comparaTo（对象）方法来比较元素之间的大小关系，然后把集合按升序排列（实现 Comparable接口）。
 　 定制排序：通过Comparator(比较器)接口，需要重写compara(对象，对象),要实现定制排序，需要把comparator实例作为形 参传给TreeSet的构造器。
 　 要想把元素放到TreeSet中，必须实现Comparable接口，同时必须实现comparaTo方法。
 　 或者继承Comparator接口，然后重写compara方法。
　  first() last()lower(对象) heigher(对象) 其他视图方法。

​4.2 ​Map集合：​​

维护"键值对"的关联性
　 key,value 必须都为引用类型数据
 　key不可以重复（后覆盖先），保存在Set集合中（因为Set集合里面的元素不能重复，所以，，还必须重写equals和hashCode()方法）,经常用String，因为都已经实现
 　put(key,value) remove(key) putAll(Map map) clear()清除所有 。(基本全是通过Set，也就是key，唯一性)。

　获取key的集合：
 　　  Set<> set= map.keySet();Iterator<> it=set.iterator();get(key) 迭代器。

　获取value的集合：
 　　   Collection values() 迭代器，增强for都可以。

   Entry集合：
  　　 Set<Entry<,>> entrys = map.entrySet();
 　　  for(Entry<String,String> entry : entrys)迭代器，增强for都可以
  　　 get(key) containsKey(key) containsValue(value) size isEmpty() equals（）比较的当然是内容啦

​4.2.1 ​HashMap:​​

​​　​　允许key和value的值为null。
　　表现是无序的 比较key相等和Set一样。
　　LinkedHashMap:子类，有序的（等同上面的HashSet和LinkedHashSet）只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。​

​4.2.2 ​TreeMap:​​

有序。 基于红黑树数据结构的实现。查看"键"或"键值对"时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。

​4.2.3 ​HashTable:​​

 　　最古老，不允许key和value值为null

​​Properties：​​

　　是HashTable的子类，用来处理文件的属性。
　　文件属性必须是key_value,必须都是字符串，存取数据用put(key,value),get(key)。

​4.3 ​Collections：​​

​　　集合操作类
　　排序：
　　Collections.reverse(list) 反序
　　Collections.shuffle()随机
　　Collections.sort()自然顺序升序
　　Collections.swap（对象，位置，位置）交换
　　查找：
　　max()
　　min()frequency(Collections,对象)；
　　copy(目标list，srclist)
　　Collections.repalceAll(list,old对象,new对象)

　　synchronizedXXX();
　　synchronizedList(list)

​4.4 ​总结：         ​​

       1.线程安全的是vertor和HashTable。
       2. List：允许重复的，全部有序（允许null）。
　　3.Set: HashSet无序的表现（一个null），其中HashSet的子类LinkedHashSet有序，TreeSet有序。
　　4.Map：HashMap无序的表现（一次null），其中HashMap的子类LinkedHashMap有序,TreeMap有序，HashTable无序（不能为null）。

　　5.ArrayList：查询效率高，增删效率低。
　　6.LinkedList:查询效率低，增删效率高。
　　7.Vertor:执行效率非常低。

　　8.HashSet:良好的增删查询性能。
　　9.LinkedHashSet:查询效率低，插入效率比HashSet低。

　　10.Map对象高于List。因为Map除了Value外还需要一个Object的Key，从而增大了Map的容量。

  　  11. HashSet,HashMap的元素都是无序的，而他们的子类都是有序的，双向链表，非常类似，因为HashMap中的唯一的约束就是key，而 key恰恰是被HashMap维护的
       12.TreeSet和TreeMap都是有序的，两个很类似。

       13. 如果Map知道了Key,List知道了index，其性能在一百万条数据中无多大差别。

　　 14.List按对象进入的顺序保存对象，不做排序或编辑操作。Set对每个对象只接受一次,并使用自己内部的排序方法(通常，你只关心某个元素是否属于 Set,而不关心它的序否则应该使用List)。Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的 顺序。如果添加元素的顺序对你很重要，应该使LinkedHashSet或者LinkedHashMap。

      15.HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显着提高性能。

​​4.5 简单数据结构​​

数据结构指的数据存储和组织方式，如日常的容器中，有方形、圆形、存放液体、固体，都是。

我们在前边见到了多种不同结构的集合，每种集合有各自数据结构特点，总结如下：

数组结构：一块连续的存储区域

链表结构：每个元素指向下一个元素

队列结构：容器先进先出的规则

栈结构：容器先进后出规则

​​4.6 集合嵌套​​

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如单列集合嵌套、双列集合与单列集合嵌套、双列集合嵌套。

单列集合嵌套:

大学(List表示)有多个分校(list表示)，每个分校有多个班级(字符串)。

双列集合与单列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(List表示)

每个分校有多个班级(字符串)。

双列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(Map表示，key:班级名称、value 班级对象)

每个分校有多个班级(自定义班级类MyClass)。

如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

• ArrayList嵌套 ArrayList

​ArrayList< ArrayList<String> >​

​Collection< ArrayList<Integer> >​

• Map嵌套 ArrayList

​HashMap<String, ArrayList<Person>>​

​ArrayList< HashMap<String, String>>​

• Map集合嵌套

​HashMap<String, HashMap<String,String>>​

​HashMap<String, HashMap<Person,String>>​

第5章 模拟斗地主洗牌发牌

​5.1 ​案例介绍​​

按照斗地主的规则，完成洗牌发牌的动作。

具体规则：

1. 组装54张扑克牌

2. 将54张牌顺序打乱

3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

• 手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

​5.2 ​案例需求分析​​

• 准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

• 洗牌：

通过数字完成洗牌发牌

• 发牌：

将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

• 看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示 

​​

​5.3 ​实现代码步骤​​

首先，要修改java文件编码，由GBK修改为UTF-8，因为默认的字符编码GBK没有我们要的梅花、方片、黑桃、红桃(♠♥♦♣)等特殊字符。

​​import​ java.util.ArrayList;​

​​import​ java.util.Collections;​

​​import​ java.util.HashMap;​

​/*​

​ * 斗地主洗牌发牌排序​

​ */​

​​public​ ​class​ Poker {​

​​public​ ​static​ ​void​ main(String[] args) {​

​//准备花色​

​ArrayList<String> color = ​new​ ArrayList<String>();​

​color.add("♠");​

​color.add("♥");​

​color.add("♦");​

​color.add("♣");​

​//准备数字​

​ArrayList<String> number = ​new​ ArrayList<String>();​

​Collections.​addAll​(number,"3","4","5","6","7","8","9","10","J","Q","K","A","2");​

​//定义一个map集合：用来将数字与每一张牌进行对应​

​HashMap<Integer, String> map = ​new​ HashMap<Integer, String>();​

​​int​ index = 0;​

​//加入大小王​

​map.put(index++, "小☺");​

​map.put(index++, "大☻");​

​​for​ (String thisNumber : number) {​

​​for​ (String thisColor : color) {​

​map.put(index++, thisColor+thisNumber);​

​}​

​}​

​//一副54张的牌 ArrayList里边为0-53的数的新牌​

​ArrayList<Integer> cards = ​new​ ArrayList<Integer>();​

​​for​ (​int​ i = 0; i <= 53; i++) {​

​cards.add(i);​

​}​

​//洗牌​

​Collections.​shuffle​(cards);​

​//创建三个玩家和底牌​

​ArrayList<Integer> iPlayer = ​new​ ArrayList<Integer>();​

​ArrayList<Integer> iPlayer2 = ​new​ ArrayList<Integer>();​

​ArrayList<Integer> iPlayer3 = ​new​ ArrayList<Integer>();​

​ArrayList<Integer> itCards = ​new​ ArrayList<Integer>();​

​//遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和底牌中​

​​for​ (​int​ i = 0; i < cards.size(); i++) {​

​​if​(i>=51) {​

​iCards.add(cards.get(i));​

​} ​else​ {​

​​if​(i%3==0) {​

​iPlayer.add(cards.get(i));​

​}​else​ ​if​(i%3==1) {​

​iPlayer2.add(cards.get(i));​

​}​else​ {​

​iPlayer3.add(cards.get(i));​

​}​

​}​

​}​

​//对每个人手中的牌排序​

​Collections.​sort​(iPlayer);​

​Collections.​sort​(iPlayer2);​

​Collections.​sort​(iPlayer3);​

​//对应数字形式的每个人手中的牌，定义字符串形式的牌​

​ArrayList<String> sPlayer = ​new​ ArrayList<String>();​

​ArrayList<String> sPlayer2 = ​new​ ArrayList<String>();​

​ArrayList<String> sPlayer3 = ​new​ ArrayList<String>();​

​ArrayList<String> sCards = ​new​ ArrayList<String>();​

​​for​ (Integer key : iPlayer) {​

​sPlayer.add(map.get(key));​

​}​

​​for​ (Integer key : iPlayer2) {​

​sPlayer2.add(map.get(key));​

​}​

​​for​ (Integer key : iPlayer3) {​

​sPlayer3.add(map.get(key));​

​}​

​​for​ (Integer key : iCards) {​

​sCards.add(map.get(key));​

​}​

​//看牌​

​System.​​out​​.println(sPlayer);​

​System.​​out​​.println(sPlayer2);​

​System.​​out​​.println(sPlayer3);​

​System.​​out​​.println(sCards);​

​}​

​}​

第6章 本日自习作业：

​6.1 ​知识点相关题​​

​6.1.1 ​掌握​​Arrays类的常用方法；​​

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

• 定义int数组，初始化为：{235,676,90,3,43,65,52,34,36,,776,9,86}

• 调用Arrays类的相关方法对数组进行升序排序；

• 调用Arrays类的查找方法，在数组中查找元素：776，并打印查找结果；

• 调用Arrays类的toString()方法打印这个int数组

​6.1.2 ​冒泡排序​​、​​选择排序​​、​​二分查找的程序实现​​；​​

​6.1.3 ​简述什么是Map集合，最常用的操作有哪些​​

​6.1.4 ​参照集合体系图，说出所有常用集合及常用集合的相关方法​​

​6.1.5 ​产生​​10​​个​​1-20​​之间的随机数要求随机数不能重复案例。​​

​6.1.6  ​键盘录入多个数据在控制台输出最大值案例。​​

​6.1.7 ​ArrayList​​集合的​​toString()​​方法源码阅读​​

​6.1.8 ​键盘录入多个数据，按数据从小到大的顺序打印到控制台。​​

​6.1.9 ​熟练使用带可变参数的方法(提示：Arrays类与Collections各一个)​​

​6.1.10 ​描述4种数据结构的特点​​

数组结构：一块连续的存储区域

链表结构：每个元素指向下一个元素

队列结构：容器先进先出的规则

栈结构：容器先进后出规则

​6.1.11 ​请你统计出,每个字母出现的次数.​​

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

/*

 * String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

 *

 * 请你统计出,每个字母出现的次数.

 * a - 2

 * l - 1

 * i - 1

 * j - 1

 *

 * 1.遍历字符串

 * 2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer  

 * 3.map ,即是结果, 遍历 map .

 *

 */

public class Test {

public static void main(String[] args) {

String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

//创建map

HashMap<Character,Integer> hashMap = new HashMap<>();

// 1.遍历字符串   

for (int i = 0; i < s.length() ; i++) {

char key   = s.charAt(i);  // ch 为每一个字母.

//2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer  

//判断 是否包含key , 再保存.

if (hashMap.containsKey(key)) {

 // 包含,存过

//Integer count  = hashMap.get(key);// 获取之前次数,

//count++;  // + 1

hashMap.put(key, hashMap.get(key) + 1); // 再 保存

}else {

// 不包含 , 第一次存.

hashMap.put(key, 1);

}

}

// 3. 遍历map

Set<Entry<Character,Integer>> entrySet = hashMap.entrySet();

System.out.println( "字母  -- 次数 "  );

for (Entry<Character, Integer> entry : entrySet) {

System.out.println(entry.getKey() +" -- "+ entry.getValue());

}

}

}

​6.2 ​代码题：​​

​6.2.1 ​创建一个Map集合，添加数据进行测试，使用Map集合的两种遍历方式进行遍历​​

​6.2.2 ​Map集合（相同键与不同键）​​

定义一个测试类，在测试类中定义main()方法，按以下要求编写代码

1.实例化一个Map<String,String>集合

2.向集合内添加以下内容：

"NO01"，"安森"

"NO01"，"凯特"

"NO02"，"安森"

3.遍历集合，观察打印结果，请说明

4.如果存储“相同的键”时，会发生什么情况

5.如果存储“不同的键”，“相同的值”时，会怎样？

​6.2.3 ​遍历Map​​

定义Student类，要求有如下成员：

成员属性(私有):

姓名(String类型)

性别(String类型)

年龄(int 类型)

构造方法：

无参

全参

成员方法：

get/set方法

    (有兴趣，可以将toString()方法也添加上)

定义类测试类，在测试类中定义main()方法，按以下要求编写代码：

• 实例化一个Map<String,Student>集合

• 向集合中添加以下元素：

“it001”,new Student(“王宝强”,’男’,20);

“it002”,new Student(“马蓉”,’女’,18);

“it003”,new Student(“宋喆”,’男’,19);

• 使用两种方式遍历这个Map

​6.2.4 ​使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键​​

定义类Cat类，要求有以下成员：

成员属性(私有):

姓名

性别

年龄

构造方法：

无参

全参

成员方法：

get/set方法

定义一个测试类，在测试类中定义main()方法：

l在main()中按以下要求编写代码：

• 实例化一个Map<Cat,String>集合；

• 向集合中添加以下元素：

new Cat(“波斯猫”,’公’,2)，”No01”

new Cat(“折耳猫”,’母’,1)，”No02”

new Cat(“折耳猫”,’母’,1)，”No03”

• 使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键

​6.2.5 ​定义类，定义main()方法，按以下要求编写代码：定义一个ArrayList<Integer>，添加一些整数；使用Collections类的相关方法将内部元素排序；定义一个HashSet<Integer>，添加一些元素；请问是否可以使用同样的方式排序？为什么？将ArrayList内的元素打乱顺序；打印集合​​

​6.2.6 ​定义一个Map，存储如下内容：增加一位新老师Allen教JDBC;Lucy改为教CoreJava​​，​​使用两种方式遍历集合；输出所有教JDBC的讲师​​

定义一个Map，存储如下内容：

老师  课程

Tom  CoreJava

John  Oracle

Susan Oracle

Jerry  JDBC

Jim  Unix

Kevin    JSP

Lucy  JSP

完成以下要求：

1).增加一位新老师Allen教JDBC;

2).Lucy改为教CoreJava

3).使用两种方式遍历集合；

4).输出所有教JDBC的讲师

​6.2.7 ​静态方法，list集合​​

1.定义一个类Demo；

2.内部定义一个静态方法asList，此方法可以接收任意多的String类型参数，方法功能：将所有String参数的值存储到一个具有String泛型的List集合中，并将此集合返回；

3.在Demo类中定义main()方法，并调用asList方法获取返回值，并遍历集合

​6.2.8 ​抽到明牌者为地主​​

成龙，甄子丹，李连杰三个人打斗地主，三人约定，洗牌后，随机抽取一张"明牌"并夹在中间；然后依次抓牌，谁抓到这张便自动作为地主，并收取最后三张。

要求：请用程序实现这一过程，最后打印地主名，以及三个人的牌(要求排序)；

思路：

  1.定义一个Map集合存储一副扑克牌；List存储编号；

  2.洗牌；

  3.随机抽取一个索引(该值必须在倒数三张之前)，用于表示"明牌"，在发牌时谁抓到这一张便作为"地主"；

  4.依次给三个人(成龙，甄子丹，李连杰)发牌，并监督谁作为地主；地主自动收取最后三张。

  5.打印地主名；

  6.最后以排序后的方式打印每个人手里的牌

长按指纹，识别二维码，一键关注Java，大数据

长按指纹，识别二维码，一键关注Python

长按指纹，识别二维码，一键关注产品经理