java大数据开发训练营--Java核心类库（上）

题记：

文章内容输出来源：拉勾教育大数据开发高薪训练营
本篇文章是java学习课程中的一部分笔记。

本博文主要是记录一些基础的知识点，通过实操更容易理解

这张主要讲的就是一些常用的包的使用，了解认识，如果不记得可以回来再查询使用，手册可真是个好东西

常用的包

包的名称和功能

java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。

        如：System类、String类、...

java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。

        如：Scanner类、Random类、List集合、...

java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等。

        如：FileInputStream类、FileOutputStream类、...

java.net包 - 该包是Java语言中的网络包，里面提供了大量网络编程相关的类等。

        如：ServerSocket类、Socket类、...

java.sql 包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。

        如：DriverManager类、Connection接口、…

... ...

Java 程序员在编程时可以使用大量类库，因此 Java编程时需要记的很多，对编程能力本身要求不是特别的高。

 

Object类的概述

基本概念

java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类。

如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。

Object类定义了“对象”的基本行为, 被子类默认继承。

常用的方法

 

案例题目：

编程实现Student类的封装，特征：学号(id)和姓名，要求提供打印所有特征的方法。

编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征。

题目扩展 :

如何实现以姓名作为基准判断两个对象是否相等？以及以学号和姓名同时作为基准判断两个对象是否相等？

import java.util.Objects;

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

    //学生类
    public Student(String id, String name, int age) {
        setId(id);
        setName(name);
        setAge(age);
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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;
    }

    //重写tostring
    @Override
    public String toString() {
        return "{" +
                "学号：" + id +
                ", 姓名：'" + name + '\'' +
                ", 年龄" + age +
                "}\r\n";
    }
    //重写equals，只对比id是否相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }
    /*对比id和name*/
/*
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id) &&
                Objects.equals(name, student.name);
    }
*/
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

 

包装类

包装类的概念

通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。

如：

Person p = new Person();

int num = 10;

  包装类的分类

 

Integer 类的概述

（ 1 ）基本概念

java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。

（ 2 ）常用的常量

（3）常用的方法

（ 3 ）装箱和拆箱的概念

在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。

从Java5开始增加了自动拆箱和自动装箱的功能。String a="234";

（ 4 ）自动装箱池

在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。

Double 类的概述

（ 1 ）基本概念

java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。

（ 2 ）常用的常量

(3)常用的方法

扩展：

java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。

Boolean 类的概述

（ 1 ）基本概念

java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。

（ 2 ）常用的常量

（ 3 ）常用的方法

Character 类的概述

（ 1 ）基本概念

java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。

包装类（ Wrapper ）的使用总结

基本数据类型转换为对应包装类的方式

        调用包装类的构造方法或静态方法即可

获取包装类对象中基本数据类型变量数值的方式

        调用包装类中的xxxValue方法即可

字符串转换为基本数据类型的方式

        调用包装类中的parseXxx方法即可

 

数学处理类

Math 类的概述

（ 1 ）基本概念

java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。

（ 2 ）常用的方法

BigDecimal 类的概述

（ 1 ）基本概念

由于flfloat类型和double类型在运算时可能会有误差，若希望实现精确运算则借助 java.math.BigDecimal类型加以描述。

（ 2 ）常用的方法

BigInteger 类的概念

（ 1 ）基本概念

若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。

（ 2 ）常用的方法

 

String类的概述和使用  

String 类的概念（重点）

java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如："abc"。

该类由fifinal关键字修饰，表示该类不能被继承。

从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。

该类描述的字符串内容是个常量不可更改，因此可以被共享使用。

如：

      String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。

       str1 = “123”; - 将“123”字符串的地址赋值给变量str1。

      - 改变str1的指向并没有改变指向的内容

常量池的概念（原理）

由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。

常用的构造方法（练熟、记住）

常用的成员方法

案例题目

判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读

还是从右向左读都是相同的句子。

public class huiwen {
    public static void main(String[] args) {
        String str="上海自来水来自海上";
        System.out.println(str);
        int length=str.length();
        for(int i=0;i

案例题目

编程实现字符串之间大小的比较并打印。

String a="asdf";
String b="Aseeee";

System.out.println(a.compareToIgnoreCase(b));

 

案例题目

提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使

用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已

冻结，请联系客服人员！”

public class StringequlesTest {
    public static void main(String[] args) {



        Scanner sc=new Scanner(System.in);
        for (int i=0;i<3;i++){
            System.out.println("请输入用户名密码");
            String name=sc.next();
            String password=sc.next();
            if("admin".equals(name) && "123456".equals(password)){
                System.out.println("登陆成功");
                return;
            }
            if(i>1){
                System.out.println("账号冻结");
            }else{

                System.out.println("还有"+(2-i)+"次机会");
            }

        }
    }
}

案例题目

编写通用的代码可以查询字符串"Good Good Study, Day Day Up!"中所有"Day"出现的索引位置并打印出来。

public class StringequlesTest {
    public static void main(String[] args) {

        String str="Good Good Study, Day Day Up!";
        for (int i = 0; i < str.length(); i++) {
            int index=str.indexOf("Day",i);
            if (index>-1){
                System.out.println(index);
                i=index+"Day".length()-1;
            }else{
                break;
            }

        }
    }
}

 

案例题目

提示用户从键盘输入一个字符串和一个字符，输出该字符(不含)后面的所有子字符串

import java.util.Scanner;

public class StringequlesTest {
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串，和字符");
        String str=sc.next();
        String s=sc.next();
        int index=str.indexOf(s);
        if (index<0){
            System.out.println("不包含");
        }else{
            System.out.println(str.substring(index+1));
        }

        sc.close();

    }
}

 

正则表达式

正则表达式的概念（了解）

正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。

正则表达式的规则（了解）

正则表达式相关的方法（熟悉）

 

案例题目

使用正则表达式描述一下银行卡密码的规则：要求是由6位数字组成。

使用正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数组成。

使用正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位

描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X。

String yhpassword="\\d{6}";
String qqreq="[^0]\\d{4,12}";
String re="^[1][34578]+\\d{9}$";
String shenfen="(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})[0-9X]";
String password="130202200202192871";
System.out.println(password.matches(shenfen));

 

 

可变字符串类 

基本概念

由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。

为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffffer类来描述字符序列可以改变的字符串，如："ab"。

StringBuffffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。

StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。

StringBuilder 类常用的构造方法

StringBuilder 类常用的成员方法

注意

作为参数传递的话，方法内部String不会改变其值，StringBuffffer和StringBuilder会改变其值。

返回值的设计

StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。

由此可见，这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基于这样设计的目的在于可以连续调用。

Java8之前的日期相关类 

System 类的概述

（ 1 ）基本概念

Java.lang.System类中提供了一些有用的类字段和方法。

（ 2 ）常用的方法

 

Date 类的概述

（ 1 ）基本概念

java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒。

（ 2 ）常用的方法

 

SimpleDateFormat 类的概述

（ 1 ）基本概念

java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换。

（ 2 ）常用的方法

 

Calendar 类的概述

（ 1 ）基本概念

java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化。

该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。

（ 2 ）常用的方法

 

（ 3 ）多态的使用场合

通过方法的参数传递形成多态；

public static void draw(Shape s){

          s.show();

}

draw(new Rect(1, 2, 3, 4));

在方法体中直接使用多态的语法格式

Account acc = new FixedAccount();

通过方法的返回值类型形成多态

Calender getInstance(){

          return new GregorianCalendar(zone, aLocale);

}

 

Java8中的日期相关类（熟悉）

 

Java8 日期类的由来

JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用

了。而Calendar并不比Date好多少。它们面临的问题是：

          Date类中的年份是从1900开始的，而月份都从0开始。

          格式化只对Date类有用，对Calendar类则不能使用。

          非线程安全等。

Java8 日期类的概述

Java 8通过发布新的Date-Time API来进一步加强对 日期与时间的处理。

java.time包：该包日期/时间API的基础包。

java.time.chrono包：该包提供对不同日历系统的访问。

java.time.format包：该包能够格式化和解析日期时间对象。

java.time.temporal包：该包包含底层框架和扩展特性。

java.time.zone包：该包支持不同时区以及相关规则的类。

LocalDate 类的概述

（ 1 ）基本概念

java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。

（ 2 ）常用的方法

LocalTime 类的概述

（ 1 ）基本概念

java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。

（ 2 ）常用的方法

LocalDateTime 类的概述

（ 1 ）基本概念

java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-03T10:15:30。

（ 2 ）常用的方法

Instant 类的概述

（ 1 ）基本概念

java.time.Instant类主要用于描述瞬间的时间点信息。

（ 2 ）常用的方法

 DateTimeFormatter 类的概述

（ 1 ）基本概念

java.time.format.DateTimeFormatter类主要用于格式化和解析日期。

（2）常用的方法

 

集合类库 

集合的由来

当需要在Java程序中记录单个数据内容时，则声明一个变量。

当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。

当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。

当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。

当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

集合的框架结构

Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。

其中Collection集合中存取元素的基本单位是：单个元素。

其中Map集合中存取元素的基本单位是：单对元素。

Collection 集合（重点）

基本概念

java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法 既可用于操作List集合，也可用于操作Queue集合和Set集合。

常用的方法（练熟、记住）

Iterator 接口（重点）

基本概念

java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。

java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭

代器对象。

常用的方法

案例题目：

如何使用迭代器实现toString方法的打印效果？

public class StringequlesTest {
    public static void main(String[] args) {


        List isList= Arrays.asList(new String[]{"this", "is", "a", "list"});
        Iterator items=isList.iterator();
        while(items.hasNext()){
            System.out.print(items.next());
            System.out.print(" ");
        }

    }
}

for each循环（重点）

语法格式

for(元素类型 变量名 : 数组/集合名称) {

循环体;

}

执行流程

不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止。

List集合（重中之重）

基本概念

java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。

该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。

其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。

其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。

可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList 更适合于 机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。

其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的 数据结构，叫做栈(last in fifirst out LIFO)。

其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的 类，效率比较低，以后开发中基本不用。

常用的方法

案例题目

准备一个Stack集合，将数据11、22、33、44、55依次入栈并打印，然后查看栈顶元素并打印， 然后将栈中所有数据依次出栈并打印。

再准备一个Stack对象，将数据从第一个栈中取出来放入第二个栈中，然后再从第二个栈中取出并 打印。

import java.util.*;

public class StringequlesTest {
    public static void main(String[] args) {

        Stack isList=new Stack<>();
        Stack twoList=new Stack<>();
        isList.push(11);
        isList.push(22);
        isList.push(33);
        isList.push(44);
//        System.out.println(isList.peek());
//        System.out.println(isList.pop());
//        System.out.println(isList.pop());
//        System.out.println(isList.pop());
//        System.out.println(isList.pop());

        for (int i = 0; i <4 ; i++) {
            twoList.push(isList.pop());

        }
        System.out.println(twoList.pop());
        System.out.println(twoList.pop());
        System.out.println(twoList.pop());
        System.out.println(twoList.pop());



    }
}

Queue集合（重点）

基本概念

java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。

该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(fifirst in fifirst out FIFO)。

该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。

常用的方法

案例题目

准备一个Queue集合，将数据11、22、33、44、55依次入队并打印，然后查看队首元素并打印，

然后将队列中所有数据依次出队并打印。

import java.util.*;

public class StringequlesTest {
    public static void main(String[] args) {


        Queue isList=new LinkedList<>();
        isList.offer(11);
        isList.offer(22);
        isList.offer(33);
        isList.offer(44);
        System.out.println(isList.peek());
        for (int i = 0; i <4 ; i++) {
            System.out.println(isList.poll());

        }


    }
}

泛型机制（熟悉）

基本概念

通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此 从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换， 而强制类型转换可能会引发类型转换异常。

为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>

的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。

泛型只在编译时期有效，在运行时期不区分是什么类型。

底层原理

泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位， 而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所 有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。

如：

//其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位

//int i = 10; E = String;

//int i = 20; E = Integer;

public static void show(int i) { public interface List {

... ...

} }

//其中10叫做实际参数，负责给形式参数初始化 //其中String叫做实际参数

show(10); List lt1 = ...;

show(20); List lt2 = ...;

 

自定义泛型接口

泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如： 等。

自定义泛型类

泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如： 等。

实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型。

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。

子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

自定义泛型方法

泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化。

泛型方法的格式：

[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) { 方法体; }

在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法。

泛型在继承上的体现

如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！

比如：String是Object的子类，但是List并不是List的子类。

通配符的使用

有时候我们希望传入的类型在一个指定的范围内，此时就可以使用泛型通配符了。

如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传入。

泛型中有三种通配符形式：

无限制通配符：表示我们可以传入任意类型的参数。

表示类型的上界是E，只能是E或者是E的子类。

表示类型的下界是E，只能是E或者是E的父类。

import java.util.LinkedList;
import java.util.List;

public class Dog extends Animal {
    public static void main(String[] args) {
        //表示是Animal的子类和本身，因为具体不知道这个子类能小到哪个孙子辈，所以不接受添加
        List lt4=new LinkedList<>();
        Animal a=lt4.get(0);
//        lt4.add(new tuii());      error
//        lt4.add(new Animal());    error
//        lt4.add(new Dog());   error

        //表示是Animal的任意父类或是本身，这个类一定>=Animal,所以lt5可以接受添加Animal本身和他的子类
        List lt5=new LinkedList<>();
        Object ob=lt5.get(0);
        lt5.add(new Animal());
        lt5.add(new Dog());
        lt5.add(new tuii());
//        lt5.add(new Object()); error
    }
}
class tuii extends Dog{

}

Set集合（熟悉）

基本概念

java.util.Set集合是Collection集合的子集合，与List集合平级。

该集合中元素没有先后放入次序，且不允许重复。

该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。

其中HashSet类的底层是采用哈希表进行数据管理的。

其中TreeSet类的底层是采用红黑树进行数据管理的。

其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

常用的方法

参考Collection集合中的方法即可！

案例题目

准备一个Set集合指向HashSet对象，向该集合中添加元素"two"并打印，再向集合中添加元素"one"并打印，再向集合中添加元素"three"并打印，再向集合中添加"one"并打印。

import java.util.*;

public class StringequlesTest {
    public static void main(String[] args) {


        Set isSet=new HashSet<>();
        isSet.add("one");
        System.out.println(isSet);
        isSet.add("two");
        System.out.println(isSet);
        isSet.add("three");
        System.out.println(isSet);
        isSet.add("one");
        System.out.println(isSet);


    }
}

元素放入 HashSet 集合的原理

使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。

若该位置没有元素，则将该元素直接放入即可。

若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。

若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。

若相等则添加元素失败，否则将元素直接放入即可。

思考：为什么要求重写equals方法后要重写hashCode方法呢？

 

解析：

当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元素比较即可，从而提高效率并避免重复元素的出现。

TreeSet 集合的概念

二叉树主要指每个节点最多只有两个子节点的树形结构。

满足以下3个特征的二叉树叫做有序二叉树。

       a.左子树中的任意节点元素都小于根节点元素值；

       b.右子树中的任意节点元素都大于根节点元素值；

       c.左子树和右子树的内部也遵守上述规则；

由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使

用新元素与集合中已有的元素依次比较来确定新元素的合理位置。

比较元素大小的规则有两种方式：

使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；

使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；

自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；

Map 集合（重点）

基本概念

java.util.Map集合中存取元素的基本单位是：单对元素，其中类型参数如下：

K - 此映射所维护的键(Key)的类型，相当于目录。

V - 映射值(Value)的类型，相当于内容。

该集合中key是不允许重复的，而且一个key只能对应一个value。

该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。

其中HashMap类的底层是采用哈希表进行数据管理的。

其中TreeMap类的底层是采用红黑树进行数据管理的。

其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。

其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。

Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。

经常用于根据key检索value的业务场景。

常用的方法

元素放入 HashMap 集合的原理

使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置。

若该位置没有元素，则将该键值对直接放入即可。

若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。

若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较。

若相等则将对应的value修改，否则将键值对直接放入即可。

相关的常量

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。

DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75。

threshold：扩容的临界值，该数值为：容量*填充因子，也就是12。

TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8。

MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64。

Collections 类

基本概念

java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。

常用的方法

 课堂作业

1. 编程题 

 编程统计字符串"ABCD123!@#$%ab"中大写字母、小写字母、数字、其它字符的个数并打 印出来。 

2. 编程题 

 编程获取两个指定字符串中的最大相同子串。 

 如： s1="asdafghjka", s2="aaasdfg" 他们的最大子串为"asd"  

 提示： 将短的那个串进行长度依次递减的子串与较长的串比较。 

3. 编程题 

 准备一个 HashMap 集合，统计字符串"123,456,789,123,456"中每个数字字符串出现的次数并打印出来。 

 如： 

        123 出现了 2 次 

        456 出现了 2 次 

        789 出现了 1 次 

4. 编程题 

 使用 List 集合实现简易的学生信息管理系统，要求打印字符界面提示用户选择相应的功 能，根据用户输入的选择去实现增加、删除、修改、查找以及遍历所有学生信息的功能。 

 其中学生的信息有：学号、姓名、年龄。 要求： 尽量将功能拆分为多个.java 文件。

5. 编程题 

 使用集合实现斗地主游戏的部分功能，要求如下： 

 （1）首先准备 54 张扑克牌并打乱顺序。 

 （2）由三个玩家交替摸牌，每人 17 张扑克牌，最后三张留作底牌。 

 （3）查看三个玩家手中的扑克牌和底牌。 

 （4）其中玩家手中的扑克牌需要按照大小顺序打印，规则如下： 

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

因为作业写完有好几个文件，所以放到仓库了，码云地址为https://gitee.com/bigload/java_big_data/tree/master/mode3，有什么不对的还望指点！！！