文章目录

  • 31 集合进阶
    • 31.1 Collection集合
      • Iterator迭代器
    • 31.2 List集合
      • 1. ListIterator
      • 2. 增强for循环
    • 31.3 数据结构
      • 1. 栈
      • 2. 队列
      • 3. 数组
      • 4. 链表
      • 5. 哈希表
    • 31.4 ArrayList
    • 31.5 LinkedList
    • 31.6 Set集合
    • 31.7 哈希值
    • 31.8 HashSet集合
    • 31.9 LinkedHashSet集合
    • 31.10 TreeSet集合
    • 31.11 自然排序Comparable的使用
    • 31.12 比较器排序Comparator的使用
  • 32 泛型
    • 32.1 泛型概述
    • 32.2 泛型类
    • 32.3 泛型方法
    • 32.4 泛型接口
    • 32.5 类型通配符
    • 32.6 可变参数
    • 32.7 可变参数的使用
  • 33 Map集合
    • 33.1 Map集合概述
    • 33.2 Map集合的基本功能
    • 33.3 Map集合的获取功能
    • 33.4 Map集合的遍历
    • 33.5 Collections
    • 33.6 模拟斗地主

黑马全套Java教程（一）
黑马全套Java教程（二）
黑马全套Java教程（三）
黑马全套Java教程（四）
黑马全套Java教程（五）
黑马全套Java教程（六）
黑马全套Java教程（七）

本博客从视频d220开始，视频链接

31 集合进阶

集合类的特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类体系结构如下：

31.1 Collection集合

package myCollection.Demo1;import java.util.ArrayList;
import java.util.Collection;/*创建Collection集合的对象多态的方式ArrayList()*/
public class Demo1 {public static void main(String[] args) {//创建Collection集合的对象Collection<String> c =  new ArrayList<String>();//添加元素c.add("hello");c.add("world");c.add("java");System.out.println(c);}
}

Collection集合常用方法

package myCollection.Demo1;import java.util.ArrayList;
import java.util.Collection;/*Collection集合常用方法：bololean add(E e)：添加元素boolean remove(Object 0)：从集合中移除指定的元素void clear()：清空集合中的元素boolean contains(Object o)：判断集合中是否存在指定的元素boolean isEmpty()：判断集合是否为空int size()：集合的长度，也就是集合中元素的个数alt+7：  打开一个窗口，能够看到类的所有信息*/
public class Demo2 {public static void main(String[] args) {//创建集合对象Collection<String> c = new ArrayList<String>();//1.add()添加元素System.out.println("add()：" + c.add("hello")); //调用add方法永远返回truec.add("world");c.add("java");System.out.println(c);System.out.println("----------------------");//2.remove()移除元素System.out.println(c.remove("hello"));System.out.println(c.remove("javaee"));System.out.println(c);System.out.println("---------------------");//4.contains()判断是否有这个元素System.out.println(c.contains("world"));System.out.println(c);System.out.println("-----------------------");//6.size()计算长度System.out.println(c.size());System.out.println("_______________________");//3.clear()清空集合c.clear();System.out.println(c);System.out.println("--------------------");//5.isEmpty判断是否为空System.out.println(c.isEmpty());}
}

Iterator迭代器

Collection集合的遍历

package myCollection.Demo2;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;/*Iterator：迭代器，集合的专用遍历方式Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的Iterator中的常用方法E next()：返回迭代器中的下一个元素boollean hasNext():如果迭代器具有更多元素，则返回true*/
public class Demo1 {public static void main(String[] args) {//创建集合对象Collection<String> c = new ArrayList<String>();//添加元素c.add("hello");c.add("world");c.add("java");Iterator<String> it = c.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);   //实现遍历集合}}
}

集合使用步骤

案例：Collection集合存储学生对象并遍历

Studnet.java

package myCollection.Demo3;public class Stduent {private String name;private int age;public Stduent() {}public Stduent(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;}@Overridepublic String toString() {return "Stduent{" +"name='" + name + '\'' +", age=" + age +'}';}
}

Demo1.java

package myCollection.Demo3;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class Demo1 {public static void main(String[] args) {//创建Collection集合对象Collection<Stduent> c = new ArrayList<Stduent>();//创建学生对象Stduent s1 = new Stduent("林青霞", 30);Stduent s2 = new Stduent("张曼玉", 33);Stduent s3 = new Stduent("风清扬", 35);//添加到集合c.add(s1);c.add(s2);c.add(s3);//遍历集合：迭代器方式Iterator<Stduent> it = c.iterator();while(it.hasNext()){System.out.println(it.next());}}
}

31.2 List集合

有序，可重复

package myList.Demo1;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*List集合特点有序：存储和取出的元素顺序一致可重复：存储的元素可以重复*/
public class Demo1 {public static void main(String[] args) {//创建对象List<String> list = new ArrayList<>();//添加元素list.add("hello");list.add("world");list.add("java");list.add("hello");System.out.println(list);//遍历Iterator<String>  it = list.iterator();while(it.hasNext()){System.out.println(it.next());}}
}

List集合特有方法

package myList.Demo1;import java.util.ArrayList;
import java.util.List;/*List集合特有方法：void add(int index, E element)：在此集合中的指定位置插入指定的元素E remove(int index):删除指定索引处的元素，返回被删除的元素E set(int index, E element):修改指定索引处的元素，返回被修饰的元素E get(int index):返回指定索引处的元素*/
public class Demo2 {public static void main(String[] args) {//创建集合对象List<String> list = new ArrayList<>();//添加元素list.add("hello");list.add("world");list.add(2, "java");//1.删除list.remove("hello");  //删除指定元素System.out.println(list);System.out.println("-----------------");list.remove(1);     //删除指定索引处的元素System.out.println(list);System.out.println("------------------");list.set(0, "hello");System.out.println(list);System.out.println("--------------");list.add(1,"world");//        System.out.println(list.get(0));for(int i=0;i< list.size();i++){String s = list.get(i);System.out.println(s);}}
}

案例：List集合存储学生对象并遍历

学生类的代码上面有，这里便不再重复

package myList.Demo2;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class Demo1 {public static void main(String[] args) {//创建集合对象List<Student> list = new ArrayList<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);//集合添加学生list.add(s1);list.add(s2);list.add(0, s3);//遍历：迭代器和for遍历Iterator<Student> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}System.out.println("---------------------------");for (int i = 0; i < list.size(); i++) {Student s = list.get(i);System.out.println(s.getName() + "," + s.getAge());}}
}

并发修改异常

package myList.Demo3;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*需求：我有一个集合：List<String> list = new ArrauList<String>();里面有三个元素：hello world java遍历集合，得到每一个元素，看有没有world这个元素；如果有就添加一个javaee*/
public class Demo1 {public static void main(String[] args) {//创建集合对象List<String> list = new ArrayList<>();//集合中添加元素list.add("hello");list.add("world");list.add("java");//迭代器遍历Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();   //ConcurrentModificationException//System.out.println(s);if (s.equals("world")){list.add("javaee");}}System.out.println(list);}
}


但是for循环实现遍历便可行

package myList.Demo3;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class Demo1 {public static void main(String[] args) {//创建集合对象List<String> list = new ArrayList<>();//集合中添加元素list.add("hello");list.add("world");list.add("java");for (int i = 0; i < list.size(); i++) {String s = list.get(i);if (s.equals("world")) {list.add("javaee");break;}}System.out.println(list);}
}

1. ListIterator

package myList.Demo4;import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;/*ListIterator：列表迭代器通过List集合的ListIterator()方法得到，所以说它是List集合特有的迭代器用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置ListIterator中的常用方法E next():返回迭代中的下一个元素boolean hasNext():如果迭代具有更多元素，则返回trueE previous():返回列表中的上一个元素boolean hsaPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回truevoid add(E e):将指定的元素插入列表*/
public class Demo1 {public static void main(String[] args) {//创建集合对象List<String> list = new ArrayList<>();//添加元素list.add("hello");list.add("world");list.add("java");//遍历ListIterator<String> lit = list.listIterator();while (lit.hasNext()) {String s = lit.next();if(s.equals("world")){lit.add("javaee");}System.out.println(s);}System.out.println("------------------------");System.out.println(list);System.out.println("------------------------");while (lit.hasPrevious()) {   //逆向遍历，从后到前String s = lit.previous();System.out.println(s);}}
}

2. 增强for循环

package myList.Demo5;import java.util.ArrayList;
import java.util.List;/*增强for：简化数组和collection集合的遍历实现Iterator接口的类允许其对象称为增强for语句的目标它是JDK5之后出现的，其内部原理是一个Iterator迭代器格式：for(元素数据类型 变量名：数组或者Collection集合){//在此处使用变量即可，该变量就是元素}*/
public class Demo1 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5};for (int i : arr) {System.out.println(i);}System.out.println("---------------------");String[] strArr = {"hello", "world", "java"};for (String i : strArr) {System.out.println(i);}System.out.println("----------------------");List<String> list = new ArrayList<>();list.add("hello");list.add("world");list.add("java");//有三种遍历方式：for，迭代器（这里迭代器也有两种），增强forfor (String i : list) {System.out.println(i);}//内部原理是一个Iterator迭代器，下面代码会报错   ConcurrentModificationExceptionfor(String s : list){if(s.equals("world")){list.add("javaee");}}}
}

案例：List集合存储学生对象，用三种方式遍历

学生类对象代码这里便不再重复

package myList.Demo6;import java.util.*;public class Demo1 {public static void main(String[] args) {//创建集合对象List<Student> list = new ArrayList<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);//集合添加学生list.add(s1);list.add(s2);list.add(1, s3);System.out.println(list);//遍历//1.forfor (int i = 0; i < list.size(); i++) {Student s = list.get(i);System.out.println(s);}System.out.println("---------------------");//2.增强forfor (Student s : list) {System.out.println(s);}System.out.println("------------------------");//3.迭代器Iterator<Student> it = list.iterator();while (it.hasNext()) {Student s = it.next();System.out.println(s);}System.out.println("-------------------------");//4.ListIterator<Student> lit = list.listIterator();while (lit.hasNext()) {Student s = lit.next();System.out.println(s);}}
}

31.3 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
通常情况下，精心选中的数据结构可以的带来更高的运行或者存储效率

1. 栈

2. 队列

3. 数组

数组是一种查询快，增删慢的模型

查询数据通过索引定位，查询任意数据耗时相同，查询速度快

删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低

添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

4. 链表

链表是一种增删快，查询慢的模型

添加元素：

删除元素：

查询元素

5. 哈希表

哈希表是一种常见的数据结构

31.4 ArrayList

List集合子类特点
List集合常用子类：ArrayList, LinkedList

  • ArrayList：底层数据结构是数组，查询快，增删慢
  • LinkedList：底层数据结构是链表，查询慢，增删快

练习：

package myList.Demo7;import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;/*List集合常用子类：ArrayList  LinkedListArrayList: 底层数据结构是数组，查询快，增删慢LinkedList: 底层数据结构是链表，查询慢，增删快练习：分别使用完成存储字符串并遍历*/
public class Demo1 {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new ArrayList<>();array.add("hello");array.add("world");array.add("java");for (String s : array) {System.out.println(s);}System.out.println("------------------------");LinkedList<String> linkedList = new LinkedList<>();linkedList.add("hello");linkedList.add("world");linkedList.add("javaee");ListIterator<String> lit = linkedList.listIterator();while(lit.hasNext()){String s = lit.next();System.out.println(s);}}
}

案例：ArrayList集合存储学生对象用三种方法遍历

Student类不重复

package myList.Demo8;import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;public class Demo1 {public static void main(String[] args) {//创建集合对象ArrayList<Student> array = new ArrayList<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);//集合添加元素array.add(s1);array.add(s2);array.add(1, s3);//遍历//1.forfor (int i = 0; i < array.size(); i++) {Student s = array.get(i);System.out.println(s);}System.out.println("--------------------------");//2.增强forfor (Student s : array) {System.out.println(s);}System.out.println("--------------------------");//3.ListIterator<Student> lit = array.listIterator();while (lit.hasNext()) {Student s = lit.next();System.out.println(s);}System.out.println("--------------------------");//4.Iterator<Student> it = array.iterator();while (it.hasNext()) {Student s = it.next();System.out.println(s);}}
}

31.5 LinkedList

LinkedList集合的特有功能

package myList.Demo9;import java.util.LinkedList;/*LinkedList集合的特有功能：public void addFirst(E e): 在该列表开头插入指定的元素public void addLast(E e): 将指定的元素追加到此列表的末尾public E getFirst(): 返回此列表中的第一个元素public E getLast(): 返回此列表中的最后一个元素public E removeFirst(): 从此列表中删除并返回第一个元素public E removeLast(): 从此列表中删除并返回最后一个元素*/
public class Demo1 {public static void main(String[] args) {LinkedList<String> linkedList = new LinkedList<>();//添加linkedList.add("world");linkedList.addFirst("hello");linkedList.addLast("java");System.out.println(linkedList);System.out.println("----------------------");//getSystem.out.println("get第一个：" + linkedList.getFirst());System.out.println("get最后一个：" + linkedList.getLast());System.out.println("-----------------------");//removeSystem.out.println("移除第一个：" + linkedList.removeFirst());System.out.println("移最后一个：" + linkedList.removeLast());System.out.println("linkedList：" + linkedList);}
}

31.6 Set集合

无序，不含重复元素

Set集合特点

  • 不包含重复元素
  • 没有带索引的方法，所以不能使用欧通for循环遍历
package mySet.Demo1;import java.util.HashSet;
import java.util.Set;/*Set集合特点不包含重复元素的集合没有带索引的方法，所以不能使用普通for循环遍历HashSet: 对集合的迭代顺序不作任何保证*/
public class Demo1 {public static void main(String[] args) {//创建集合对象Set<String> set = new HashSet<>();//添加元素set.add("hello");set.add("world");set.add("java");//不包含重复元素set.add("world");//遍历for (String s : set) {System.out.println(s);}}
}

31.7 哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

  • public int hashCode()：返回对象的哈希码值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象哈希值相同

代码如下：
Student.java这里就不再写了

package mySet.Demo2;/*哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值Object类中有一个方法可以获取对象的哈希值public int hashCode(): 返回对象的哈希码值*/
public class Demo1 {public static void main(String[] args) {//创建学生对象Student s1 = new Student("林青霞", 18);//同一个对象多次调用hashCode()方法返回的哈希值是相同的System.out.println(s1.hashCode());System.out.println(s1.hashCode());  //1239731077//默认情况下 不同对象的哈希值是不相同的Student s2 = new Student("林青霞", 18);System.out.println(s2.hashCode());System.out.println(s2.hashCode());   //557041912//通过方法重写，可以实现不同独享的哈希值是相同的System.out.println("---------------------------");System.out.println("hello".hashCode());System.out.println("world".hashCode());System.out.println("java".hashCode());System.out.println("-------------------");System.out.println("重地".hashCode());  //这两个一样！  字符串重写了哈希值的方法System.out.println("通话".hashCode());}
}

31.8 HashSet集合

无序，不含重复元素

package mySet.Demo3;import java.util.HashSet;/*HashSet集合的特点1.底层数据结构是哈希表2.对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致3.没有带索引的方法，所以不能使用普通for循环遍历4.由于是Set集合，所以是不包含重复元素的集合*/
public class Demo1 {public static void main(String[] args) {//创建集合对象HashSet<String> hs = new HashSet<>();hs.add("hello");hs.add("world");hs.add("java");//不包含重复元素hs.add("hello");System.out.println(hs);//遍历for (String s : hs) {System.out.println(s);}}
}

案例：HashSet集合存储学生对象并遍历

Student.java

package mySet.Demo4;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;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}
}

Demo1.java

package mySet.Demo4;import java.util.HashSet;public class Demo1 {public static void main(String[] args) {//创建HashSet集合对象HashSet<Student> ha = new HashSet<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);Student s4 = new Student("王祖贤", 20);  //因为是new，这里会默认s3和s4不一样， 所以需要重写HashCode和equalsha.add(s1);ha.add(s2);ha.add(s3);ha.add(s4);for (Student s : ha) {System.out.println(s.getName() + "," + s.getAge());}}
}

31.9 LinkedHashSet集合

这个是有序的，不含重复元素

package mySet.Demo5;import java.util.LinkedHashSet;/*LinkedHashSet集合特点1.哈希表和链表实现的Set接口，具有可预测的迭代次序2.由链表保证元素有序，也就是说元素的存储和去除顺序一致3.由哈希表保证元素唯一，就是没有重复元素*/
public class Demo1 {public static void main(String[] args) {//创建集合对象LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();//添加元素linkedHashSet.add("hello");linkedHashSet.add("world");linkedHashSet.add("java");linkedHashSet.add("world");System.out.println(linkedHashSet);//遍历for(String s:linkedHashSet){System.out.println(s);}}
}

31.10 TreeSet集合

有序，不含重复元素

Student.java

package mySet.Demo6;public class Student implements Comparable<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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Student s) {//        return 0;
//        return 1;int num = this.age - s.age;int num2 = num == 0 ? this.name.compareTo(s.name) : num;return num2;}
}

Demo1.java

package mySet.Demo6;import java.util.TreeSet;/*TreeSet集合特点1.元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法TreeSet(): 根据其元素的自然排序进行排序TreeSet(Comparator comparator): 根据指定的比较器进行排序2.没有带索引的方法，所以不能使用普通for循环遍历3.由于是Set集合，所以不包含重复元素*/
public class Demo1 {public static void main(String[] args) {//创建集合对象TreeSet<Integer> ts = new TreeSet<>();//添加元素ts.add(10);ts.add(40);ts.add(30);ts.add(50);ts.add(20);//重复元素ts.add(30);System.out.println(ts);  //自然排序//遍历for (Integer i : ts) {System.out.println(i);}}
}

31.11 自然排序Comparable的使用

案例：

Student.java

Demo2.java

package mySet.Demo6;import java.util.TreeSet;/*存储学生对象并遍历，创建集合使用无参构造方法要求：按照年龄的从小到大排序，年龄相同时，按照姓名的字母顺序排序*/
public class Demo2 {public static void main(String[] args) {//创建集合对象TreeSet<Student> ts = new TreeSet<Student>();//创建学生对象Student s1 = new Student("xishi", 29);Student s2 = new Student("wangzhaojun", 28);Student s3 = new Student("diaochan", 30);Student s4 = new Student("yangyuhuan", 33);Student s5 = new Student("linqingxia", 33);Student s6 = new Student("linqingxia", 33);//添加ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);System.out.println(ts);//遍历for (Student s : ts) {System.out.println(s.getName() + "," + s.getAge());}}
}

31.12 比较器排序Comparator的使用

package mySet.Demo7;import java.util.Comparator;
import java.util.TreeSet;/*存储学生对象并遍历，创建集合使用带参构造方法要求：按照年龄的从小到大排序，年龄相同时，按照姓名的字母顺序排序*/
public class Demo1 {public static void main(String[] args) {//创建集合对象TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s1.getAge() - s2.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;return num2;}});//创建学生对象Student s1 = new Student("xishi", 29);Student s2 = new Student("wangzhaojun", 28);Student s3 = new Student("diaochan", 30);Student s4 = new Student("yangyuhuan", 33);Student s5 = new Student("linqingxia", 33);Student s6 = new Student("linqingxia", 33);//添加ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);System.out.println(ts);//遍历for (Student s : ts) {System.out.println(s.getName() + "," + s.getAge());}}
}

与上一小节输出同样的结果

案例：成绩排序

Demo1.java

package mySet.Demo8;import java.util.Comparator;
import java.util.TreeSet;/*需求：用TreeSet集合存储多个学生信息（姓名， 语文成绩， 数学成绩）， 并遍历该集合要求：按照总分从高到低出现思路：1.定义学生类2.创建TreeSet集合对象，通过比较器排序进行排序3.创建学生对象4.把学生对象添加到集合5.遍历集合*/
public class Demo1 {public static void main(String[] args) {//创建集合对象TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s2.getSum() - s1.getSum();int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;return num3;}});//创建学生对象Student s1 = new Student("林青霞", 98, 100);Student s2 = new Student("张曼玉", 95, 95);Student s3 = new Student("王祖贤", 100, 93);Student s4 = new Student("成德善", 100, 97);Student s5 = new Student("风清扬", 98, 98);Student s6 = new Student("左冷禅", 97, 99);Student s7 = new Student("张三", 97, 99);//添加ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);ts.add(s7);System.out.println(ts);//遍历for (Student s : ts) {System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum());}}
}

案例：不重复的随机数

package mySet.Demo9;import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;public class Demo9 {public static void main(String[] args) {//创建集合Set<Integer> set = new HashSet<>();//Set<Integer> set = new TreeSet<>();//创建随机数对象Random r = new Random();//判断是否10个while (set.size() < 10) {//产生一个随机数，添加到集合int number = r.nextInt(20) + 1;   //1-20之间set.add(number);}System.out.println(set);//遍历集合for (Integer i : set) {System.out.println(i);}}
}

32 泛型

32.1 泛型概述

package myGeneric.Demo1;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;//需求：Collection集合存储字符串并遍历
public class Demo1 {public static void main(String[] args) {//创建集合对象//Collection c =new ArrayList();Collection<String> c =new ArrayList();   //String泛型//添加元素c.add("hello");c.add("world");c.add("java");
//        c.add(100);    //ClassCastException//遍历
//        Iterator it = c.iterator();Iterator<String> it = c.iterator();while(it.hasNext()){//            Object obj = it.next();
//            System.out.println(obj);
//            String s = (String)it.next();String s = it.next();System.out.println(s);}}
}

32.2 泛型类


Generic.java

package myGeneric.Demo2;public class Generic<T> {private T t;public T getT() {return t;}public void setT(T t) {this.t = t;}
}

Demo1.java

package myGeneric.Demo2;public class Demo1 {public static void main(String[] args) {Generic<String> g1 = new Generic<>();g1.setT("林青霞");System.out.println(g1.getT());Generic<Integer> g2 = new Generic<>();g2.setT(30);System.out.println(g2.getT());Generic<Boolean> g3 = new Generic<>();g3.setT(true);System.out.println(g3.getT());}
}

32.3 泛型方法

版本一：
Generic.java

package myGeneric.Demo3;public class Generic {public void show(String s){System.out.println(s);}public void show(Integer i){System.out.println(i);}public void show(Boolean b){System.out.println(b);}
}

Demo1.java

package myGeneric.Demo3;public class Demo1 {public static void main(String[] args) {Generic g = new Generic();g.show("林青霞");g.show(30);g.show(true);//g.show(12.34);   //报错}
}

版本二：
Generic.java

package myGeneric.Demo3;//泛型类改进
public class Generic<T>{public void show(T t){System.out.println(t);}
}

Demo1.java

package myGeneric.Demo3;public class Demo1 {public static void main(String[] args) {Generic<String> g1 = new Generic<>();g1.show("林青霞");Generic<Integer> g2 = new Generic<>();g2.show(30);Generic<Boolean> g3 = new Generic<>();g3.show(true);Generic<Double> g4 = new Generic<>();g4.show(12.34);}
}

版本三：
Generic.java

package myGeneric.Demo3;//泛型方法改进
public class Generic {public <T> void show(T t){System.out.println(t);}
}

Demo1.java

package myGeneric.Demo3;public class Demo1 {public static void main(String[] args) {Generic g = new Generic();g.show("林青霞");g.show(30);g.show(true);g.show(12.34);}
}

32.4 泛型接口


Generic.java

package myGeneric.Demo4;public interface Generic<T> {void show(T t);
}

GenericImpl.java

package myGeneric.Demo4;public class GenericImpl<T> implements Generic<T> {@Overridepublic void show(T t) {System.out.println(t);}
}

Demo1.java

package myGeneric.Demo4;public class Demo1 {public static void main(String[] args) {Generic<String> g1 = new GenericImpl<>();g1.show("林青霞");Generic<Integer> g2 = new GenericImpl<>();g2.show(30);}
}

32.5 类型通配符

package myGeneric.Demo5;import java.util.ArrayList;
import java.util.List;public class Demo1 {public static void main(String[] args) {//类型通配符： <?>List<?> list1 = new ArrayList<Object>();List<?> list2 = new ArrayList<Number>();List<?> list3 = new ArrayList<Integer>();System.out.println("----------------------");//类型通配符上限：<? extends 类型>//List<? extends Number> list4 = new ArrayList<Object>();List<? extends Number> list5 = new ArrayList<Number>();List<? extends Number> list6 = new ArrayList<Integer>();System.out.println("------------------------");//类型通配符下限： <? super 类型>List<? super Number> list7 = new ArrayList<Object>();List<? super Number> list8 = new ArrayList<Number>();//List<? super Number> list9 = new ArrayList<Integer>();}
}

32.6 可变参数

package myGeneric.Demo6;//测试类
public class Demo1 {public static void main(String[] args) {System.out.println(sum(10, 20));System.out.println(sum(10, 20, 30));System.out.println(sum(10, 20, 30, 40));System.out.println(sum(10, 20, 30, 40, 50));System.out.println(sum(10, 20, 30, 40, 50, 60));System.out.println(sum(10, 20, 30, 40, 50, 60, 70));}//    public static int sum(int a, int b) {//        return a + b;
//    }
//
//    public static int sum(int a, int b, int c) {//        return a + b + c;
//    }
//
//    public static int sum(int a, int b, int c, int d) {//        return a + b + c + d;
//    }
//
//    public static int sum(int... a) {  //a其实是数组
//        int sum = 0;
//        for (int i : a) {//            sum += i;
//        }
//        return sum;
//    }public static int sum(int b, int... a){int sum = 0;for (int i : a) {sum += i;}return sum;}
}


<32>

32.7 可变参数的使用

package myGeneric.Demo6;
/*Arrays工具类中有一个静态方法：public static <T> List<T> saList(T... a): 返回由指定数组支持的固定大小的列表List接口中有一个静态方法public static <E> List<E> of (E... elements): 返回包含任意数量元素的不可变列表Set接口中有一个静态方法：public static <E> Set<E> of (E... elements): 返回一个包含任意数量元素的不可变集合*/import java.util.Arrays;
import java.util.List;
import java.util.Set;public class Demo2 {public static void main(String[] args) {//1.List<String> list = Arrays.asList("hello", "world", "java", "world");System.out.println(list);//list.add("javaee");  //java.lang.UnsupportedOperationException//list.remove("hello");   //UnsupportedOperationExceptionlist.set(2, "javaee");System.out.println(list);System.out.println("------------------");//2.List<String> list1 = List.of("hello", "world", "java", "world");System.out.println(list1);//add报错//remove报错//list1.set(3,"javaee");报错System.out.println("--------------------");//3.//Set<String> set = Set.of("hello", "world", "java", "hello");  //报错 IllegalArgumentExceptionSet<String> set = Set.of("hello", "world", "java");System.out.println(set);//add报错//remove报错//set没有修改方法}
}

33 Map集合

33.1 Map集合概述

package myMap.Demo1;import java.util.HashMap;
import java.util.Map;/*Map集合概述Interface Map<K,V>  K:键的类型 V:值的类型将键映射到值的对象：不能包含重复的键；每个键可以映射到最多一个值举例：学生的学号和姓名01  林青霞02  张曼玉03  王祖贤创建Map集合的对象多态的方式具体的实现类HashMap*/
public class Demo1 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//putmap.put("01", "林青霞");map.put("02", "张曼玉");map.put("03", "王祖贤");map.put("03", "张三");      //替代，相当于修改//输出集合对象System.out.println(map);}
}

33.2 Map集合的基本功能

package myMap.Demo1;import java.util.HashMap;
import java.util.Map;public class Demo2 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//put添加元素map.put("林青霞", "张三");map.put("郭靖", "张三");map.put("杨过", "小龙女");//输出System.out.println(map);System.out.println("---------------------");//2.removeSystem.out.println(map.remove("郭靖"));System.out.println(map.remove("李四"));System.out.println(map);System.out.println("-----------------------");//containsKey()System.out.println(map.containsKey("林青霞"));System.out.println(map.containsKey("李四"));System.out.println(map);System.out.println("-------------------------");//containsValueSystem.out.println(map.containsValue("张三"));System.out.println(map.containsValue("李四"));System.out.println("--------------------------");//size()System.out.println(map.size());System.out.println("------------------------------");//2.clearmap.clear();System.out.println(map);System.out.println("-----------------------------");//isEmptySystem.out.println(map.isEmpty());}
}

33.3 Map集合的获取功能

package myMap.Demo1;import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo3 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//添加元素map.put("张无忌", "张三");map.put("郭靖", "张三");map.put("杨过", "张三");System.out.println(map);//get根据键获取值System.out.println(map.get("张无忌"));System.out.println(map.get("张三"));System.out.println("------------------------------");//keySet获取所有键的集合Set<String> keySet = map.keySet();System.out.println(keySet);System.out.println("------------------------");//获取所有值的集合Collection<String> values = map.values();System.out.println(values);}
}

33.4 Map集合的遍历

方式一：

package myMap.Demo1;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo4 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//添加元素map.put("张无忌", "张三");map.put("郭靖", "张三");map.put("杨过", "张三");Set<String> keySet = map.keySet();for (String key : keySet) {String value = map.get(key);System.out.println(key + "," + value);}}
}

方式二：

package myMap.Demo1;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo5 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//添加元素map.put("张无忌", "张三");map.put("郭靖", "张三");map.put("杨过", "张三");//获取所有键值对对象的集合Set<Map.Entry<String, String>> entrySet = map.entrySet();//遍历for (Map.Entry<String, String> me : entrySet) {//根据键值对对象获取键和值String key = me.getKey();String value = me.getValue();System.out.println(key + "," + value);}}
}

案例：存储学生对象并遍历

package myMap.Demo2;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo1 {public static void main(String[] args) {//创建HashMap集合对象HashMap<String, Student> hm = new HashMap<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);//添加hm.put("01", s1);hm.put("02", s2);hm.put("03", s3);//方式一：键找值Set<String> keySet = hm.keySet();for (String key : keySet) {Student value = hm.get(key);System.out.println(key + "," + value.getName() + "," + value.getAge());}System.out.println("------------------------------");//方式二，获取键值对Set<Map.Entry<String, Student>> entrySet = hm.entrySet();for (Map.Entry<String, Student> i : entrySet) {String key = i.getKey();Student value = i.getValue();System.out.println(key + "," + value.getName() + "," + value.getAge());}}
}

案例二

这里Student需要重写hashCode和equals

package myMap.Demo3;import java.util.HashMap;
import java.util.Set;public class Demo1 {public static void main(String[] args) {//创建HashMap集合对象HashMap<Student, String> hm = new HashMap<>();//创建学生对象Student s1 = new Student("林青霞", 18);Student s2 = new Student("张曼玉", 19);Student s3 = new Student("王祖贤", 20);Student s4 = new Student("王祖贤", 20);//添加hm.put(s1, "西安");hm.put(s2, "武汉");hm.put(s3, "郑州");hm.put(s4, "北京");System.out.println(hm);//遍历Set<Student> keySet = hm.keySet();for (Student key : keySet) {String value = hm.get(key);System.out.println(key.getName() + "," + key.getAge() + "," + value);}}
}

案例三：

package myMap.Demo4;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;public class Demo1 {public static void main(String[] args) {//创建ArrayList集合对象ArrayList<HashMap<String, String>> array = new ArrayList<>();//创建HashMap集合对象HashMap<String, String> hm1 = new HashMap<>();hm1.put("孙策", "大乔");hm1.put("周瑜", "小乔");HashMap<String, String> hm2 = new HashMap<>();hm2.put("郭靖", "黄蓉");hm2.put("杨过", "小龙女");HashMap<String, String> hm3 = new HashMap<>();hm3.put("令狐冲", "任盈盈");hm3.put("张三", "李四");array.add(hm1);array.add(hm2);array.add(hm3);System.out.println(array);//遍历for (HashMap<String, String> hm : array) {Set<String> keySet = hm.keySet();for (String key : keySet) {String value = hm.get(key);System.out.println(key + "," + value);}System.out.println("----------------------");}}
}

案例四：

package myMap.Demo5;import myMap.Demo3.Student;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;public class Demo1 {public static void main(String[] args) {//创建ArrayList集合对象HashMap<String, ArrayList<String>> hm = new HashMap<>();//创建ArrayList集合ArrayList<String> sgyy = new ArrayList<>();sgyy.add("诸葛亮");sgyy.add("赵云");ArrayList<String> xyj = new ArrayList<>();xyj.add("唐僧");xyj.add("孙悟空");ArrayList<String> shz = new ArrayList<>();shz.add("武松");shz.add("鲁智深");hm.put("三国演义", sgyy);hm.put("西游记", xyj);hm.put("水浒传", shz);System.out.println(hm);//遍历Set<String> keySet = hm.keySet();for (String key : keySet) {System.out.println(key);ArrayList<String> value = hm.get(key);for (String s : value) {System.out.println("\t" + s);}}}
}

案例五：统计字符串中每个字符出现的次数

package myMap.Demo6;import java.util.*;public class Demo1 {public static void main(String[] args) {//键盘录入字符Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String line = sc.nextLine();//创建HashMap集合对象
//        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();TreeMap<Character, Integer> hm = new TreeMap<>();//遍历字符串for (int i = 0; i < line.length(); i++) {char key = line.charAt(i);   //获取每一个字符Integer value = hm.get(key);  // 自动装箱if (value == null) {hm.put(key, 1);} else {value++;   // 这里会自动拆箱hm.put(key, value);}}//进行拼接StringBuilder sb = new StringBuilder();Set<Character> keySet = hm.keySet();for (Character key : keySet) {Integer value = hm.get(key);sb.append(key).append("(").append(value).append(")");}String result = sb.toString();   //StringBuilder--->StringSystem.out.println(result);}
}

33.5 Collections

package myMap.Demo7;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class Demo1 {public static void main(String[] args) {//创建集合对象List<Integer> list = new ArrayList<>();list.add(30);list.add(20);list.add(50);list.add(10);list.add(40);System.out.println("正常输出："+list);Collections.sort(list);System.out.println("排序："+list);Collections.reverse(list);System.out.println("倒序："+list);Collections.shuffle(list);   //随机排序，每次执行结果都不一样System.out.println("随机排序："+list);}
}

案例：

package myMap.Demo8;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo1 {public static void main(String[] args) {ArrayList<Student> array = new ArrayList<>();Student s1 = new Student("linqingxia", 18);Student s2 = new Student("zhangmanyu", 19);Student s3 = new Student("wangzuxian", 20);Student s4 = new Student("zhangsan", 18);array.add(s1);array.add(s2);array.add(s3);array.add(s4);Collections.sort(array, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s1.getAge() - s2.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;return num2;}});System.out.println(array);for (Student s : array) {System.out.println(s.getName() + "," + s.getAge());}}
}

33.6 模拟斗地主

package myMap.Demo9;import java.util.ArrayList;
import java.util.Collections;public class Demo1 {public static void main(String[] args) {//创建一个牌盒ArrayList<String> array = new ArrayList<>();//装牌//定义花色数组String[] colors = {"♦", "♣", "♥", "♠"};//定义点数数组String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};for (String color : colors) {for (String number : numbers) {array.add(color + number);}}array.add("小王");array.add("大王");System.out.println(array);//洗牌Collections.shuffle(array);System.out.println(array);//发牌//创建三个玩家ArrayList<String> lqxArray = new ArrayList<>();ArrayList<String> zmyArray = new ArrayList<>();ArrayList<String> wzxArray = new ArrayList<>();ArrayList<String> dpArray = new ArrayList<>();for (int i = 0; i < array.size(); i++) {String poker = array.get(i);if (i >= array.size() - 3) {dpArray.add(poker);} else if (i % 3 == 0) {lqxArray.add(poker);} else if (i % 3 == 1) {zmyArray.add(poker);} else if (i % 3 == 2) {wzxArray.add(poker);}}//看牌lookPoker("林青霞", lqxArray);lookPoker("张曼玉", zmyArray);lookPoker("王祖贤", wzxArray);lookPoker("底牌", dpArray);}//看牌方法public static void lookPoker(String name, ArrayList<String> array) {System.out.print(name + "的牌是：");for (String poker : array) {System.out.print(poker + " ");}System.out.println();}
}

案例二：升级版

package myMap.Demo9;import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;public class Demo2 {public static void main(String[] args) {//创建HashMap集合，键是编号，值是牌HashMap<Integer, String> hm = new HashMap<>();//创建ArrayList存储编号ArrayList<Integer> array = new ArrayList<>();//定义花色数组String[] colors = {"♦", "♣", "♥", "♠"};//定义点数数组String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};//存储键值对，装牌int index = 0;for (String number : numbers) {for (String color : colors) {hm.put(index, color + number);array.add(index);index++;}}hm.put(index, "小王");array.add(index);index++;hm.put(index, "大王");array.add(index);//洗牌Collections.shuffle(array);//发牌，发编号TreeSet<Integer> lqxSet = new TreeSet<>();TreeSet<Integer> zwySet = new TreeSet<>();TreeSet<Integer> wzxSet = new TreeSet<>();TreeSet<Integer> dpSet = new TreeSet<>();for (int i = 0; i < array.size(); i++) {int x = array.get(i);  //索引if (i >= array.size() - 3) {dpSet.add(x);} else if (i % 3 == 0) {lqxSet.add(x);} else if (i % 3 == 1) {zwySet.add(x);} else if (i % 3 == 2) {wzxSet.add(x);}}//看牌lookPoker("林青霞", lqxSet, hm);lookPoker("张曼玉", zwySet, hm);lookPoker("王祖贤", wzxSet, hm);lookPoker("底牌", dpSet, hm);}public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {System.out.print(name + "的牌是：");for (Integer key : ts) {String poker = hm.get(key);System.out.print(poker + " ");}System.out.println();}
}

本博客内容长了点，包含了黑马讲的所有集合类了，到视频d271截止！
只做代码记录，后续遗忘方便学习而已

黑马全套Java教程（八）：集合进阶相关推荐

  1. 黑马全套Java教程（十一）

    文章目录 40 反射 40.1 单元测试 40.2 反射 40.3 注解 40.4 动态代理 41 XML 41.1 XML 41.2 XML解析技术 41.3 XPath 41.4 设计模式 总结 ...

  2. 黑马全套Java教程（一）

    Java入门 1 Java概述 1.1 Java基本介绍 1.2 JDK的下载与安装 1.3 常用DOS命令 1.4 path环境变量的配置 2 Hello world! 2.1 hello worl ...

  3. 黑马全套Java教程（二）

    文章目录 9 IDEA下载.安装与概述.使用 9.1 IDEA的下载 9.2 安装 9.3 IDEA的基本使用 9.4 IDEA字体修改 9.5 IDEA中内容辅助键和快捷键 9.6 IDEA中模块操 ...

  4. 黑马程序员全套Java教程_Java基础教程_异常（含扩展）（二十三）

    黑马程序员全套Java教程_Java基础教程_异常(含扩展)(二十三) 1.1 异常概述与异常体系结构 1.2 JVM遇到异常时的默认处理方案 1.3 异常处理 1.4 异常处理之try--catch ...

  5. 全套Java教程--打包下载地址

    [全套Java教程--打包下载地址] Java基础阶段 一.20天横扫Java基础(课堂实录) https://pan.baidu.com/s/1htTzZRQ 二.尚硅谷Java基础实战--Bank ...

  6. #Java教程：集合 #Collection、List、Set #ArrayList、LinkedList、Vector、HashSet、TreeSet #一个斗地主小游戏@FDDLC

    一.概述 Java单列集合中最顶层的是Collection接口,Collection下又分List和Set两大类: 学习Java集合的时候,建议自顶向下学:先学Collection,再学List和Se ...

  7. 尚硅谷《全套Java、Android、HTML5前端视频》

    尚硅谷<全套Java.Android.HTML5前端视频> (百万谷粉推荐:史上最牛.最适合自学的全套视频.资料及源码) [尚硅谷官网资料导航] 谷粒学院在线学习:http://www.g ...

  8. 【备忘】2018年最新尚硅谷全套Java、Android、HTML5前端视频教程下载

    全套Java教程--打包下载地址]     Java基础阶段     一.20天横扫Java基础(课堂实录)     二.尚硅谷Java基础实战--Bank项目     三.尚硅谷_ORACLE.SQ ...

  9. 我大学大三用一个月时间学完就找到实习的一套Java教程

    目录 引言 第一个Java程序 Java运行机制 基本语法 Java 关键字 Java 标识符 Java 修饰符 Java 注释 Java 基本数据类型 Java 变量 Java 运算符 Java 循 ...

最新文章

  1. Sublime Text 3 (含：配置 C# 编译环境)
  2. 如何自学python到做项目-总算明白如何通过项目学习python
  3. java bean传索引_Java如何设置bean的索引属性值？
  4. CSS之media Query
  5. c语言优化冒泡法,C语言：冒泡法排序一组数，如何优化？
  6. faststart可以卸载吗_你的手机你做主！免 ROOT 卸载安卓手机预装APP
  7. 用c语言编写五子棋用vs写,c语言写的五子棋人与人对战
  8. [转]vs2003,安装程序检测到另一个程序要求计算机重新启动
  9. 190712每日一句 生命的韧性
  10. Atitit 泛型的知识点 目录 1. 为什么需要泛型 why 2 2. 定义分类 what 2 2.1. 编辑类型参数 2 2.2. 模板 2 2.3. 简单理解 占位符 代替object、 3
  11. ppt生成eps文件_eps是什么格式怎么打开？全面解析图片的eps是什么格式
  12. Python对象与json数据的转换
  13. 步进电机驱动控制器，电动云台控制。
  14. php eclipse 版本_PHPEclipse官方下载
  15. 1月15日云栖精选夜读 | 重磅公开！阿里语音识别模型端核心技术，让你“听”见未来...
  16. 如何在计算机添加打印机驱动程序,教你如何安装打印机驱动程序
  17. 基于自适应调整权重和搜索策略的鲸鱼优化算法
  18. 建设数字经济引领型城市 CDEC2022中国数字智能生态大会广州举行
  19. AI帮我画出了小说里的人物，我这么多年的小说好像白看了。。。
  20. 波段合成，去除黑边并提取土地利用数据....下

热门文章

  1. 吐血规劝！程序员防猝死终极指南
  2. java继承a mya new c,“内部类” 大总结(Java)，内部类总结java
  3. Java-双亲委派机制
  4. 邮箱的容量怎么算怎么看？免费邮箱容量多大？能办公用吗？
  5. The Devil Wears Prada-3
  6. K8S(一)VMware Fusion 构建基本k8s集群
  7. React报错之React hook ‘useState‘ cannot be called in a class component
  8. Node.js 从零开发web server博客项目--项目初始化
  9. 计算机组成原理复习总结（七）外围设备
  10. 客户流失预测模型python_使用python进行客户流失案例分析