JAVA笔记10-18

10.01_面向对象(package关键字的概述及作用)(了解)

A:为什么要有包
- 将字节码(.class)进行分类存放
- 包其实就是文件夹
- www.briup.com com.briup.项目名
B:包的概述

举例：
学生：增加，删除，修改，查询
老师：增加，删除，修改，查询
...

  方案1：按照功能分
      com.briup.add
          AddStudent
          AddTeacher
      com.briup.delete
          DeleteStudent
          DeleteTeacher
      com.briup.update
          UpdateStudent
          UpdateTeacher
      com.briup.find
          FindStudent
          FindTeacher
  
  方案2：按照模块分
      com.briup.teacher
          AddTeacher
          DeleteTeacher
          UpdateTeacher
          FindTeacher
      com.briup.student
          AddStudent
          DeleteStudent
          UpdateStudent
          FindStudent

10.02_面向对象(包的定义及注意事项)(掌握)

A:定义包的格式
- package 包名;
- 多级包用.分开即可
B:定义包的注意事项
- A:package语句必须是程序的第一条可执行的代码
- B:package语句在一个java文件中只能有一个
- C:如果没有package，默认表示无包名
C:案例演示
- 包的定义及注意事项

10.03_面向对象(带包的类编译和运行)(掌握)

A:如何编译运行带包的类
- a:javac编译的时候带上-d即可
  - javac -d . HelloWorld.java
- b:通过java命令执行。
  - java 包名.HellWord

10.04_面向对象(不同包下类之间的访问)(掌握)

A:案例演示
- 不同包下类之间的访问
- com.包名.类名去使用别的类。
- 注意：在不同的包中，默认修饰符的成员不能使用；
- 封装：隐藏实现细节，提供公共的访问方式。

10.05_面向对象(import关键字的概述和使用)(掌握)

A:案例演示
- 为什么要有import
  - 其实就是让有包的类对调用者可见,不用写全类名了
B:导包格式
- import 包名.类名;
- 注意：
- 这种方式导入是到类的名称。
- 虽然可以最后写*，但是不建议。
C:package,import,class有没有顺序关系(面试题)
D:案例演示
- 当前目录 Student.java Test.java
  Student: package com.briup.student;
  Test: package com.briup.test; Test中实例化Student对象；
  编译:
  javac -d . Student.java
  javac -d . Test.java
  java com.briup.test.Test
  或
  javac -d bin Student.java
  javac -d bin Test.java
  cd bin
  java com.briup.test.Test
  或
  javac -d bin Student.java
  javac -d . Test.java
  java -cp .;bin com.briup.test.Test

10.06_面向对象(四种权限修饰符的测试)(掌握)

A:案例演示
- 四种权限修饰符
B:结论

              本类   同一个包下  不同包下(子类)    不同包下(无关类)
  private     Y       
  默认          Y       Y
  protected   Y       Y       Y
  public      Y       Y       Y               Y

10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)

A:修饰符：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 抽象修饰符：abstract
B:类：
- 权限修饰符：默认修饰符，public
- 状态修饰符：final
- 抽象修饰符：abstract
- 用的最多的就是：public
C:成员变量：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 用的最多的就是：private
D:构造方法：
- 权限修饰符：private，默认的，protected，public
- 用的最多的就是：public
E:成员方法：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 抽象修饰符：abstract
- 用的最多的就是：public
F:除此以外的组合规则：
- 成员变量：public static final
- 成员方法：
  - public static
  - public abstract
  - public final

10.08_面向对象(内部类概述和访问特点)(了解)

A:内部类概述
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类

10.08_成员内部类

A:成员内部类访问特点
- a:内部类可以直接访问外部类的成员，包括【私有】。此时可以把内部类看成外部类的一个成员。
- b:外部类可以访问内部类的成员【包括私有】，但必须创建内部类对象。
- 外部类名.内部类名对象名 = 外部类对象.内部类对象;
- Outer.Inner inn = new Outer().new Inner();
B:案例演示

  class Outer {
      private int num = 10;
      String name = "test";

      class Inner {
          private int i_num = 5;
          private int num = 20;

          public void show() {
              System.out.println("in Inner,i_num: " + i_num + ",Outer.num: " + num);
          }
          
          public void show2() {
              int num = 30;
              System.out.println(num);        //num
              System.out.println(this.num);   //this.num
              System.out.println(Outer.this.num); //Outer.this.num
          }
      }

      public void disp() {
          System.out.println("in Outer,num: " + num);
          Inner inn = new Inner();
          inn.i_num = 20;
          inn.show();
      }
  }

  class Demo1_Inner {
      public static void main(String[] args) {
          Outer.Inner inn = new Outer().new Inner();
          inn.show();
  
          new Outer().disp();
      }
  }

10.09_面向对象(成员内部类私有使用)(了解)

private 修饰成员内部类，可以将内部类理解成一个私有成员
可以在外部类其他方法中去使用成员私有内部类

10.10_面向对象(静态成员内部类)(了解)

static 看成静态成员
成员内部类被静态修饰后的访问方式是:
- 外部类.内部类对象名 = new 外部类.内部类(...);
注意静态只能访问静态
- static内部类里面所有方法都可以看成 static的
- stataic内部类中只能访问外部类中static成员[属性、方法]

10.11_面向对象(成员内部类的面试题)(掌握)

A:面试题

  要求：使用已知的变量，在控制台输出30，20，10。
  
  class Outer {
      public int num = 10;
      class Inner {
          public int num = 20;

          public void show() {
              int num = 30;
              System.out.println(?);  //num
              System.out.println(??); //this.num
              System.out.println(???);//Outer.this.num
          }
      }
  }
  class InnerClassTest {
      public static void main(String[] args) {
          Outer.Inner oi = new Outer().new Inner();
          oi.show();
      }   
  }

  //Outer.this.num;在外部类下面的成员

10.12_面向对象(局部内部类访问局部变量的问题)(掌握)

局部内部类就是在方法内部定义的类
其只能在方法内部实例化对象，然后调用其方法实现功能
A:案例演示
- 局部内部类访问局部变量必须用final修饰
- 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
  因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用【延迟生命周期】
  
  但是jdk1.8取消了这个事情【不加final也可以】,所以我认为这是个bug

10.13_面向对象(匿名内部类的格式和理解)

A:匿名内部类
- 就是内部类的简化写法。
B:前提：存在一个类或者接口
- 这里的类可以是具体类也可以是抽象类。
C:格式：

  new 类名或者接口名() {
      重写方法;
  }
  获取一个匿名对象;

D:本质是什么呢?
- 是一个继承了该类或者实现了该接口的子类匿名对象。
E:案例演示
- 按照要求来一个匿名内部类

  interface Inter {
      void show(); //public abstract
  }

  class Outer {
      private int num = 10;
  
      class Inner implements Inter {
          public void show() {
              System.out.println("show");
          }
      }
  
      public void method() {
          //普通方式调用
          Inter inn1 = new Inner();
          inn1.show();
          
          //匿名内部类方式调用
          Inter inn2 = new Inter() {
              public void show() {
                  System.out.println("noname inner class show");
              }
          };
          inn2.show();
      }
  }

10.14_面向对象(匿名内部类重写多个方法调用)

必须重写所有方法
案例演示
- 匿名内部类的方法调用

10.15_面向对象(匿名内部类在开发中的应用)

A:代码如下

  //这里写抽象类，接口都行
  abstract class Person {
      public abstract void show();
  }

  class PersonDemo {
      public void method(Person p) {
          p.show();
      }
  }

  class PersonTest {
      public static void main(String[] args) {
          //如何调用PersonDemo中的method方法呢?
          PersonDemo pd = new PersonDemo ();
      }
  }

10.16_面向对象(匿名内部类的面试题)

A:面试题

  按照要求，补齐代码
  interface Inter { 
      void show(); 
  }

  class Outer { 
      //补齐代码 
      public static Inter method() {
          return new Inter() {
              public void show() {
                  System.out.println("HelloWorld");
              }
          };
      } 
  }

  class OuterDemo {
      public static void main(String[] args) {
            Outer.method().show();
        }
  }
  要求在控制台输出”HelloWorld”

11.01_Java开发工具(常见开发工具介绍)(了解)

A:操作系统自带的记事本软件
B:高级记事本软件
C:集成开发环境 IDE
- (Integrated Development Environment)
D:Eclipse和MyEclipse的区别
- a:Eclipse是一种可扩展的开放源代码的IDE。
- b:Eclipse的特点描述
  - 免费
  - 纯Java语言编写
  - 免安装
  - 扩展性强
- c:MyEclipse
  - 在Eclipse基础上追加的功能性插件，对插件收费
  - 在WEB开发中提供强大的系统架构平台
E:下载 http://eclipse.org/
- org是非盈利团体
F:软件分类
- 绿色版解压就可以使用(Eclipse)
- 安装版双击运行,一路next即可(JDK)
G:卸载
- 绿色版直接删除文件夹即可
- 安装版专业卸载软件或者控制面板添加删除程序

11.02_Java开发工具(Eclipse中HelloWorld案例以及汉化)(了解)

A:选择工作空间
- 工作空间其实就是我们写的源代码所在的目录
B:用Eclipse来完成一个HelloWorld案例
- 代码以项目为基本单位
- 创建项目
- 创建包
- 创建类
- 编写代码
C:编译和运行
D:Eclipse的汉化
- 从Eclipse3.5开始，安装目录下就多了一个dropins目录,只要将插件解压后放到到该目录即可。
- 同理，这种方式卸载插件也是特别的方便，推荐这种方式
E:语法检查提示
- 红色波浪线
  - 必须处理,否则编译通不过
- 黄色波浪线
  - 可以不搭理他

11.03_Java开发工具(Eclipse的视窗和视图概述)(了解)

A:视窗每一个基本的窗体被称为视窗
- PackageExplorer 包资源管理器，显示项目结构，包，类，及资源
- Outline 大纲视窗，显示类的结构，方便查找，识别，修改
- Console 程序运行的结果在该窗口显示
- Hierarchy 显示Java继承层次结构，选中类后按F4显示
B:视图是由某些视窗的组合而成的
- Java视图
- JavaEE视图
- Debug视图

11.04_Java开发工具(Eclipse工作空间的基本配置)(掌握)

A:程序的编译和运行的环境配置(一般不改)
- window -- Preferences -- Java
- 编译环境：Compiler 默认选中的就是最高版本。
- 运行环境：Installed JREs 默认会找你安装的那个JDK。建议配置了Java的环境变量。
- 问题：
  - 低编译，高运行。可以。
  - 高编译，低运行。不可以。
  - 建议，编译和运行的版本一致。
B:如何去掉默认注释?
- window -- Preferences -- Java -- Code Style -- Code Templates
- 选择你不想要的内容，通过右边Edit编辑。
- 注意：请只删除注释部分，不是注释部分的不要删除。
C:行号的显示和隐藏
- 显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
- 隐藏：把上面的动作再做一次。
D:字体大小及颜色
- a:Java代码区域的字体大小和颜色：
  - window -- Preferences -- General -- Appearance -- Colors And Fonts --Java修改 -- Java Edit Text Font
- b:控制台
  - window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
- c:其他文件
  - window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
E:窗体给弄乱了，怎么办?
- window -- Perspective -- Reset Perspective
F:输出控制台找不到了，怎么办?
- Window--Show View—Console
G:取消悬浮提示
- window -- Preferences -- Java--Editor--Hovers 到右边将Combined Hover勾去掉，
- 这样代码的悬浮框就不会自动出现了。如果想看提示，将光标悬浮在代码上，按F2即可。

11.05_Java开发工具(Eclipse中内容辅助键的使用)(掌握)

A:Alt+/ 起提示作用
B:main+alt+/,syso+alt+/,给出其他提示
C:补充输出语句,选中需要输出的部分,alt+/选择最后一项即可
C:定义自己的alt + /
- windows--perference-Java-Editor-Templates--New

11.06_Java开发工具(Eclipse中快捷键的使用)(掌握)

A:新建 ctrl + n
B:导入包 ctrl+shift+o 整理包
C:注释 ctrl+/,ctrl+shift+/,ctrl+shift+\
//桌面右键图形选项 -- 快捷键 -- 禁用
D:代码上下移动选中代码alt+上/下箭头
E:查看源码选中类名(F3或者Ctrl+鼠标点击)
F:查找具体的类 ctrl + shift + t
G:在具体类java文件中查找具体方法 ctrl + o
H:给建议 ctrl+1,根据右边生成左边的数据类型,生成方法
I:删除一整行代码 ctrl + d
J:抽取方法alt + shift + m
K:改名alt + shift + r

11.07_Java开发工具(Eclipse中如何提高开发效率)(掌握)

alt + shift + s
A:自动生成构造方法
B:自动生成get/set方法

11.08_Java开发工具(Eclipse中一个标准学生类及其测试)(掌握)

A:案例演示
- 用Eclipse实现标准学生类及其测试

11.09_Java开发工具(Eclipse中接口抽象类具体类代码体现)(掌握)

A:案例演示
- 用Eclipse实现接口抽象类具体类代码
- 注意，将抽象类放在一个项目中，测试类放在另一个项目中

11.10_Java开发工具(Eclipse中如何生成jar包并导入到项目中)(了解)

A:jar是什么?
- jar是多个class文件的压缩包。
B:jar有什么用?
- 用别人写好的东西
C:打jar包
- 选中项目--右键--Export--Java--Jar--自己指定一个路径和一个名称--Finish
D:导入jar包
- 复制到项目路径下并添加至构建路径。

11.11_Java开发工具(Eclipse中如何删除项目和导入项目)(掌握)

A:删除项目
- 选中项目 – 右键 – 删除
  - 从项目区域中删除
  - 从硬盘上删除
B:导入项目
- 在项目区域右键找到import
- 找到General，展开，并找到
- Existing Projects into Workspace
- 点击next,然后选择你要导入的项目
- 注意：这里选择的是项目名称

11.12_Java开发工具(Eclipse中断点调试的基本使用)(了解)

A:Debug的作用
- 调试程序
- 查看程序执行流程
B:如何查看程序执行流程
- 什么是断点：
  - 就是一个标记，从哪里开始。
- 如何设置断点：
  - 你想看哪里的程序，你就在那个有效程序的左边双击即可。
- 在哪里设置断点：
  - 哪里不会点哪里。
  - 目前：我们就在每个方法的第一条有效语句上都加。
- 如何运行设置断点后的程序：
  - 右键 -- Debug as -- Java Application
- 看哪些地方：
  - Debug：断点测试的地方
    - 在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
  - Variables：查看程序的变量变化
  - ForDemo：被查看的源文件
  - Console：控制台
- 如何去断点：
  - a:再次双击即可
  - b:找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。

11.13_Java开发工具(Eclipse查看Java中参数传递问题)(了解)

A:断点演示
- 断点查看Java中参数传递问题

11.14_常见对象(API概述)(了解)

A:API(Application Programming Interface)
- 应用程序编程接口
B:Java API
- 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
- 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

11.15_常见对象(Object类的概述)(了解)

A:Object类概述
- 类层次结构的根类
- 所有类都直接或者间接的继承自该类
B:构造方法
- public Object()
- 回想面向对象中为什么说：
- 子类的构造方法默认访问的是父类的无参构造方法

11.16_常见对象(Object类的hashCode()方法)(了解)

A:案例演示
- public int hashCode()
- a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
- b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

11.17_常见对象(Object类的getClass()方法)(在反射的时候掌握)

A:案例演示
- public final Class getClass()
- a:返回此 Object 的运行时类。
- b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
  - public String getName()

11.18_常见对象(Object类的toString()方法)(掌握)

A:案例演示
- public String toString()
- a:返回该对象的字符串表示。
```
  public Stirng toString() {
      return name + "," + age;
  }
```
- b:它的值等于：
  - getClass().getName() + "@" + Integer.toHexString(hashCode())
- c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
B:最终版
- 自动生成

11.19_常见对象(Object类的equals()方法)(掌握)

A:案例演示
- a:指示其他某个对象是否与此对象“相等”。
- b:默认情况下比较的是对象的引用是否相同。
- c:由于比较对象的引用没有意义，一般建议重写该方法。
B: equals在Object中的源代码
public boolean equals(Object obj) {
return (this == obj);
}
比较两个对象所对应内存地址值。

11.20_常见对象(==号和equals方法的区别)(掌握)

==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

11.21_day11总结

把今天的知识点总结一遍。

12.01_常见对象(Scanner的概述和方法介绍)(掌握)

A:Scanner的概述
B:Scanner的构造方法原理
- Scanner(InputStream source)
- System类下有一个静态的字段：
  - public static final InputStream in; 标准的输入流，对应着键盘录入。
C:一般方法
- hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
- nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

12.02_常见对象(Scanner获取数据出现的小问题及解决方案)(掌握)

A:两个常用的方法：
- public int nextInt():获取一个int类型的值
- public String nextLine():获取一个String类型的值
B:案例演示
- a:先演示获取多个int值，多个String值的情况
- b:再演示先获取int值，然后获取String值出现问题
- c:问题解决方案
  - 第一种：先获取一个数值后，在创建一个新的键盘录入对象获取字符串。
  - 第二种：把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。(后面讲)

12.03_常见对象(String类的概述)(掌握)

A:String类的概述
- 通过JDK提供的API，查看String类的说明
- 可以看到这样的两句话。
  - a:字符串字面值"abc"也可以看成是一个字符串对象。 //"abc".equals(); OK
  - b:字符串是常量，一旦被赋值，就不能被改变。

12.04_常见对象(String类的构造方法)(掌握)

A:常见构造方法
- public String():空构造
- public String(byte[] bytes):把字节数组转成字符串
- public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
- public String(char[] value):把字符数组转成字符串
- public String(char[] value,int index,int count):把字符数组的一部分转成字符串
- public String(String original):把字符串常量值转成字符串
B:案例演示
- 演示String类的常见构造方法

12.05_常见对象(String类的常见面试题)(掌握)

1.判断定义为String类型的s1和s2是否相等
- String s1 = "abc";
- String s2 = "abc";
- System.out.println(s1 == s2);
- System.out.println(s1.equals(s2));
2.下面这句话在内存中创建了几个对象?
- String s1 = new String("abc");
3.判断定义为String类型的s1和s2是否相等
- String s1 = new String("abc");
- String s2 = "abc";
- System.out.println(s1 == s2); ?
- System.out.println(s1.equals(s2)); ?
4.判断定义为String类型的s1和s2是否相等
- String s1 = "a" + "b" + "c";
- String s2 = "abc";
- System.out.println(s1 == s2); ?
- System.out.println(s1.equals(s2)); ?
5.判断定义为String类型的s1和s2是否相等
- String s1 = "ab";
- String s2 = "abc";
- String s3 = s1 + "c"; //new StringBuffer --> toString
- System.out.println(s3 == s2);
- System.out.println(s3.equals(s2)); ?

12.06_常见对象(String类的判断功能)(掌握)

A:String类的判断功能
- boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
- boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
- boolean contains(String str):判断大字符串中是否包含小字符串
- boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
- boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
- boolean isEmpty():判断字符串是否为空。

12.07_常见对象(模拟用户登录)(掌握)

A:作业 LoginTest.java
- 需求：模拟登录,给三次机会,并提示还有几次。
- 用户名和密码都是admin

12.08_常见对象(String类的获取功能)(掌握)

A:String类的获取功能
- int length():获取字符串的长度。
- char charAt(int index):获取指定索引位置的字符
- int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
- int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
- int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
- int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
- lastIndexOf
- String substring(int start):从指定位置开始截取字符串,默认到末尾。
- String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。[start,end)

12.09_常见对象(字符串的遍历)(掌握)

A:案例演示
- 需求：遍历字符串

12.10_常见对象(统计不同类型字符个数)(掌握)

A:作业 CountTest.java
- 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数,其他字符出现的次数。
- ABCDEabcd123456!@#$%^ ch >= 'a' && ch <= 'z'

12.11_常见对象(String类的转换功能)(掌握)

A:String的转换功能：
- byte[] getBytes():把字符串转换为字节数组。
- char[] toCharArray():把字符串转换为字符数组。
- static String valueOf(char[] chs):把字符数组转成字符串。
- static String valueOf(int i):把int类型的数据转成字符串。
  - 注意：String类的valueOf方法可以把任意类型的数据转成字符串。
- String toLowerCase():把字符串转成小写。(了解)
- String toUpperCase():把字符串转成大写。
- String concat(String str):把字符串拼接。

12.12_常见对象(按要求转换字符)(链式编程掌握)

A:作业 TransTest.java
- 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

12.13_常见对象(把数组转成字符串)

A:作业 TransTest2.java
- 需求：把数组中的数据按照指定个格式拼接成一个字符串
  - 举例：
    - int[] arr = {1,2,4,3};
  - 输出结果：
    - "[1, 2, 4, 3]"

12.14_常见对象(String类的其他功能)

A:String的替换功能及案例演示
- String replace(char old,char new)
- String replace(String old,String new)
B:String的去除字符串两空格及案例演示
- String trim() " zhang san " --> "zhang san"
C:String的按字典顺序比较两个字符串及案例演示
- int compareTo(String str)(暂时不用掌握)
- int compareToIgnoreCase(String str)(了解)

12.15_常见对象(字符串反转)

A:作业 ReversalTest.java
- 需求：把字符串反转
  - 举例：键盘录入"abc"
  - 输出结果："cba"
  - public static String reversal(String str) {
  - //str = "hello"; --> char[] s = "";
  - //对字符数组进行反转
  - //char[] --> String s;
  - retrun s;
  - }

12.16_常见对象(在大串中查找小串出现的次数思路图解)

A:画图演示
- 需求：统计大串中小串出现的次数
- public static int count(String max,String min)
- 这里的大串和小串可以自己根据情况给出
- String max = "helloworldnihaobuhaohello";
- ```
          max = "buhaohello";   substring();
```
- ```
          max = "hello";
```
- String min = "hao";
- max.indexOf(min) ==> 子串第一次出现的index值
- int index = max.indexOf(min);
- //while((index = max.indexOf(min)) != -1) {
- while(index != -1) {
- count++;
- //截取子串 12 + 3 15
- max = max.substring(index+min.length());
- index = max.indexOf(min);
- }
- syso(count);

12.17_常见对象(在大串中查找小串出现的次数代码实现)

A:作业 CountSubTest.java
- 统计大串中小串出现的次数
- indexOf()帮助实现

13.01_常见对象(StringBuffer类的概述)

A:StringBuffer类概述 [StringBulider]
- 通过JDK提供的API，查看StringBuffer类的说明
- 线程安全的可变字符序列
B:StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列
- 多线程访问的时候银行主卡副卡同一个时刻去各自存钱1000 0+1000=1000 1000+1000=2000

13.02_常见对象(StringBuffer类的构造方法)

A:StringBuffer的构造方法：
- public StringBuffer():无参构造方法
- public StringBuffer(int capacity):指定容量的字符串缓冲区对象
- public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法：
- public int capacity()：返回当前容量。理论值(不掌握)
- public int length():返回长度（字符数）。实际值
C:案例演示
- 构造方法和长度方法的使用

13.03_常见对象(StringBuffer的添加功能)

A:StringBuffer的添加功能
- public StringBuffer append(String str):
  - 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
- public StringBuffer insert(int offset,String str):
  - 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

13.04_常见对象(StringBuffer的删除功能)

A:StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index):
  - 删除指定位置的字符，并返回本身
- public StringBuffer delete(int start,int end):
  - 删除从指定位置开始指定位置结束的内容，并返回本身

13.05_常见对象(StringBuffer的替换和反转功能)

A:StringBuffer的替换功能
- public StringBuffer replace(int start,int end,String str):
  - 从start开始到end用str替换
B:StringBuffer的反转功能
- public StringBuffer reverse():
  - 字符串反转

13.06_常见对象(StringBuffer的截取功能及注意事项)

A:StringBuffer的截取功能
- public String substring(int start):
  - 从指定位置截取到末尾
- public String substring(int start,int end):
  - 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B:注意事项
- 注意:返回值类型不再是StringBuffer本身

13.07_常见对象(StringBuffer和String的相互转换)

A:String -- StringBuffer
- a:通过构造方法
- b:通过append()方法
B:StringBuffer -- String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length);

13.08_常见对象(把数组转成字符串)

A:作业 TransArrToString.java

需求：把数组中的数据按照指定个格式拼接成一个字符串

  举例：
      int[] arr = {1,2,3};    
  输出结果：
      "[1, 2, 3]"
      
  用StringBuffer的功能实现

13.09_常见对象(字符串反转)

A:案例演示

  需求：把字符串反转
      举例：键盘录入"abc"        
      输出结果："cba"
      
  用StringBuffer的功能实现

13.10_常见对象(StringBuffer和StringBuilder的区别)

A:StringBuilder的概述
- 通过查看API了解一下StringBuilder类
B:面试题
- StringBuffer和StringBuilder的区别
  - StringBuffer是jdk1.0版本的,是线程安全的,效率低
  - StringBuilder是jdk1.5版本的,是线程不安全的,效率高
- String和StringBuffer,StringBuilder的区别
  - String是一个不可变的字符序列
  - StringBuffer,StringBuilder是可变的字符序列

13.11_常见对象(String和StringBuffer分别作为参数传递)

A:形式参数问题
- String作为参数传递传值
- StringBuffer作为参数传递传地址
B:案例演示
- String和StringBuffer分别作为参数传递问题

13.14_常见对象(数组高级选择排序原理图解)

A:画图演示
- 需求：
  - 数组元素：{24, 69, 80, 57, 13}
  - 请对数组元素进行排序。
  - 选择排序
    - 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

13.15_常见对象(数组高级选择排序代码实现)

A:案例演示
- 数组高级选择排序代码

13.16_常见对象(数组高级二分查找原理图解)

A:画图演示
- 二分查找
- 前提：数组元素有序

13.17_常见对象(数组高级二分查找代码实现及注意事项)

A:案例演示
- 数组高级二分查找代码
B:注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

13.18_常见对象(Arrays类的概述和方法使用)

A:Arrays类概述
- 针对数组进行操作的工具类。
- 提供了排序，查找等功能。
B:成员方法
- public static String toString(int[] a)
- public static void sort(int[] a)；底层快速排序
- public static int binarySearch(int[] a,int key);如果没有，返回负的插入点再减一；

13.19_常见对象(基本类型包装类的概述)

A:为什么会有基本类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
C:基本类型和包装类的对应

  byte            Byte
  short           Short
  int             Integer         //*
  long            Long
  float           Float
  double          Double
  char            Character       //*
  boolean         Boolean

13.20_常见对象(Integer类的概述和构造方法)

A:Integer类概述
- 通过JDK提供的API，查看Integer类的说明
- Integer 类在对象中包装了一个基本类型 int 的值,
- 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
- 还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
- public Integer(int value)
- public Integer(String s)
C:案例演示
- 使用构造方法创建对象

13.21_常见对象(String和int类型的相互转换)

A:int -- String
- a:和""进行拼接
- b:public static String valueOf(int i)
- c:int -- Integer -- String(Integer类的toString方法())
- d:public static String toString(int i)(Integer类的静态方法)
B:String -- int
- a:String -- Integer -- int
- public static int parseInt(String s)

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

A:JDK5的新特性
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
B:案例演示
- JDK5的新特性自动装箱和拆箱
- Integer ii = 100;
- int num = ii + 10;
- ii += 200;
C:注意事项
- 在使用时，Integer x = null;代码就会出现NullPointerException。
- 建议先判断是否为null，然后再使用。

13.23_常见对象(Integer的面试题)

A:Integer的面试题
参考Integer.valueOf()源码

  看程序写结果
  
  Integer i1 = new Integer(97);
  Integer i2 = new Integer(97);
  System.out.println(i1 == i2);
  System.out.println(i1.equals(i2));
  System.out.println("-----------");

  Integer i3 = new Integer(197);
  Integer i4 = new Integer(197);
  System.out.println(i3 == i4);
  System.out.println(i3.equals(i4));
  System.out.println("-----------");

  Integer i5 = 97;
  Integer i6 = 97;
  System.out.println(i5 == i6);
  System.out.println(i5.equals(i6));
  System.out.println("-----------");

  Integer i7 = 197;
  Integer i8 = 197;
  System.out.println(i7 == i8);
  System.out.println(i7.equals(i8));

14.01_常见对象(Math类概述和方法使用)

A:Math类概述
- Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
- public static int abs(int a) 求绝对值
- public static double ceil(double a) 向上取整
- public static double floor(double a) 向下取整
- public static int max(int a,int b) min自学
- public static double pow(double a,double b) 求a^b
- public static double random() 获取随机数
- public static int round(float a) 参数为double的自学四舍五入
- public static double sqrt(double a) 开平方

14.02_常见对象(Random类的概述和方法使用)

A:Random类的概述
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
- public Random()
- public Random(long seed)
C:成员方法
- public int nextInt()
- public int nextInt(int n)(重点掌握)

14.03_常见对象(System类的概述和方法使用)

A:System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。
B:成员方法
- public static void gc()
- public static void exit(int status)
- public static long currentTimeMillis()
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
C:案例演示
- System类的成员方法使用

14.04_常见对象(Date类的概述和方法使用)(掌握)

A:Date类的概述
- 类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
- public Date()
- public Date(long date)
C:成员方法
- public long getTime()
- public void setTime(long time)

14.05_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)

A:DateFormat类的概述
- DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
B:SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
C:成员方法
- public final String format(Date date)
- public Date parse(String source)

14.06_常见对象(你来到这个世界多少天案例)(掌握)

A:案例演示
- 需求：算一下你来到这个世界多少天?
- 当前系统时间 --> ms数 num1
- 你生日那天"1994.10.21" --> ms数 num2
- long num = num1 - num2;
- 天数 = num / 1000 / 60 / 60 / 24;

15.01_集合框架(对象数组的概述和使用)

A:案例演示
- 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。

  Student[] arr = new Student[5];                 //存储学生对象
  arr[0] = new Student("张三", 23);
  arr[1] = new Student("李四", 24);
  arr[2] = new Student("王五", 25);
  arr[3] = new Student("赵六", 26);
  arr[4] = new Student("马哥", 20);
  
  for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
  }

B:画图演示
- 把学生数组的案例画图讲解
- 数组和集合存储引用数据类型,存的都是地址值

15.02_集合框架(集合的由来及集合继承体系图)

A:集合的由来
- 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少.
B:数组和集合的区别
- 区别1 :
  - 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  - 集合只能存储引用数据类型(对象),集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
- 区别2:
  - 数组长度是固定的,不能自动增长
  - 集合的长度的是可变的,可以根据元素的增加而增长
C:数组和集合什么时候用
- 如果元素个数是固定的推荐用数组
- 如果元素个数不是固定的推荐用集合
D:集合继承体系图
- 单列集合顶层接口Collection
- 实现子类 List有序、重复 Set无序、不能重复
- ArrayList LinkedList Vector HashSet哈希算法 TreeSet二叉树算法

15.03_集合框架(Collection集合的基本功能测试)

A:案例演示

  基本功能演示
  
  boolean add(E e)
  boolean remove(Object o)
  void clear()
  boolean contains(Object o)
  boolean isEmpty()
  int size()

B:注意:

  collectionXxx.java使用了未经检查或不安全的操作.
  注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
  java编译器认为该程序存在安全隐患
  温馨提示:这不是编译失败,所以先不用理会,等学了泛型你就知道了

15.04_集合框架(集合的遍历之集合转数组遍历)

A:集合的遍历
- 其实就是依次获取集合中的每一个元素。

B:案例演示

把集合转成数组，可以实现集合的遍历
toArray()

  Collection coll = new ArrayList();
  coll.add(new Student("张三",23));     //Object obj = new Student("张三",23);
  coll.add(new Student("李四",24));
  coll.add(new Student("王五",25));
  coll.add(new Student("赵六",26));
  
  Object[] arr = coll.toArray();              //将集合转换成数组
  for (int i = 0; i < arr.length; i++) {
      Student s = (Student)arr[i];            //强转成Student
      System.out.println(s.getName() + "," + s.getAge());
  }

15.05_集合框架(Collection集合的带All功能测试)

A:案例演示

  带All的功能演示
  
  boolean addAll(Collection c)
  boolean removeAll(Collection c)
  boolean containsAll(Collection c)
  boolean retainAll(Collection c)     取交集

15.06_集合框架(集合的遍历之迭代器遍历)

A:迭代器概述
- 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)

B:案例演示

迭代器的使用

  Collection c = new ArrayList();
  c.add("a");
  c.add("b");
  c.add("c");
  c.add("d");
  
  Iterator it = c.iterator();                     //获取迭代器的引用
  while(it.hasNext()) {                           //集合中的迭代方法(遍历)
      System.out.println(it.next());
  }

15.07_集合框架(Collection存储自定义对象并遍历)

A:案例演示

Collection存储自定义对象并用迭代器遍历

  Collection c = new ArrayList();
  
  c.add(new Student("张三",23));
  c.add(new Student("李四",24));
  c.add(new Student("王五",25));
  c.add(new Student("赵六",26));
  c.add(new Student("赵六",26));
  
  for(Iterator it = c.iterator();it.hasNext();) {
      Student s = (Student)it.next();                     //向下转型
      System.out.println(s.getName() + "," + s.getAge()); //获取对象中的姓名和年龄
  }
  System.out.println("------------------------------");
  Iterator it = c.iterator();                             //获取迭代器
  while(it.hasNext()) {                                   //判断集合中是否有元素
      //System.out.println(((Student)(it.next())).getName() + "," + ((Student)(it.next())).getAge());
      Student s = (Student)it.next();                     //向下转型
      System.out.println(s.getName() + "," + s.getAge()); //获取对象中的姓名和年龄
  }

15.08_集合框架(迭代器的原理及源码解析)(了解)

A:迭代器原理
- 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
B:迭代器源码解析
- 1,在eclipse中ctrl + shift + t找到ArrayList类
- 2,ctrl+o查找iterator()方法
- 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
- 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法

15.09_集合框架(List集合的特有功能概述和测试)

A:List集合的特有功能概述
- void add(int index,E element)
- E remove(int index)
- E get(int index)
- E set(int index,E element)

15.10_集合框架(List集合存储学生对象并遍历)

A:案例演示

通过size()和get()方法结合使用遍历。

  List list = new ArrayList();
  list.add(new Student("张三", 18));
  list.add(new Student("李四", 18));
  list.add(new Student("王五", 18));
  list.add(new Student("赵六", 18));
  
  for(int i = 0; i < list.size(); i++) {
      Student s = (Student)list.get(i);
      System.out.println(s.getName() + "," + s.getAge());
  }

15.11_集合框架(并发修改异常产生的原因及解决方案)

A:案例演示

需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

  List list = new ArrayList();
  list.add("a");
  list.add("b");
  list.add("world");
  list.add("d");
  list.add("e");
  
  /*Iterator it = list.iterator();
  while(it.hasNext()) {
      String str = (String)it.next();
      if(str.equals("world")) {
          list.add("javaee");         //这里会抛出ConcurrentModificationException并发修改异常
      }
  }*/

B:ConcurrentModificationException出现
- 迭代器遍历，集合修改集合

C:解决方案

a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)

b:集合遍历元素，集合修改元素

  ListIterator lit = list.listIterator();     //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
  while(lit.hasNext()) {
      String str = (String)lit.next();
      if(str.equals("world")) {
          lit.add("javaee");  
          //list.add("javaee");
      }
  }

15.12_集合框架(ListIterator)(了解)

boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素

15.13_集合框架(Vector的特有功能)

A:Vector类概述
B:Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()

C:案例演示

Vector的迭代

  Vector v = new Vector();                //创建集合对象,List的子类
  v.addElement("a");
  v.addElement("b");
  v.addElement("c");
  v.addElement("d");
  
  //Vector迭代
  Enumeration en = v.elements();          //获取枚举
  while(en.hasMoreElements()) {           //判断集合中是否有元素
      System.out.println(en.nextElement());//获取集合中的元素
  }

15.14_集合框架(数据结构之数组和链表)

A:数组
- 查询快修改也快
- 增删慢
B:链表
- 查询慢,修改也慢
- 增删快

15.15_集合框架(List的三个子类的特点)

A:List的三个子类的特点

  ArrayList:
      底层数据结构是数组，查询快，增删慢。
      线程不安全，效率高。
  Vector:
      底层数据结构是数组，查询快，增删慢。
      线程安全，效率低。

  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)
  LinkedList:
      底层数据结构是链表，查询慢，增删快。
      线程不安全，效率高。

  Vector和ArrayList的区别
      Vector是线程安全的,效率低
      ArrayList是线程不安全的,效率高
  共同点:都是数组实现的
  ArrayList和LinkedList的区别
      ArrayList底层是数组结果,查询和修改快
      LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
  共同点:都是线程不安全的

B:List有三个儿子，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList

15.01_集合框架(对象数组的概述和使用)

A:案例演示
- 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。

  Student[] arr = new Student[5];                 //存储学生对象
  arr[0] = new Student("张三", 23);
  arr[1] = new Student("李四", 24);
  arr[2] = new Student("王五", 25);
  arr[3] = new Student("赵六", 26);
  arr[4] = new Student("马哥", 20);
  
  for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
  }

B:画图演示
- 把学生数组的案例画图讲解
- 数组和集合存储引用数据类型,存的都是地址值

15.02_集合框架(集合的由来及集合继承体系图)

A:集合的由来
- 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少.
B:数组和集合的区别
- 区别1 :
  - 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  - 集合只能存储引用数据类型(对象),集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
- 区别2:
  - 数组长度是固定的,不能自动增长
  - 集合的长度的是可变的,可以根据元素的增加而增长
C:数组和集合什么时候用
- 1,如果元素个数是固定的推荐用数组
- 2,如果元素个数不是固定的推荐用集合
D:集合继承体系图
- 单列集合顶层接口Collection
- 实现子类 List有序、重复 Set无序、不能重复
- ArrayList LinkedList Vector HashSet哈希算法 TreeSet二叉树算法

15.03_集合框架(Collection集合的基本功能测试)

A:案例演示

  基本功能演示
  
  boolean add(E e)
  boolean remove(Object o)
  void clear()
  boolean contains(Object o)
  boolean isEmpty()
  int size()

B:注意:

  collectionXxx.java使用了未经检查或不安全的操作.
  注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
  java编译器认为该程序存在安全隐患
  温馨提示:这不是编译失败,所以先不用理会,等学了泛型你就知道了

15.04_集合框架(集合的遍历之集合转数组遍历)

A:集合的遍历
- 其实就是依次获取集合中的每一个元素。

B:案例演示

把集合转成数组，可以实现集合的遍历
toArray()

  Collection coll = new ArrayList();
  coll.add(new Student("张三",23));     //Object obj = new Student("张三",23);
  coll.add(new Student("李四",24));
  coll.add(new Student("王五",25));
  coll.add(new Student("赵六",26));
  
  Object[] arr = coll.toArray();              //将集合转换成数组
  for (int i = 0; i < arr.length; i++) {
      Student s = (Student)arr[i];            //强转成Student
      System.out.println(s.getName() + "," + s.getAge());
  }

15.05_集合框架(Collection集合的带All功能测试)

A:案例演示

  带All的功能演示
  
  boolean addAll(Collection c)
  boolean removeAll(Collection c)
  boolean containsAll(Collection c)
  boolean retainAll(Collection c)     取交集，如果集合内容改变则返回true,否则返回false

15.06_集合框架(集合的遍历之迭代器遍历)

A:迭代器概述
- 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)

B:案例演示

迭代器的使用

  Collection c = new ArrayList();
  c.add("a");
  c.add("b");
  c.add("c");
  c.add("d");
  
  Iterator it = c.iterator();                     //获取迭代器的引用
  while(it.hasNext()) {                           //集合中的迭代方法(遍历)
      System.out.println(it.next());
  }

15.07_集合框架(Collection存储自定义对象并遍历)

A:案例演示

Collection存储自定义对象并用迭代器遍历

  Collection c = new ArrayList();
  
  c.add(new Student("张三",23));
  c.add(new Student("李四",24));
  c.add(new Student("王五",25));
  c.add(new Student("赵六",26));
  c.add(new Student("赵六",26));
  
  for(Iterator it = c.iterator();it.hasNext();) {
      Student s = (Student)it.next();                     //向下转型
      System.out.println(s.getName() + "," + s.getAge()); //获取对象中的姓名和年龄
  }
  System.out.println("------------------------------");
  Iterator it = c.iterator();                             //获取迭代器
  while(it.hasNext()) {                                   //判断集合中是否有元素
      //System.out.println(((Student)(it.next())).getName() + "," + ((Student)(it.next())).getAge());
      Student s = (Student)it.next();                     //向下转型
      System.out.println(s.getName() + "," + s.getAge()); //获取对象中的姓名和年龄
  }

15.08_集合框架(迭代器的原理及源码解析)(了解)

A:迭代器原理
- 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
B:迭代器源码解析
- 1,在eclipse中ctrl + shift + t找到ArrayList类
- 2,ctrl+o查找iterator()方法
- 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
- 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法

15.09_集合框架(List集合的特有功能概述和测试)

A:List集合的特有功能概述
- void add(int index,E element)
- E remove(int index)
- E get(int index)
- E set(int index,E element)

15.10_集合框架(List集合存储学生对象并遍历)

A:案例演示

通过size()和get()方法结合使用遍历。

  List list = new ArrayList();
  list.add(new Student("张三", 18));
  list.add(new Student("李四", 18));
  list.add(new Student("王五", 18));
  list.add(new Student("赵六", 18));
  
  for(int i = 0; i < list.size(); i++) {
      Student s = (Student)list.get(i);
      System.out.println(s.getName() + "," + s.getAge());
  }

15.11_集合框架(并发修改异常产生的原因及解决方案)

A:案例演示

需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

  List list = new ArrayList();
  list.add("a");
  list.add("b");
  list.add("world");
  list.add("d");
  list.add("e");
  
  /*Iterator it = list.iterator();
  while(it.hasNext()) {
      String str = (String)it.next();
      if(str.equals("world")) {
          list.add("javaee");         //这里会抛出ConcurrentModificationException并发修改异常
      }
  }*/

B:ConcurrentModificationException出现
- 迭代器遍历，集合名修改集合内部值

C:解决方案

a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)

b:集合遍历元素，集合修改元素

  ListIterator lit = list.listIterator();     //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
  while(lit.hasNext()) {
      String str = (String)lit.next();
      if(str.equals("world")) {
          lit.add("javaee");  
          //list.add("javaee");
      }
  }

15.12_集合框架(ListIterator)(了解)

boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素

15.13_集合框架(Vector的特有功能)

A:Vector类概述
B:Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()

C:案例演示

Vector的迭代

  Vector v = new Vector();                //创建集合对象,List的子类
  v.addElement("a");
  v.addElement("b");
  v.addElement("c");
  v.addElement("d");
  
  //Vector迭代
  Enumeration en = v.elements();          //获取枚举
  while(en.hasMoreElements()) {           //判断集合中是否有元素
      System.out.println(en.nextElement());//获取集合中的元素
  }

15.14_集合框架(数据结构之数组和链表)

A:数组
- 查询快修改也快
- 增删慢
B:链表
- 查询慢,修改也慢
- 增删快

15.15_集合框架(List的三个子类的特点)

A:List的三个子类的特点

  ArrayList:
      底层数据结构是数组，查询快，增删慢。
      线程不安全，效率高。
  Vector:
      底层数据结构是数组，查询快，增删慢。
      线程安全，效率低。

  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)
  LinkedList:
      底层数据结构是链表，查询慢，增删快。
      线程不安全，效率高。

  Vector和ArrayList的区别
      Vector是线程安全的,效率低
      ArrayList是线程不安全的,效率高
  共同点:都是数组实现的
  ArrayList和LinkedList的区别
      ArrayList底层是数组结果,查询和修改快
      LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
  共同点:都是线程不安全的

B:List有三个儿子，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList

16.01_集合框架(去除ArrayList中重复字符串元素方式)(掌握)

A:案例演示

需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

思路：创建新集合方式

  /**
   *  A:案例演示
   * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
   * 思路：创建新集合方式
   */
  public static void main(String[] args) {
      ArrayList list = new ArrayList();
      list.add("a");
      list.add("a");
      list.add("b");
      list.add("b");
      list.add("b");
      list.add("c");
      list.add("c");
      list.add("c");
      list.add("c");
      
      System.out.println(list);
      ArrayList newList = getSingle(list);
      System.out.println(newList);
  }

  /*
   * 去除重复
   * 1,返回ArrayList
   * 2,参数列表ArrayList
   */
  public static ArrayList getSingle(ArrayList list) {
      ArrayList newList = new ArrayList();            //创建一个新集合
      Iterator it = list.iterator();                  //获取迭代器
      while(it.hasNext()) {                           //判断老集合中是否有元素
          String temp = (String)it.next();            //将每一个元素临时记录住
          if(!newList.contains(temp)) {               //如果新集合中不包含该元素
              newList.add(temp);                      //将该元素添加到新集合中
          }
      }
      return newList;                                 //将新集合返回
  }

16.02_集合框架(去除ArrayList中重复自定义对象元素)(掌握)

A:案例演示
- 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
- 重写equals()方法的

16.03_集合框架(LinkedList的特有功能)(掌握)

A:LinkedList类概述
B:LinkedList类特有功能
- public void addFirst(E e)及addLast(E e)
- public E getFirst()及getLast()
- public E removeFirst()及public E removeLast()
- public E get(int index);
C: 利用特有方法添加成员到集合中，然后遍历；然后再删除头尾，再次遍历。

16.04_集合框架(栈和队列数据结构)(掌握)

栈
- 先进后出
队列
- 先进先出

16.05_集合框架(用LinkedList模拟栈数据结构的集合并测试)(掌握)

A:案例演示

需求：请用LinkedList模拟栈数据结构的集合，并测试
创建一个类将Linked中的方法封装

  public class Stack {
      private LinkedList list = new LinkedList();     //创建LinkedList对象
      
      public void in(Object obj) {
          list.addLast(obj);                          //封装addLast()方法
      }
      
      public Object out() {
          return list.removeLast();                   //封装removeLast()方法
      }
      
      public boolean isEmpty() {
          return list.isEmpty();                      //封装isEmpty()方法
      }
  }

16.06_集合框架(泛型概述和基本使用)(掌握)

A:泛型概述
- 不确定的类型什么都可以的意思。
B:泛型好处
- 提高安全性【将运行期的错误转换到编译期】
- 省去强转的麻烦
C:泛型基本使用
- <>中放的必须是引用数据类型
D:泛型使用注意事项
- 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
- 泛型类的使用固定格式
- 泛型类<确定类型1,确定类型2,...> 对象名 = new 泛型类<>();

16.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)(掌握)

A:案例演示
- ArrayList存储字符串并遍历泛型版

16.08_集合框架(泛型的由来)(了解)

A:案例演示
- 泛型的由来:通过Object转型问题引入
- 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

16.09_集合框架(泛型类的概述及使用)(了解)

A:泛型类概述<T>
- 把泛型定义在类上
B:定义格式
- public class 类名<泛型类型1,…>
C:注意事项
- 泛型类型必须是引用类型
D:案例演示
- 泛型类的使用

16.10_集合框架(泛型方法的概述和使用)(了解)

A:泛型方法概述
- 把泛型定义在方法上
B:定义格式
- public<泛型类型> 返回类型方法名(泛型类型变量名)
- 最好与类泛型一致
C:案例演示
- 泛型方法的使用
D:静态方法中，必须声明自己的泛型
- 静态方法不依赖对象,而类泛型只有在创建对象时传递类型值。

16.11_集合框架(泛型接口的概述和使用)(了解)

A:泛型接口概述
- 把泛型定义在接口上
B:定义格式
- public interface 接口名<泛型类型>
- a. 实现类中确定类型
- b. class Demo<T> implements 接口<T> { ... }
C:案例演示
- 泛型接口的使用

16.12_集合框架(泛型高级之通配符)(了解)

A:泛型通配符<?>
- 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E
- 向下限定，E及其子类
- addAll(Collection<? extends E>);
C:? super E
- 向上限定，E及其父类

16.13_集合框架(增强for的概述和使用)(掌握)

A:增强for概述
- 简化数组和Collection集合的遍历
- 底层是通过迭代器实现的。
B:格式：

  for(元素数据类型 变量 : 数组或者Collection集合) {
      使用变量即可，该变量就是元素
  }

C:案例演示
- 数组，集合存储元素用增强for遍历
D:好处
- 简化遍历

16.14_集合框架(ArrayList存储字符串和自定义对象并遍历增强for版)(掌握)

A:案例演示

ArrayList存储字符串并遍历增强for版

  ArrayList<String> list = new ArrayList<>();
  list.add("a");
  list.add("b");
  list.add("c");
  list.add("d");
  
  for(String s : list) {
      System.out.println(s);
  }

底层借助迭代器实现.

16.15_集合框架(三种迭代的能否删除)(掌握)

普通for循环,可以删除,但是【索引要--】
迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
增强for循环不能删除【底层通过迭代器实现，不能删除】

16.16_集合框架(静态导入的概述和使用)(掌握)

A:静态导入概述
B:格式：
- import static 包名….类名.static方法;
- import static 包名...类名.static成员;
- 可以直接导入到方法的级别
C:注意事项
- 方法必须是静态的,如果有同名的方法，就不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

16.17_集合框架(可变参数的概述和使用)(掌握)

A:可变参数概述
- 定义方法的时候不知道该定义多少个参数
B:格式
- 修饰符返回值类型方法名(数据类型… 变量名){}
C:注意事项：
- 这里可变参数其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
- outArray(int len,int... arr); ok
- outArray(int... arr,int len); error

16.18_集合框架(Arrays工具类的asList()方法的使用)(掌握)

A:案例演示
- Arrays工具类的asList()方法的使用
- 将数组转换成集合
- 注意：转换成集合后，不可以增加或减少元素，但可以用集合思想操作数据。
- ```
 如果操作标准数据类型数组，则将数组当成一个元素添加到数组中。
```
- Collection中toArray(T[] a)泛型版的集合转数组
- 例如 list.toArray(new String[n]); n值不同，转换得到的数组不同

16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)

A:案例演示
- 集合嵌套之ArrayList嵌套ArrayList
- 专业中包含多个班级，每个班级包含多个学生

17.01_集合框架(HashSet存储字符串并遍历)

A:Set集合概述及特点
- 通过API查看即可

B:案例演示

HashSet存储字符串并遍历

  HashSet<String> hs = new HashSet<>();
  boolean b1 = hs.add("a");
  boolean b2 = hs.add("a");           //当存储不成功的时候,返回false
  
  System.out.println(b1);
  System.out.println(b2);
  for(String s : hs) {
      System.out.println(s);
  }

17.02_集合框架(HashSet存储自定义对象保证元素唯一性)

A:案例演示

存储自定义对象，并保证元素唯一性。

  HashSet<Person> hs = new HashSet<>();
  hs.add(new Person("张三", 23));
  hs.add(new Person("张三", 23));
  hs.add(new Person("李四", 23));
  hs.add(new Person("李四", 23));
  hs.add(new Person("王五", 23));
  hs.add(new Person("赵六", 23));

重写hashCode()和equals()方法

17.03_集合框架(HashSet存储自定义对象保证元素唯一性图解及代码优化)

A:画图演示
- 画图说明比较过程
B:代码优化
- 为了减少比较，优化hashCode()代码写法。
- 最终版就是自动生成即可。

17.04_集合框架(HashSet如何保证元素唯一性的原理)

1.HashSet原理
- 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
- 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
  - 如果没有哈希值相同的对象就直接存入集合
  - 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
2.将自定义类的对象存入HashSet去重复
- 类中必须重写hashCode()和equals()方法
- hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
- equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

17.05_集合框架(LinkedHashSet的概述和使用)

A:LinkedHashSet的特点
B:案例演示
- LinkedHashSet的特点
  - 可以保证怎么存就怎么取

17.06_集合框架(产生10个1-20之间的随机数要求随机数不能重复)

A:案例演示

需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。

  HashSet<Integer> hs = new HashSet<>();      //创建集合对象
  Random r = new Random();                    //创建随机数对象
  
  while(hs.size() < 10) {
      int num = r.nextInt(20) + 1;            //生成1到20的随机数
      hs.add(num);
  }
  
  for (Integer integer : hs) {                //遍历集合
      System.out.println(integer);            //打印每一个元素
  }

17.07_集合框架(练习)

使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符

aaaabbbcccddd

  Scanner sc = new Scanner(System.in);            //创建键盘录入对象
  System.out.println("请输入一行字符串:");
  String line = sc.nextLine();                    //将键盘录入的字符串存储在line中
  char[] arr = line.toCharArray();                //将字符串转换成字符数组
  HashSet<Character> hs = new HashSet<>();        //创建HashSet集合对象
  
  for(char c : arr) {                             //遍历字符数组
      hs.add(c);                                  //将字符数组中的字符添加到集合中
  }
  
  for (Character ch : hs) {                       //遍历集合
      System.out.println(ch);
  }

17.08_集合框架(练习)

将ArrayList集合中的重复元素去掉

      public static void main(String[] args) {
          ArrayList<String> list = new ArrayList<>();
          list.add("a");
          list.add("a");
          list.add("a");
          list.add("b");
          list.add("b");
          list.add("b");
          list.add("b");
          list.add("c");
          list.add("c");
          list.add("c");
          list.add("c");
          
          System.out.println(list);
          System.out.println("去除重复后:");
          getSingle(list);
          System.out.println(list);
      }
      
      /*
       * 将集合中的重复元素去掉
       * 1,void
       * 2,List<String> list
       */
      
      public static void getSingle(List<String> list) {
          LinkedHashSet<String> lhs = new LinkedHashSet<>();
          lhs.addAll(list);                                   //将list集合中的所有元素添加到lhs
          list.clear();                                       //清空原集合
          list.addAll(lhs);                                   //将去除重复的元素添回到list中
      }

17.09_集合框架(TreeSet存储Integer类型的元素并遍历)

A:案例演示
- TreeSet存储Integer类型的元素并遍历

17.10_集合框架(TreeSet存储自定义对象)

A:案例演示
- 存储Person对象

17.11_集合框架(TreeSet保证元素唯一和自然排序的原理和图解)

A:画图演示
- TreeSet保证元素唯一和自然排序的原理和图解

17.12_集合框架(TreeSet存储自定义对象并遍历练习1)

A:案例演示
- TreeSet存储自定义对象并遍历练习1(按照姓名排序)

17.13_集合框架(TreeSet存储自定义对象并遍历练习2)

A:案例演示
- TreeSet存储自定义对象并遍历练习2(按照姓名的长度排序)
- compareTo(Person p) {
- int num = name.length() - p.name.length();
- return num;
- }

17.14_集合框架(TreeSet保证元素唯一和比较器排序的原理及代码实现)

A:案例演示
- TreeSet保证元素唯一和比较器排序的原理及代码实现

17.15_集合框架(TreeSet原理)

1.特点
- TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
2.使用方式
- a.自然顺序(Comparable)
  - TreeSet类的add()方法中会把存入的对象提升为Comparable类型
  - 调用对象的compareTo()方法和集合中的对象比较
  - 根据compareTo()方法返回的结果进行存储
- b.比较器顺序(Comparator)
  - 创建TreeSet的时候可以制定一个Comparator
  - 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
  - add()方法内部会自动调用Comparator接口中compare()方法排序
  - 调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
- c.两种方式的区别
  - TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
  - TreeSet如果传入Comparator, 就优先按照Comparator

17.16_集合框架(练习)

在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复

      public static void main(String[] args) {
          ArrayList<String> list = new ArrayList<>();
          list.add("ccc");
          list.add("ccc");
          list.add("aaa");
          list.add("aaa");
          list.add("bbb");
          list.add("ddd");
          list.add("ddd");
          
          sort(list);
          System.out.println(list);
      }
      
      /*
       * 对集合中的元素排序,并保留重复
       * 1,void
       * 2,List<String> list
       */
      public static void sort(List<String> list) {
          TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {       //定义比较器(new Comparator(){}是Comparator的子类对象)
  
              @Override
              public int compare(String s1, String s2) {                      //重写compare方法
                  int num = s1.compareTo(s2);                                 //比较内容
                  return num == 0 ? 1 : num;                                  //如果内容一样返回一个不为0的数字即可
              }
          });
          
          ts.addAll(list);                                                    //将list集合中的所有元素添加到ts中
          list.clear();                                                       //清空list
          list.addAll(ts);                                                    //将ts中排序并保留重复的结果在添加到list中
      }

17.17_集合框架(练习)

从键盘接收一个字符串, 程序对其中所有字符进行排序,例如键盘输入: helloitcast程序打印:acehillostt

  Scanner sc = new Scanner(System.in);            //创建键盘录入对象
  System.out.println("请输入一行字符串:");
  String line = sc.nextLine();                    //将键盘录入的字符串存储在line中
  char[] arr = line.toCharArray();                //将字符串转换成字符数组
  TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {

      @Override
      public int compare(Character c1, Character c2) {
          //int num = c1.compareTo(c2);
          int num = c1 - c2;                  //自动拆箱
          return num == 0 ? 1 : num;
      }
  });
  
  for(char c : arr) {
      ts.add(c);
  }
  
  for(Character ch : ts) {
      System.out.print(ch);
  }

17.18_集合框架(练习)

程序1：程序启动后, 可以从键盘输入接收多个整数, 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.

      Scanner sc = new Scanner(System.in);        //创建键盘录入对象
      System.out.println("请输入: ");
      TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {//将比较器传给TreeSet的构造方法

          @Override
          public int compare(Integer i1, Integer i2) {
              //int num = i2 - i1;                    //自动拆箱
              int num = i2.compareTo(i1);
              return num == 0 ? 1 : num;
          }
      });
      
      while(true) {
          String line = sc.nextLine();            //将键盘录入的字符串存储在line中
          if("quit".equals(line))                 //如果字符串常量和变量比较,常量放前面,这样不会出现空指针异常,变量里面可能存储null
              break;
          try {
              int num = Integer.parseInt(line);       //将数字字符串转换成数字
              ts.add(num);
          } catch (Exception e) {
              System.out.println("您录入的数据有误,请输入一个整数");
          }
          
      }
      
      for (Integer i : ts) {                      //遍历TreeSet集合
          System.out.println(i);
      }

17.19_集合框架(键盘录入学生信息按照总分排序后输出在控制台)

A:案例演示

需求：键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。

  Scanner sc = new Scanner(System.in);
  System.out.println("请输入5个学生成绩格式是:(姓名,语文成绩,数学成绩,英语成绩)");
  TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
      @Override
      public int compare(Student s1, Student s2) {
          int num = s2.getSum() - s1.getSum();            //根据学生的总成绩降序排列
          return num == 0 ? 1 : num;
      }
  });
  
  while(ts.size() < 5) {
      String line = sc.nextLine();
      try {
          String[] arr = line.split(",");
          int chinese = Integer.parseInt(arr[1]);             //转换语文成绩
          int math = Integer.parseInt(arr[2]);                //转换数学成绩
          int english = Integer.parseInt(arr[3]);             //转换英语成绩
          ts.add(new Student(arr[0], chinese, math, english));
      } catch (Exception e) {
          System.out.println("录入格式有误,输入5个学生成绩格式是:(姓名,语文成绩,数学成绩,英语成绩");
      }
  }
  
  System.out.println("排序后的学生成绩是:");
  for (Student s : ts) {
      System.out.println(s);
  }

17.20_day17总结

1.List
- a.普通for循环, 使用get()逐个获取
- b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
- c.增强for循环, 只要可以使用Iterator的类都可以用
- d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法
2.Set
- a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
- b.增强for循环, 只要可以使用Iterator的类都可以用
3.普通for循环,迭代器,增强for循环是否可以在遍历的过程中删除

18.01_集合框架(Map集合概述和特点)

A:Map接口概述
- 查看API可以知道：
  - 将键映射到值的对象
  - 一个映射不能包含重复的键
  - 每个键最多只能映射到一个值
B:Map接口和Collection接口的不同
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set是唯一的
- Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

18.02_集合框架(Map集合的功能概述)

A:Map集合的功能概述
- a:添加功能
  - V put(K key,V value):添加元素。
    - 如果键是第一次存储，就直接存储元素，返回null
    - 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
- b:删除功能
  - void clear():移除所有的键值对元素
  - V remove(Object key)：根据键删除键值对元素，并把值返回
- c:判断功能
  - boolean containsKey(Object key)：判断集合是否包含指定的键
  - boolean containsValue(Object value):判断集合是否包含指定的值
  - boolean isEmpty()：判断集合是否为空
- d:获取功能
  - Set<Map.Entry<K,V>> entrySet():获取集合中所有的键值对
  - V get(Object key):根据键获取值
  - Set<K> keySet():获取集合中所有键的集合
  - Collection<V> values():获取集合中所有值的集合
- e:长度功能
  - int size()：返回集合中的键值对的个数

18.03_集合框架(Map集合的遍历之键找值)

A:键找值思路：
- 获取所有键的集合
- 遍历键的集合，获取到每一个键
- 根据键找值

B:案例演示

Map集合的遍历之键找值

  HashMap<String, Integer> hm = new HashMap<>();
  hm.put("张三", 23);
  hm.put("李四", 24);
  hm.put("王五", 25);
  hm.put("赵六", 26);
  
  /*Set<String> keySet = hm.keySet();         //获取集合中所有的键
  Iterator<String> it = keySet.iterator();    //获取迭代器
  while(it.hasNext()) {                       //判断单列集合中是否有元素
      String key = it.next();                 //获取集合中的每一个元素,其实就是双列集合中的键
      Integer value = hm.get(key);            //根据键获取值
      System.out.println(key + "=" + value);  //打印键值对
  }*/
  
  for(String key : hm.keySet()) {             //增强for循环迭代双列集合第一种方式
      System.out.println(key + "=" + hm.get(key));
  }

18.04_集合框架(Map集合的遍历之键值对对象找键和值)

A:键值对对象找键和值思路：
- 获取所有键值对对象的集合
- 遍历键值对对象的集合，获取到每一个键值对对象
- 根据键值对对象找键和值

B:案例演示

Map集合的遍历之键值对对象找键和值

  HashMap<String, Integer> hm = new HashMap<>();
  hm.put("张三", 23);
  hm.put("李四", 24);
  hm.put("王五", 25);
  hm.put("赵六", 26);
  /*Set<Map.Entry<String, Integer>> entrySet = hm.entrySet(); //获取所有的键值对象的集合
  Iterator<Entry<String, Integer>> it = entrySet.iterator();//获取迭代器
  while(it.hasNext()) {
      Entry<String, Integer> en = it.next();              //获取键值对对象
      String key = en.getKey();                               //根据键值对对象获取键
      Integer value = en.getValue();                          //根据键值对对象获取值
      System.out.println(key + "=" + value);
  }*/
  
  for(Entry<String,Integer> en : hm.entrySet()) {
      System.out.println(en.getKey() + "=" + en.getValue());
  }

C:源码分析

注意: Map.Entry<K,V> 表示Map接口内部存在Entry接口。

18.05_集合框架(HashMap集合键是Student值是String的案例)

HashMap中的key如果是自定义类型，则需要重写hashCode与equals方法
A:案例演示
- HashMap集合键是Student值是String的案例

18.06_集合框架(LinkedHashMap的概述和使用)

底层实现类似LinkedHashSet
A:案例演示 LinkedHashMapTest.java
- LinkedHashMap的特点
  - 底层是链表实现的可以保证怎么存就怎么取

18.07_集合框架(TreeMap集合键是Student值是String的案例)

A:案例演示 TreeMapTest.java
- TreeMap集合键是Student值是String的案例

18.08_集合框架(统计字符串中每个字符出现的次数)

A:案例演示

需求：统计字符串中每个字符出现的次数
String str = "aaaabbbcccccccccc";
char[] arr = str.toCharArray(); //将字符串转换成字符数组
HashMap<Character, Integer> hm = new HashMap<>(); //创建双列集合存储键和值

  for(char c : arr) {                                 //遍历字符数组
      /*if(!hm.containsKey(c)) {                      //如果不包含这个键
          hm.put(c, 1);                               //就将键和值为1添加
      }else {                                         //如果包含这个键
          hm.put(c, hm.get(c) + 1);                   //就将键和值再加1添加进来
      }
      
      //hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
      Integer i = !hm.containsKey(c) ? hm.put(c, 1) : hm.put(c, hm.get(c) + 1);
              }
  
  for (Character key : hm.keySet()) {                 //遍历双列集合
      System.out.println(key + "=" + hm.get(key));
  }

18.09_集合框架(集合嵌套之HashMap嵌套HashMap)

A:案例演示
- 集合嵌套之HashMap嵌套HashMap
- 一个专业可以包含多个班级
- java1班里面包含3个学生 HashMap<String,Student> javaClass1;
- java2班也包含 3个学生 HashMap<String,Student> javaClass2;
- 软件开发专业包含java1 java2班 HashMap<"Java1班",javaClass1> RJKAMap;

18.10_集合框架(HashMap和Hashtable的区别)

A:面试题
- HashMap和Hashtable的区别
  - Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
  - Hashtable不可以存储null键和null值,HashMap可以存储null键和null值
B:案例演示
- HashMap和Hashtable的区别

18.11_集合框架(Collections工具类的概述和常见方法讲解)

A:Collections类概述
- 针对集合操作的工具类
B:Collections成员方法

  public static <T> void sort(List<T> list)
  public static <T> int binarySearch(List<?> list,T key)
  public static <T> T max(Collection<?> coll)
  public static void reverse(List<?> list)
  public static void shuffle(List<?> list)

18.12_集合框架(模拟斗地主洗牌和发牌)

A:案例演示

使用ArrayList集合模拟斗地主洗牌和发牌，牌没有排序

  //买一副扑克
  String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
  String[] color = {"方片","梅花","红桃","黑桃"};
  ArrayList<String> poker = new ArrayList<>();
  
  for(String s1 : color) {
      for(String s2 : num) {
          poker.add(s1.concat(s2));
      }
  }
  
  poker.add("小王");
  poker.add("大王");
  //洗牌
  Collections.shuffle(poker);
  //发牌
  ArrayList<String> gaojin = new ArrayList<>();
  ArrayList<String> longwu = new ArrayList<>();
  ArrayList<String> me = new ArrayList<>();
  ArrayList<String> dipai = new ArrayList<>();
  
  for(int i = 0; i < poker.size(); i++) {
      if(i >= poker.size() - 3) {
          dipai.add(poker.get(i));
      }else if(i % 3 == 0) {
          gaojin.add(poker.get(i));
      }else if(i % 3 == 1) {
          longwu.add(poker.get(i));
      }else {
          me.add(poker.get(i));
      }
  }
  
  //看牌
  
  System.out.println(gaojin);
  System.out.println(longwu);
  System.out.println(me);
  System.out.println(dipai);

18.13_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的原理图解)

A:画图演示
- 画图说明排序原理

18.14_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的代码实现)

A:案例演示
- 模拟斗地主洗牌和发牌并对牌进行排序的代码实现

      //买一副牌
      String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
      String[] color = {"方片","梅花","红桃","黑桃"};
      HashMap<Integer, String> hm = new HashMap<>();          //存储索引和扑克牌
      ArrayList<Integer> list = new ArrayList<>();            //存储索引
      int index = 0;                                          //索引的开始值
      for(String s1 : num) {
          for(String s2 : color) {
              hm.put(index, s2.concat(s1));                   //将索引和扑克牌添加到HashMap中
              list.add(index);                                //将索引添加到ArrayList集合中
              index++;
          }
      }
      hm.put(index, "小王");
      list.add(index);
      index++;
      hm.put(index, "大王");
      list.add(index);
      //洗牌
      Collections.shuffle(list);
      //发牌
      TreeSet<Integer> gaojin = new TreeSet<>();
      TreeSet<Integer> longwu = new TreeSet<>();
      TreeSet<Integer> me = new TreeSet<>();
      TreeSet<Integer> dipai = new TreeSet<>();
      
      for(int i = 0; i < list.size(); i++) {
          if(i >= list.size() - 3) {
              dipai.add(list.get(i));                         //将list集合中的索引添加到TreeSet集合中会自动排序
          }else if(i % 3 == 0) {
              gaojin.add(list.get(i));
          }else if(i % 3 == 1) {
              longwu.add(list.get(i));
          }else {
              me.add(list.get(i));
          }
      }
      
      //看牌
      lookPoker("高进", gaojin, hm);
      lookPoker("龙五", longwu, hm);
      lookPoker("冯佳", me, hm);
      lookPoker("底牌", dipai, hm);
      
  }
  
  public static void lookPoker(String name,TreeSet<Integer> ts,HashMap<Integer, String> hm) {
      System.out.print(name + "的牌是:");
      for (Integer index : ts) {
          System.out.print(hm.get(index) + " ");
      }
      
      System.out.println();
  }

18.15_集合框架(泛型固定下边界)

? super E 拿出来到比较器中做比较, TreeMap(Comparator<? super K> comparator);
? extends E 放进去，放入父类对象集合, boolean addAll(Collection<? extends E> c);

18.16_day18总结

把今天的知识点总结一遍。
泛型
1.要会使用泛型 class ArrayList<E> ...
List<Student> list = new ArrayList<>();
2.如果定义泛型类泛型方法泛型接口
固定格式套路
多做练习
集合
单列集合Collection根接口
一些方法
List接口
新增一些和 index 有关的方法
ArrayList Vector LinkedList[头部尾部添加删除]

Set不可重复无序
HashSet
自定义类往 HashSet中添加，必须重写 hashCode equals
TreeSet
自定义类往 TreeSet中添加，必须指定比较器
1.实现Comparable接口
2.实例化一个Comparator类对象

Map<key,value>
HashMap
自定义类作为Key 往 HashMap中添加,必须重写 hashCode equals
TreeMap
自定义类作为Key 往 TreeMap中添加,必须指定比较器