编程学习
🗒️2019黑马java笔记④
00 分钟
2024-2-26
2024-3-2
type
status
date
slug
summary
tags
category
icon
password

1.包装类

1.1基本类型包装类(记忆)

  • 基本类型包装类的作用
    • 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
      常用的操作之一:用于基本数据类型与字符串之间的转换
  • 基本类型对应的包装类
    • 基本数据类型
      包装类
      byte
      Byte
      short
      Short
      int
      Integer
      long
      Long
      float
      Float
      double
      Double
      char
      Character
      boolean
      Boolean

1.2Integer类(应用)

  • Integer类概述
    • 包装一个对象中的原始类型 int 的值
  • Integer类构造方法
    • 方法名
      说明
      public Integer(int value)
      根据 int 值创建 Integer 对象(过时)
      public Integer(String s)
      根据 String 值创建 Integer 对象(过时)
      public static Integer valueOf(int i)
      返回表示指定的 int 值的 Integer 实例
      public static Integer valueOf(String s)
      返回一个保存指定值的 Integer 对象 String
  • 示例代码

    1.3int和String类型的相互转换(记忆)

    • int转换为String
      • 转换方式
        • 方式一:直接在数字后加一个空字符串
        • 方式二:通过String类静态方法valueOf()
      • 示例代码
      • String转换为int
        • 转换方式
          • 方式一:先将字符串数字转成Integer,再调用valueOf()方法
          • 方式二:通过Integer静态方法parseInt()进行转换
        • 示例代码

        1.4字符串数据排序案例(应用)

        • 案例需求
          • 有一个字符串:“91 27 46 38 50”,请写程序实现最终输出结果是:“27 38 46 50 91”
        • 代码实现

          1.5自动拆箱和自动装箱(理解)

          • 自动装箱
            • 把基本数据类型转换为对应的包装类类型
          • 自动拆箱
            • 把包装类类型转换为对应的基本数据类型
          • 示例代码

            2.时间日期类

            2.1Date类(应用)

            • Date类概述
              • Date 代表了一个特定的时间,精确到毫秒
            • Date类构造方法
              • 方法名
                说明
                public Date()
                分配一个 Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒
                public Date(long date)
                分配一个 Date对象,并将其初始化为表示从标准基准时间起指定的毫秒数
            • 示例代码

              2.2Date类常用方法(应用)

              • 常用方法
                • 方法名
                  说明
                  public long getTime()
                  获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
                  public void setTime(long time)
                  设置时间,给的是毫秒值
              • 示例代码

                2.3SimpleDateFormat类(应用)

                • SimpleDateFormat类概述
                  • SimpleDateFormat是一个具体的类,用于以区域设置敏感的方式格式化和解析日期。
                    我们重点学习日期格式化和解析
                • SimpleDateFormat类构造方法
                  • 方法名
                    说明
                    public SimpleDateFormat()
                    构造一个SimpleDateFormat,使用默认模式和日期格式
                    public SimpleDateFormat(String pattern)
                    构造一个SimpleDateFormat使用给定的模式和默认的日期格式
                • SimpleDateFormat类的常用方法
                  • 格式化(从Date到String)
                    • public final String format(Date date):将日期格式化成日期/时间字符串
                  • 解析(从String到Date)
                    • public Date parse(String source):从给定字符串的开始解析文本以生成日期
                • 示例代码

                  2.4日期工具类案例(应用)

                  • 案例需求
                    • 定义一个日期工具类(DateUtils),包含两个方法:把日期转换为指定格式的字符串;把字符串解析为指定格式的日期,然后定义一个测试类(DateDemo),测试日期工具类的方法
                  • 代码实现
                    • 工具类
                    • 测试类

                  2.5Calendar类(应用)

                  • Calendar类概述
                    • Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法
                      Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。
                      该方法返回一个Calendar 对象。
                      其日历字段已使用当前日期和时间初始化:Calendar rightNow = Calendar.getInstance();
                  • Calendar类常用方法
                    • 方法名
                      说明
                      public int get(int field)
                      返回给定日历字段的值
                      public abstract void add(int field, int amount)
                      根据日历的规则,将指定的时间量添加或减去给定的日历字段
                      public final void set(int year,int month,int date)
                      设置当前日历的年月日
                  • 示例代码

                    2.6二月天案例(应用)

                    • 案例需求
                      • 获取任意一年的二月有多少天
                    • 代码实现

                      3.异常

                      3.1异常(记忆)

                      • 异常的概述
                        • 异常就是程序出现了不正常的情况
                      • 异常的体系结构
                        • notion image

                      3.2JVM默认处理异常的方式(理解)

                      • 如果程序出现了问题,我们没有做任何处理,最终JVM 会做默认的处理,处理方式有如下两个步骤:
                      • 把异常的名称,错误原因及异常出现的位置等信息输出在了控制台
                      • 程序停止执行

                      3.3try-catch方式处理异常(应用)

                      • 定义格式
                        • 执行流程
                          • 程序从 try 里面的代码开始执行
                          • 出现异常,就会跳转到对应的 catch 里面去执行
                          • 执行完毕之后,程序还可以继续往下执行
                        • 示例代码

                          3.4Throwable成员方法(应用)

                          • 常用方法
                            • 方法名
                              说明
                              public String getMessage()
                              返回此 throwable 的详细消息字符串
                              public String toString()
                              返回此可抛出的简短描述
                              public void printStackTrace()
                              把异常的错误信息输出在控制台
                          • 示例代码

                            3.5编译时异常和运行时异常的区别(记忆)

                            • 编译时异常
                              • 都是Exception类及其子类
                              • 必须显示处理,否则程序就会发生错误,无法通过编译
                            • 运行时异常
                              • 都是RuntimeException类及其子类
                              • 无需显示处理,也可以和编译时异常一样处理

                            3.6throws方式处理异常(应用)

                            • 定义格式
                              • 示例代码
                                • 注意事项
                                  • 这个throws格式是跟在方法的括号后面的
                                  • 编译时异常必须要进行处理,两种处理方案:try...catch …或者 throws,如果采用 throws 这种方案,将来谁调用谁处理
                                  • 运行时异常可以不处理,出现问题后,需要我们回来修改代码

                                3.7throws和throw的区别(记忆)

                                3.8自定义异常(应用)

                                • 自定义异常类
                                  • 老师类
                                    • 测试类

                                      1.Collection集合

                                      1.1集合体系结构【记忆】

                                      • 集合类的特点
                                        • 提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变
                                      • 集合类的体系图
                                        • notion image

                                      1.2Collection集合概述和基本使用【应用】

                                      • Collection集合概述
                                        • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
                                        • JDK 不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现
                                      • Collection集合基本使用

                                        1.3Collection集合的常用方法【应用】

                                        方法名
                                        说明
                                        boolean add(E e)
                                        添加元素
                                        boolean remove(Object o)
                                        从集合中移除指定的元素
                                        void clear()
                                        清空集合中的元素
                                        boolean contains(Object o)
                                        判断集合中是否存在指定的元素
                                        boolean isEmpty()
                                        判断集合是否为空
                                        int size()
                                        集合的长度,也就是集合中元素的个数

                                        1.4Collection集合的遍历【应用】

                                        • 迭代器的介绍
                                          • 迭代器,集合的专用遍历方式
                                          • Iterator<E> iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
                                          • 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
                                        • Collection集合的遍历

                                        1.5集合使用步骤图解【理解】

                                        • 使用步骤
                                        notion image

                                        1.6集合的案例-Collection集合存储学生对象并遍历【应用】

                                        • 案例需求
                                          • 创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
                                        • 代码实现
                                          • 学生类
                                          • 测试类

                                        2.List集合

                                        2.1List集合概述和特点【记忆】

                                        • List集合概述
                                          • 有序集合(也称为序列),用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素,并搜索列表中的元素
                                          • 与Set集合不同,列表通常允许重复的元素
                                        • List集合特点
                                          • 有索引
                                          • 可以存储重复元素
                                          • 元素存取有序

                                        2.2List集合的特有方法【应用】

                                        方法名
                                        描述
                                        void add(int index,E element)
                                        在此集合中的指定位置插入指定的元素
                                        E remove(int index)
                                        删除指定索引处的元素,返回被删除的元素
                                        E set(int index,E element)
                                        修改指定索引处的元素,返回被修改的元素
                                        E get(int index)
                                        返回指定索引处的元素

                                        2.3集合的案例-List集合存储学生对象并遍历【应用】

                                        • 案例需求
                                          • 创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
                                        • 代码实现
                                          • 学生类
                                            • 测试类

                                            2.4并发修改异常【应用】

                                            • 出现的原因
                                              • 迭代器遍历的过程中,通过集合对象修改了集合中的元素,造成了迭代器获取元素中判断预期修改值和实际修改值不一致,则会出现:ConcurrentModificationException
                                            • 解决的方案
                                              • 用for循环遍历,然后用集合对象做对应的操作即可
                                            • 示例代码

                                              2.5列表迭代器【应用】

                                              • ListIterator介绍
                                                • 通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器
                                                • 用于允许程序员沿任一方向遍历的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
                                              • 示例代码

                                                2.6增强for循环【应用】

                                                • 定义格式
                                                  • 示例代码

                                                    2.7集合的案例-List集合存储学生对象三种方式遍历【应用】

                                                    • 案例需求
                                                      • 创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
                                                    • 代码实现
                                                      • 学生类
                                                        • 测试类

                                                        3.数据结构

                                                        3.1数据结构之栈和队列【记忆】

                                                        • 栈结构
                                                          • 先进后出
                                                        • 队列结构
                                                          • 先进先出

                                                        3.2数据结构之数组和链表【记忆】

                                                        • 数组结构
                                                          • 查询快、增删慢
                                                        • 队列结构
                                                          • 查询慢、增删快

                                                        4.List集合的实现类

                                                        4.1List集合子类的特点【记忆】

                                                        • ArrayList集合
                                                          • 底层是数组结构实现,查询快、增删慢
                                                        • LinkedList集合
                                                          • 底层是链表结构实现,查询慢、增删快

                                                        4.2集合的案例-ArrayList集合存储学生对象三种方式遍历【应用】

                                                        • 案例需求
                                                          • 创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
                                                        • 代码实现
                                                          • 学生类
                                                            • 测试类

                                                            4.3LinkedList集合的特有功能【应用】

                                                            • 特有方法
                                                              • 方法名
                                                                说明
                                                                public void addFirst(E e)
                                                                在该列表开头插入指定的元素
                                                                public void addLast(E e)
                                                                将指定的元素追加到此列表的末尾
                                                                public E getFirst()
                                                                返回此列表中的第一个元素
                                                                public E getLast()
                                                                返回此列表中的最后一个元素
                                                                public E removeFirst()
                                                                从此列表中删除并返回第一个元素
                                                                public E removeLast()
                                                                从此列表中删除并返回最后一个元素

                                                            1.Set集合

                                                            1.1Set集合概述和特点【应用】

                                                            • Set集合的特点
                                                              • 元素存取无序
                                                              • 没有索引、只能通过迭代器或增强for循环遍历
                                                              • 不能存储重复元素
                                                            • Set集合的基本使用

                                                            1.2哈希值【理解】

                                                            • 哈希值简介
                                                              • 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
                                                            • 如何获取哈希值
                                                              • Object类中的public int hashCode():返回对象的哈希码值
                                                            • 哈希值的特点
                                                              • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
                                                              • 默认情况下,不同对象的哈希值是不同的。而重写hashCode()方法,可以实现让不同对象的哈希值相同
                                                            • 获取哈希值的代码
                                                              • 学生类
                                                              • 测试类

                                                            1.3HashSet集合概述和特点【应用】

                                                            • HashSet集合的特点
                                                              • 底层数据结构是哈希表
                                                              • 对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致
                                                              • 没有带索引的方法,所以不能使用普通for循环遍历
                                                              • 由于是Set集合,所以是不包含重复元素的集合
                                                            • HashSet集合的基本使用

                                                              1.4HashSet集合保证元素唯一性源码分析【理解】

                                                              • HashSet集合保证元素唯一性的原理
                                                                • 1.根据对象的哈希值计算存储位置
                                                                  如果当前位置没有元素则直接存入
                                                                  如果当前位置有元素存在,则进入第二步
                                                                  2.当前元素的元素和已经存在的元素比较哈希值
                                                                  如果哈希值不同,则将当前元素进行存储
                                                                  如果哈希值相同,则进入第三步
                                                                  3.通过equals()方法比较两个元素的内容
                                                                  如果内容不相同,则将当前元素进行存储
                                                                  如果内容相同,则不存储当前元素
                                                              • HashSet集合保证元素唯一性的图解
                                                                • notion image

                                                              1.5常见数据结构之哈希表【理解】

                                                              notion image

                                                              1.6HashSet集合存储学生对象并遍历【应用】

                                                              • 案例需求
                                                                • 创建一个存储学生对象的集合,存储多个学生对象,使用程序实现在控制台遍历该集合
                                                                • 要求:学生对象的成员变量值相同,我们就认为是同一个对象
                                                              • 代码实现
                                                                • 学生类
                                                                  • 测试类

                                                                  1.7LinkedHashSet集合概述和特点【应用】

                                                                  • LinkedHashSet集合特点
                                                                    • 哈希表和链表实现的Set接口,具有可预测的迭代次序
                                                                    • 由链表保证元素有序,也就是说元素的存储和取出顺序是一致的
                                                                    • 由哈希表保证元素唯一,也就是说没有重复的元素
                                                                  • LinkedHashSet集合基本使用

                                                                    2.Set集合排序

                                                                    2.1TreeSet集合概述和特点【应用】

                                                                    • TreeSet集合概述
                                                                      • 元素有序,可以按照一定的规则进行排序,具体排序方式取决于构造方法
                                                                        • TreeSet():根据其元素的自然排序进行排序
                                                                        • TreeSet(Comparator comparator) :根据指定的比较器进行排序
                                                                      • 没有带索引的方法,所以不能使用普通for循环遍历
                                                                      • 由于是Set集合,所以不包含重复元素的集合
                                                                    • TreeSet集合基本使用

                                                                      2.2自然排序Comparable的使用【应用】

                                                                      • 案例需求
                                                                        • 存储学生对象并遍历,创建TreeSet集合使用无参构造方法
                                                                        • 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
                                                                      • 实现步骤
                                                                        • 用TreeSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的
                                                                        • 自然排序,就是让元素所属的类实现Comparable接口,重写compareTo(T o)方法
                                                                        • 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
                                                                      • 代码实现
                                                                        • 学生类
                                                                          • 测试类

                                                                          2.3比较器排序Comparator的使用【应用】

                                                                          • 案例需求
                                                                            • 存储学生对象并遍历,创建TreeSet集合使用带参构造方法
                                                                            • 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
                                                                          • 实现步骤
                                                                            • 用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序的
                                                                            • 比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法
                                                                            • 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
                                                                          • 代码实现
                                                                            • 学生类
                                                                              • 测试类

                                                                              2.4成绩排序案例【应用】

                                                                              • 案例需求
                                                                                • 用TreeSet集合存储多个学生信息(姓名,语文成绩,数学成绩),并遍历该集合
                                                                                • 要求:按照总分从高到低出现
                                                                              • 代码实现
                                                                                • 学生类
                                                                                  • 测试类

                                                                                  2.5不重复的随机数案例【应用】

                                                                                  • 案例需求
                                                                                    • 编写一个程序,获取10个1-20之间的随机数,要求随机数不能重复,并在控制台输出
                                                                                  • 代码实现

                                                                                    3.泛型

                                                                                    3.1泛型概述和好处【理解】

                                                                                    • 泛型概述
                                                                                      • 是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型
                                                                                        它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口
                                                                                    • 泛型定义格式
                                                                                      • <类型>:指定一种类型的格式。这里的类型可以看成是形参
                                                                                      • <类型1,类型2…>:指定多种类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参
                                                                                      • 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型
                                                                                    • 泛型的好处
                                                                                      • 把运行时期的问题提前到了编译期间
                                                                                      • 避免了强制类型转换

                                                                                    3.2泛型类【应用】

                                                                                    • 定义格式
                                                                                      • 示例代码
                                                                                        • 泛型类
                                                                                          • 测试类

                                                                                          3.3泛型方法【应用】

                                                                                          • 定义格式
                                                                                            • 示例代码
                                                                                              • 带有泛型方法的类
                                                                                                • 测试类

                                                                                                3.4泛型接口【应用】

                                                                                                • 定义格式
                                                                                                  • 示例代码
                                                                                                    • 泛型接口
                                                                                                      • 泛型接口实现类
                                                                                                        • 测试类

                                                                                                        3.5类型通配符【应用】

                                                                                                        • 类型通配符的作用
                                                                                                          • 为了表示各种泛型List的父类,可以使用类型通配符
                                                                                                        • 类型通配符的分类
                                                                                                          • 类型通配符:<?>
                                                                                                            • List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
                                                                                                            • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中
                                                                                                          • 类型通配符上限:<? extends 类型>
                                                                                                            • List<? extends Number>:它表示的类型是Number或者其子类型
                                                                                                          • 类型通配符下限:<? super 类型>
                                                                                                            • List<? super Number>:它表示的类型是Number或者其父类型
                                                                                                        • 类型通配符的基本使用

                                                                                                          4.可变参数

                                                                                                          4.1可变参数【应用】

                                                                                                          • 可变参数介绍
                                                                                                            • 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了
                                                                                                          • 可变参数定义格式
                                                                                                            • 可变参数的注意事项
                                                                                                              • 这里的变量其实是一个数组
                                                                                                              • 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
                                                                                                            • 可变参数的基本使用

                                                                                                              4.2可变参数的使用【应用】

                                                                                                              • Arrays工具类中有一个静态方法:
                                                                                                                • public static <T> List<T> asList(T... a):返回由指定数组支持的固定大小的列表
                                                                                                                • 返回的集合不能做增删操作,可以做修改操作
                                                                                                              • List接口中有一个静态方法:
                                                                                                                • public static <E> List<E> of(E... elements):返回包含任意数量元素的不可变列表
                                                                                                                • 返回的集合不能做增删改操作
                                                                                                              • Set接口中有一个静态方法:
                                                                                                                • public static <E> Set<E> of(E... elements) :返回一个包含任意数量元素的不可变集合
                                                                                                                • 在给元素的时候,不能给重复的元素
                                                                                                                • 返回的集合不能做增删操作,没有修改的方法
                                                                                                              • 示例代码

                                                                                                                1.Map集合

                                                                                                                1.1Map集合概述和特点【理解】

                                                                                                                • Map集合概述
                                                                                                                  • Map集合的特点
                                                                                                                    • 键值对映射关系
                                                                                                                    • 一个键对应一个值
                                                                                                                    • 键不能重复,值可以重复
                                                                                                                    • 元素存取无序
                                                                                                                  • Map集合的基本使用

                                                                                                                    1.2Map集合的基本功能【应用】

                                                                                                                    • 方法介绍
                                                                                                                      • 方法名
                                                                                                                        说明
                                                                                                                        V put(K key,V value)
                                                                                                                        添加元素
                                                                                                                        V remove(Object key)
                                                                                                                        根据键删除键值对元素
                                                                                                                        void clear()
                                                                                                                        移除所有的键值对元素
                                                                                                                        boolean containsKey(Object key)
                                                                                                                        判断集合是否包含指定的键
                                                                                                                        boolean containsValue(Object value)
                                                                                                                        判断集合是否包含指定的值
                                                                                                                        boolean isEmpty()
                                                                                                                        判断集合是否为空
                                                                                                                        int size()
                                                                                                                        集合的长度,也就是集合中键值对的个数
                                                                                                                    • 示例代码

                                                                                                                      1.3Map集合的获取功能【应用】

                                                                                                                      • 方法介绍
                                                                                                                        • 方法名
                                                                                                                          说明
                                                                                                                          V get(Object key)
                                                                                                                          根据键获取值
                                                                                                                          Set<K> keySet()
                                                                                                                          获取所有键的集合
                                                                                                                          Collection<V> values()
                                                                                                                          获取所有值的集合
                                                                                                                          Set<Map.Entry<K,V>> entrySet()
                                                                                                                          获取所有键值对对象的集合
                                                                                                                      • 示例代码

                                                                                                                        1.4Map集合的遍历(方式1)【应用】

                                                                                                                        • 遍历思路
                                                                                                                          • 我们刚才存储的元素都是成对出现的,所以我们把Map看成是一个夫妻对的集合
                                                                                                                            • 把所有的丈夫给集中起来
                                                                                                                            • 遍历丈夫的集合,获取到每一个丈夫
                                                                                                                            • 根据丈夫去找对应的妻子
                                                                                                                        • 步骤分析
                                                                                                                          • 获取所有键的集合。用keySet()方法实现
                                                                                                                          • 遍历键的集合,获取到每一个键。用增强for实现
                                                                                                                          • 根据键去找值。用get(Object key)方法实现
                                                                                                                        • 代码实现

                                                                                                                          1.5Map集合的遍历(方式2)【应用】

                                                                                                                          • 遍历思路
                                                                                                                            • 我们刚才存储的元素都是成对出现的,所以我们把Map看成是一个夫妻对的集合
                                                                                                                              • 获取所有结婚证的集合
                                                                                                                              • 遍历结婚证的集合,得到每一个结婚证
                                                                                                                              • 根据结婚证获取丈夫和妻子
                                                                                                                          • 步骤分析
                                                                                                                            • 获取所有键值对对象的集合
                                                                                                                              • Set<Map.Entry<K,V>> entrySet():获取所有键值对对象的集合
                                                                                                                            • 遍历键值对对象的集合,得到每一个键值对对象
                                                                                                                              • 用增强for实现,得到每一个Map.Entry
                                                                                                                            • 根据键值对对象获取键和值
                                                                                                                              • 用getKey()得到键
                                                                                                                              • 用getValue()得到值
                                                                                                                          • 代码实现

                                                                                                                            1.6Map集合的案例【应用】

                                                                                                                            1.6.1HashMap集合练习之键是String值是Student

                                                                                                                            • 案例需求
                                                                                                                              • 创建一个HashMap集合,键是学号(String),值是学生对象(Student)。存储三个键值对元素,并遍历
                                                                                                                            • 代码实现
                                                                                                                              • 学生类
                                                                                                                                • 测试类

                                                                                                                                1.6.2HashMap集合练习之键是Student值是String

                                                                                                                                • 案例需求
                                                                                                                                  • 创建一个HashMap集合,键是学生对象(Student),值是居住地 (String)。存储多个元素,并遍历。
                                                                                                                                  • 要求保证键的唯一性:如果学生对象的成员变量值相同,我们就认为是同一个对象
                                                                                                                                • 代码实现
                                                                                                                                  • 学生类
                                                                                                                                    • 测试类

                                                                                                                                    1.6.3集合嵌套之ArrayList嵌套HashMap

                                                                                                                                    • 案例需求
                                                                                                                                      • 创建一个ArrayList集合,存储三个元素,每一个元素都是HashMap
                                                                                                                                      • 每一个HashMap的键和值都是String,并遍历。
                                                                                                                                    • 代码实现

                                                                                                                                      1.6.4集合嵌套之HashMap嵌套ArrayList

                                                                                                                                      • 案例需求
                                                                                                                                        • 创建一个HashMap集合,存储三个键值对元素,每一个键值对元素的键是String,值是ArrayList
                                                                                                                                        • 每一个ArrayList的元素是String,并遍历。
                                                                                                                                      • 代码实现

                                                                                                                                        1.6.5统计字符串中每个字符出现的次数

                                                                                                                                        • 案例需求
                                                                                                                                          • 键盘录入一个字符串,要求统计字符串中每个字符串出现的次数。
                                                                                                                                          • 举例:键盘录入“aababcabcdabcde” 在控制台输出:“a(5)b(4)c(3)d(2)e(1)”
                                                                                                                                        • 代码实现

                                                                                                                                          2.Collections集合工具类

                                                                                                                                          2.1Collections概述和使用【应用】

                                                                                                                                          • Collections类的作用
                                                                                                                                            • 是针对集合操作的工具类
                                                                                                                                          • Collections类常用方法
                                                                                                                                            • 方法名
                                                                                                                                              说明
                                                                                                                                              public static void sort(List<T> list)
                                                                                                                                              将指定的列表按升序排序
                                                                                                                                              public static void reverse(List<?> list)
                                                                                                                                              反转指定列表中元素的顺序
                                                                                                                                              public static void shuffle(List<?> list)
                                                                                                                                              使用默认的随机源随机排列指定的列表
                                                                                                                                          • 示例代码

                                                                                                                                            2.2ArrayList集合存储学生并排序【应用】

                                                                                                                                            • 案例需求
                                                                                                                                              • ArrayList存储学生对象,使用Collections对ArrayList进行排序
                                                                                                                                              • 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
                                                                                                                                            • 代码实现
                                                                                                                                              • 学生类
                                                                                                                                                • 测试类

                                                                                                                                                3.斗地主案例

                                                                                                                                                3.1模拟斗地主案例-普通版本【应用】

                                                                                                                                                • 案例需求
                                                                                                                                                  • 通过程序实现斗地主过程中的洗牌,发牌和看牌
                                                                                                                                                • 代码实现

                                                                                                                                                  3.2模拟斗地主案例-升级版本【应用】

                                                                                                                                                  • 案例需求
                                                                                                                                                    • 通过程序实现斗地主过程中的洗牌,发牌和看牌。要求:对牌进行排序
                                                                                                                                                  • 代码实现

                                                                                                                                                    1.File类

                                                                                                                                                    1.1File类概述和构造方法【应用】

                                                                                                                                                    • File类介绍
                                                                                                                                                      • 它是文件和目录路径名的抽象表示
                                                                                                                                                      • 文件和目录是可以通过File封装成对象的
                                                                                                                                                      • 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已。它可以是存在的,也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
                                                                                                                                                    • File类的构造方法
                                                                                                                                                      • 方法名
                                                                                                                                                        说明
                                                                                                                                                        File(String pathname)
                                                                                                                                                        通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
                                                                                                                                                        File(String parent, String child)
                                                                                                                                                        从父路径名字符串和子路径名字符串创建新的 File实例
                                                                                                                                                        File(File parent, String child)
                                                                                                                                                        从父抽象路径名和子路径名字符串创建新的 File实例
                                                                                                                                                    • 示例代码

                                                                                                                                                      1.2File类创建功能【应用】

                                                                                                                                                      • 方法分类
                                                                                                                                                        • 方法名
                                                                                                                                                          说明
                                                                                                                                                          public boolean createNewFile()
                                                                                                                                                          当具有该名称的文件不存在时,创建一个由该抽象路径名命名的新空文件
                                                                                                                                                          public boolean mkdir()
                                                                                                                                                          创建由此抽象路径名命名的目录
                                                                                                                                                          public boolean mkdirs()
                                                                                                                                                          创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录
                                                                                                                                                      • 示例代码

                                                                                                                                                        1.3File类判断和获取功能【应用】

                                                                                                                                                        • 判断功能
                                                                                                                                                          • 方法名
                                                                                                                                                            说明
                                                                                                                                                            public boolean isDirectory()
                                                                                                                                                            测试此抽象路径名表示的File是否为目录
                                                                                                                                                            public boolean isFile()
                                                                                                                                                            测试此抽象路径名表示的File是否为文件
                                                                                                                                                            public boolean exists()
                                                                                                                                                            测试此抽象路径名表示的File是否存在
                                                                                                                                                        • 获取功能
                                                                                                                                                          • 方法名
                                                                                                                                                            说明
                                                                                                                                                            public String getAbsolutePath()
                                                                                                                                                            返回此抽象路径名的绝对路径名字符串
                                                                                                                                                            public String getPath()
                                                                                                                                                            将此抽象路径名转换为路径名字符串
                                                                                                                                                            public String getName()
                                                                                                                                                            返回由此抽象路径名表示的文件或目录的名称
                                                                                                                                                            public String[] list()
                                                                                                                                                            返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
                                                                                                                                                            public File[] listFiles()
                                                                                                                                                            返回此抽象路径名表示的目录中的文件和目录的File对象数组
                                                                                                                                                        • 示例代码

                                                                                                                                                          1.4File类删除功能【应用】

                                                                                                                                                          • 方法分类
                                                                                                                                                            • 方法名
                                                                                                                                                              说明
                                                                                                                                                              public boolean delete()
                                                                                                                                                              删除由此抽象路径名表示的文件或目录
                                                                                                                                                          • 示例代码
                                                                                                                                                            • 绝对路径和相对路径的区别
                                                                                                                                                              • 绝对路径:完整的路径名,不需要任何其他信息就可以定位它所表示的文件。例如:E:\itcast\java.txt
                                                                                                                                                              • 相对路径:必须使用取自其他路径名的信息进行解释。例如:myFile\java.txt

                                                                                                                                                            2.递归

                                                                                                                                                            2.1递归【应用】

                                                                                                                                                            • 递归的介绍
                                                                                                                                                              • 以编程的角度来看,递归指的是方法定义中调用方法本身的现象
                                                                                                                                                              • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
                                                                                                                                                              • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
                                                                                                                                                            • 递归的基本使用
                                                                                                                                                              • 递归的注意事项
                                                                                                                                                                • 递归一定要有出口。否则内存溢出
                                                                                                                                                                • 递归虽然有出口,但是递归的次数也不宜过多。否则内存溢出

                                                                                                                                                              2.2递归求阶乘【应用】

                                                                                                                                                              • 案例需求
                                                                                                                                                                • 用递归求5的阶乘,并把结果在控制台输出
                                                                                                                                                              • 代码实现

                                                                                                                                                                2.3递归遍历目录【应用】

                                                                                                                                                                • 案例需求
                                                                                                                                                                  • 给定一个路径(E:\itcast),通过递归完成遍历该目录下所有内容,并把所有文件的绝对路径输出在控制台
                                                                                                                                                                • 代码实现