本帖最后由 小石姐姐 于 2019-5-9 18:36 编辑
22岁少年程序猿半夜惊醒竟然
开始写帖子
继承的概念理解
继承是面向对象三大特征之一。 可以使得子类具有父类的属性和方法，还可以在子类中重新定义， 以及追加属性和方法 通过extends关键字实现继承 格式： class 子类 extends 父类 { }
继承带来的好处
继承可以让类与类之间产生关系，子父类关系 产生子父类后，子类则可以使用父类中非私有的成员。
继承好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景：
使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
在子类方法中访问一个变量，采用的是就近原则。
子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)
this关键字：
this：代表本类对象的引用
super关键字：
super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
成员变量：
this.成员变量 - 访问本类成员变量
super.成员变量 - 访问父类成员变量
成员方法：
this.成员方法 - 访问本类成员方法
super.成员方法 - 访问父类成员方法
构造方法：
this(…) - 访问本类构造方法
super(…) - 访问父类构造方法
包的概念
包就是文件夹，用来管理类文件的
包的定义格式
package 包名; (多级包用.分开)
例如：package com.heima.demo;
带包编译&带包运行
带包编译：javac –d . 类名.java
例如：javac -d . com.heima.demo.HelloWorld.java
带包运行：java 包名+类名
例如：java com.heima.demo.HelloWorld
导包的意义
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能
导包的格式
格式：import 包名;
范例：import java.util.Scanner;
fianl关键字的作用
final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
final修饰方法：该方法不能被重写
final修饰变量：表明该变量是一个常量，不能再次赋值
fianl修饰基本数据类型变量
final 修饰指的是基本类型的数据值不能发生改变
final修饰引用数据类型变量
final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
举例：
[AppleScript] 纯文本查看 复制代码 final Student s = new Student(23);
s = new Student(24); // 错误
s.setAge(24); // 正确
static的概念
static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
static修饰的特点
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
当然，也可以通过对象名调用
推荐使用类名调用
static的访问特点
非静态的成员方法
能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法
静态的成员方法
能访问静态的成员变量
能访问静态的成员方法
什么是继承 让类与类之间产生了子父类关系
继承的好处是 提高代码的复用性和维护性
java中继承的特点是 只支持单继承、不支持多继承，但是可以多层继承
四种权限修饰符是 public protected 默认 private
final关键字的特点是 修饰类：类不能被继承 修饰方法：方法不能被重写 修饰变量：变量就变成了常量
static修饰的成员访问方式是 直接通过类名点访问
--------------------------------------------------------------------------------------------------------------
什么是多态
同一个对象，在不同时刻表现出来的不同形态
多态的前提条件有哪些
要有继承/实现关系
要有方法重写
要有父类引用指向子类对象
多态中成员变量的访问特点是什么
编译看左边、运行看左边
多态中成员方法的访问特点是什么
编译看左边、运行看右边
多态的好处
提高了代码的扩展性。
定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象
多态的弊端
不能使用子类特有的成员
多态中的向上转型
父类引用指向子类对象其实就是向上转型。例如：
Animal a = new Dog();
多态中的向下转型
将父类型的引用转换成具体的子类对象。转换格式：
子类 对象名 = (子类)父类引用;
猫狗案例多态版重要步骤
1.定义Animal类，提供name和age成员变量。eat方法
2.定义Cat类，继承Animal类，重写eat方法
3.定义Dog类，继承Animal类，重写eat方法
4.通过多态创建对象，并给属性赋值，调用方法
什么是抽象类
一个类中如果有抽象方法，那么这个类就必须是一个抽象类
什么是抽象方法
抽象方法指的是没有具体的方法实现
如何定义抽象类和抽象方法
使用abstract关键字来修饰类和方法 抽象类中的成员特点 1.成员变量 既可以是变量、也可以是常量 2.构造方法 有构造方法，目的是给父类中成员初始化 3.成员方法 既可以是抽象方法、也可以是普通方法
猫狗案例抽象类版重点步骤 1.定义动物类Animal 成员变量：name age 构造方法：无参、带参 成员方法：get/set方法、抽象eat() 2.定义猫类Cat，继承Animal 构造方法：无参、带参 成员方法：重写eat()方法 3.定义狗类Dog，继承Animal 构造方法：无参、带参 成员方法：重写eat()方法 4.定义测试类，创建猫狗对象并赋值。调用方法
什么是接口
接口就是一种公共的规范标准，只要符合规范标准，都可以使用
java中的接口更多的体现在对行为的抽象
接口的特点
1.如何定义接口
public interface 接口名{}
2.如何实现接口
public class 类名 implements 接口名{}
3.接口不能被实例化，可以通过多态形式创建实现类对象
4.接口的实现类
要么重写接口中所有的抽象方法
要么实现类定义为抽象类
接口的成员特点
1.成员变量
只能是常量，默认修饰符为：public static final
2.构造方法
接口中没有构造方法
3.成员方法
接口中可以有抽象方法，默认修饰符为：public abstract
JDK8以后可以有静态方法(后面学)
JDK9以后可以有默认方法(后面学)
接口版猫狗案例主要步骤
1.定义接口Jumping，提供抽象方法跳高jump
2.定义动物类Animal
成员变量：name age
构造方法、get和set方法
抽象eat方法
3.定义猫类Cat，继承Animal，实现Jumping
重写两个抽象方法
4.定义狗类Dog，继承Animal，实现Jumping
重写两个抽象方法
5.定义测试类，完成代码测试
类和类之间的关系
继承关系，可以单继承，不能多继承，但是可以多层继承
类和接口之间的关系
实现关系，可以单实现，也可以多实现
还可以继承一个类的同时，再实现多个接口
接口和接口之间的关系
继承关系，可以单继承、也可以多继承
抽象类和接口的区别
1.成员区别
抽象类：变量、常量、构造方法、普通方法、抽象方法
接口：常量、抽象方法
2.关系区别
类和类：继承关系，单继承
类和接口：实现关系，单实现、多实现
接口和接口：继承关系，单继承、多继承
3.设计理念区别
抽象类：完成的是一些共性功能的抽取
接口：完成的是一些特性功能的抽取
--------------------------------------------------------------------------------------------------------------
类名作为方法的形参 方法的形参是类名，其实需要的是该类的对象 实际传递的是该对象的【地址值】
类名作为方法的返回值 方法的返回值是类名，其实返回的是该类的对象 实际传递的，也是该对象的【地址值】
抽象类作为形参和返回值 方法的形参是抽象类名，其实需要的是该抽象类的子类对象 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
接口作为形参和返回值 方法的形参是接口名，其实需要的是该接口的实现类对象 方法的返回值是接口名，其实返回的是该接口的实现类对象
内部类概念
在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
内部类定义格式
格式： 举例：
class 外部类名 { class Outer {
修饰符 class 内部类名{ public class Inner {
} }
} }
内部类的访问特点
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
成员内部类的定义位置
在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
举例：Outer.Inner oi = new Outer().new Inner();
成员内部类的推荐使用方案
将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
局部内部类定义位置
局部内部类是在方法中定义的类
局部内部类方式方式
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量
匿名内部类的前提
存在一个类或者接口，这里的类可以是具体类也可以是抽象类
匿名内部类的格式
格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
举例： new Inter(){
@Override
public void method(){}
}
匿名内部类的本质
本质：是一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节
匿名内部类可以通过多态的形式接受
[AppleScript] 纯文本查看 复制代码 Inter i = new Inter(){
@Override
public void method(){}
}
冒泡排序概述
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与
类名作为方法参数传递传递的是 对象的内存地址值
类名作为方法的返回值返回的是 对象的内存地址值
成员内部类创建对象的格式是 内部类名.外部类名 对象名 = 外部类对象.内部类对象
Arrays工具类常用方法有 sort() toString()
基本数据类型所对应的包装类 byte Byte short Short int Integer long Long float Float double Double char Character Boolean Boolean
Integer的构造方法创建对象
Integer(int num)
Integer(String num)
Integer的静态方法valueOf()获取对象
valueOf(int num)
valueOf(String num)
int类型如何转为String类型
第一种方式：直接在int类型数据后面加一个空字符串
第二种方式：通过String的静态方法valueOf()
String类型如何转为int类型
第一种方式：先将String转为Integer类型，再通过valueOf()方法转为int
第二种方式：通过Integer静态方法parseInt()
字符串数据排序的重要步骤
1.定义一个字符串：”91 27 46 38 50”
2.使用String类的split()方法进行切割
3.通过Integer的parseInt()方法进行转换
4.通过Arrays的sort()方法对数组进行排序
自动拆装箱
拆箱：将包装类转为基本数据类型
装箱：将基本数据类型转为包装类
自动拆装箱是JDK1.5新特性，可以实现基本数据类型与对应的包装类之间无缝使用！
Date类概述
Date代表了一个特定的时间类，精确到毫秒值
Date类构造方法
Date() 以当前系统时间创建对象
Date(long l) 以指定毫秒值时间创建对象
Date类常用方法
getTime() 获取时间毫秒值
setTime(long l) 根据传入的毫秒值设置时间
SimpleDateFormat类常用构造方法
SimpleDateFormat() 根据默认模板格式创建日期格式化对象
SimpleDateFormat(String m) 根据指定模板格式创建日期格式化对象
常用的日期模板格式
“yyyy年MM月dd日 HH:mm:ss”
将日期对象格式化成字符串
String format(Date d) 将日期对象格式化成字符串
将字符串日期解析成Date对象
Date parse(String s) 将字符串日期解析成Date对象Calendar日历类概述 表示特定瞬间与一组日历字段之间的转换提供了一些方法 并且也为操作日历字段提供了一些常用方法 Calendar获取对象的方式 Calendar c = Calendar.getInstance(); Calendar获取日历字段的方法 get() Calendar类的常用方法
get(int filed) 获取指定字段的日历信息
add(int filed,int count) 将指定日历字段进行增加或减少
set(int year,int month,int date) 修改为指定日历字段
获取任意年份的2月有多少天重要步骤
1.键盘输入任意年份
2.设置日历对象的年月日
年：来自键盘录入
月：设置为3月，月份从0开始，所以设置的值是2
日：设置为1日
3. 3月1日向前推一天，就是2月的最后一天
4. 获取这一天输出即可
Java虚拟机对异常的默认处理方式
把异常的名称、原因、位置等信息输出在控制台
结束程序的运行
try…catch处理方式标准格式
try{
可能会出现异常的代码
}catch(异常类型 对象名) {
处理方式
}
Throwable常用方法
getMessage() 获取异常的简短消息
toString() 获取异常的详细消息
printStackTrace() 获取异常的完整消息
编译时异常和运行时异常的区别
编译时异常：都是Exception类及其子类。写代码时必须处理，否则无法运行
运行时异常：都是RuntimeException类及其子类。写代码时不需要处理
Throws抛出方式处理异常
有些时候我们不想使用try-catch或没有权限使用try-catch方式处理异常时
还可以选择throws抛出的方式，格式为：
在方法声明上：throws 异常类名
自定义异常的编写步骤
1.定义一个类，继承Exception或者RuntimeException类
2.该类中提供空参构造方法和带字符串参数的构造方法即可
Throws和throw的区别
throws写在方法声明后，跟的是异常类名，表示抛出此异常，由调用者处理
throw写在方法内，跟的是异常对象
包装类有哪些
Byte Short Integer Long Float Double Character Boolean
将Date格式化成字符串的方法是 format()
将字符串解析成Date的方法是 parse()
处理异常的两种方式是 try-catch方式和throws方式
--------------------------------------------------------------------------------------------------------------Collection集合的概述 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection元素 JDK不提供此接口的直接实现类，它提供更具体的子接口(Set和List) Collection集合的基本使用 通过多态形式创建对象：Collection<String> c = new ArrayList()
Collection集合的常用方法 boolean add(E e) 向集合中添加元素 boolean remove(E e) 将元素从集合中删除 void clear() 清空集合所有的元素 boolean contains(E e) 判断集合中是否包含指定的元素 boolean isEmpty() 判断集合是否为空 int size() 获取集合的长度
遍历Collection集合的重要步骤
1.通过集合对象获取迭代器对象
2.使用循环和hasNext()方法来控制是否还有元素
3.循环内通过next()方法获取元素
Collection集合存储学生对象并遍历的重要步骤
1.定义一个学生类，包含姓名和年龄两个属性
2.创建Collection集合对象，泛型为学生对象类型
3.创建几个学生对象，并存储到集合中
4.通过迭代器遍历集合
List集合的概述和特点
1.List集合是单列集合体系之一
2.List集合及其实现类全部有索引
3.List集合及其实现类全部可以存储重复元素
4.List集合及其实现类全部元素存取有序
List集合特有的方法
void add(int index,E e) 向集合中指定索引位置添加元素
E remove(int index) 删除指定索引处的元素并返回
E set(int index,E e) 修改指定索引处的元素，返回被修改的元素
E get(int index) 获取指定索引处的元素
List集合存储学生对象并遍历重要步骤
1.定义学生类，包含姓名和年龄两个属性
2.创建List集合对象，泛型为学生对象类型
3.创建几个学生对象，并存入集合中
4.使用迭代器和for循环两种方式遍历集合
并发修改异常出现的原因
在迭代器遍历集合过程中，通过集合的自身方法对集合进行了操作。
导致了迭代器预期次数和实际次数不一致，就会出现并发修改异常
并发修改异常解决的方式
可以使用普通for循环来遍历集合，再对集合进行修改
List集合特有的迭代器
1.通过集合对象的listiterator()方法获取一个ListIterator迭代器对象
2.通过调用hasNext()方法判断是否有下一个元素
3.通过调用next()方法获取元素
4.可以通过ListIterator迭代器中的方法对集合进行操作
增强for循环定义格式
for(元素数据类型 变量名 : 数组/集合对象) {
循环体;
}
List集合存储学生对象三种遍历方式重要步骤
1.定义一个学生类，包含姓名和年龄两个属性
2.创建一个List集合对象，泛型为学生对象类型
3.创建三个学生对象，并添加到集合中
4.使用迭代器遍历集合
5.使用普通for循环遍历集合
6.使用增强for循环遍历集合
栈结构
数据先进后出模型
队列结构
数据先进先出模型
数组结构
特点：查询快、增删慢
链表结构
特点：查询慢、增删快
List集合实现类的特点
ArrayList集合：底层是数组实现，查询快、增删慢
LinkedList集合：底层是链表实现，查询慢、增删快
ArrayList集合存储学生对象三种方式遍历重点步骤
1.定义一个学生类，包含姓名和年龄两个属性
2.创建一个ArrayList集合对象，泛型为学生对象类型
3.创建三个学生对象，并添加到集合中
4.使用迭代器遍历集合
5.使用普通for循环遍历集合
6.使用增强for循环遍历集合
LinkedList集合的特有功能
void addFirst(E e) 向集合中第一个位置添加元素
void addLast(E e) 向集合中最后一个位置添加元素
E getFirst() 获取集合中第一个元素
E getLast() 获取集合中最后一个元素
E removeFirst() 删除集合中第一个元素
E removeLast() 删除集合中最后一个元素
Collection常用方法有哪些 add() remove() clear() contains() isEmpty() size()
List集合的特点是 有索引、元素可以重复、元素存取有序
List集合特有方法有哪些 add(int index,E e) remove(int index) set(int index,E e) get(int index)
ArrayList集合的特点是 底层是数组实现，查询快、增删慢
LinkedList集合的特点是 底层是链表实现，查询慢、增删快
--------------------------------------------------------------------------------------------------------------
Set集合的特点
1.元素存取无序
2.没有索引
3.不能存储重复元素
什么是哈希值
是JDK根据对象的地址或字符串或数字计算出来的一串int类型的数值
如何获取哈希值
Object类中有一个方法：hashCode()用于获取哈希值
HashSet集合的特点
1.底层是哈希表结构
2.元素存取无序
3.没有索引
4.不能存储重复元素
HashSet集合保证元素唯一性的原理
1.根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
2.当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
3.通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素
HashSet集合存储学生对象并遍历的重要步骤
1.定义一个学生类
包含姓名和年龄两个属性
并重写hashCode()和equals()方法
2.创建HashSet集合对象，泛型为学生对象类型
3.创建几个学生对象，并存储到集合中
4.通过增强for循环遍历集合
LinkedHashSet集合的概述和特点
1.LinkedHashSet集合是HashSet集合的子类
2.LinkedHashSet集合不能存储重复元素
3.LinkedHashSet集合可以保证元素存取有序
TreeSet集合的特点
1.元素有序。元素可以按照一定规则进行排序。具体要取决于构造方法
TreeSet()：根据元素的自然顺序进行排序
TreeSet(Comparator c)：根据指定的比较器进行排序
2.TreeSet集合没有索引。只能通过迭代器、增强for循环进行遍历
3.TreeSet集合不能存储重复元素
使用自然排序Comparable的重要步骤
1.定义学生类
包含姓名和年龄两个属性
实现Comparable接口，重写compareTo()方法
主要条件：年龄升序
次要条件：姓名字母顺序
2.创建TreeSet集合对象，泛型为学生对象类型
3.创建几个学生对象，并存入集合中
4.使用增强for循环遍历集合
使用比较器接口Comparator排序的重要步骤
1.定义学生类，包含姓名和年龄两个属性
2.创建TreeSet集合对象，泛型为学生对象类型
3.在TreeSet集合构造方法中，使用匿名内部类方式传递Comparator接口，重写compare()方法。主要排序条件：年龄升序，次要排序条件：姓名字母顺序
4.创建几个学生对象，并添加到集合中
5.使用增强for循环遍历集合
成绩排序案例的主要步骤
1.定义一个学生类，包含姓名、语文成绩、数学成绩三个变量
提供一个获取总成绩的方法
2.创建TreeSet集合对象，泛型为学生对象类型
3.在TreeSet构造方法中，使用匿名内部类传递Comparator接口，重写compare()方法。主要条件：总分降序，次要条件：语文成绩和姓名
4.创建几个学生对象，并添加到集合中
5.通过增强for循环遍历集合
不重复随机数案例的主要步骤
1.创建一个TreeSet集合对象，泛型为Integer类型
2.创建Random对象，用于生成随机数
3.使用while循环判断集合长度是否不等于10
如果长度不为10，则生成随机数保存到集合中
4.使用增强for循环遍历集合
什么是泛型
泛型指的是广泛的数据类型，就是将原来具体的类型参数化，在使用的时候再传入具体的类型！
泛型的好处
将运行时期的错误提前到了编译期间
省去了类型转换的麻烦
泛型类的定义
[AppleScript] 纯文本查看 复制代码 public class Generic<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
[AppleScript] 纯文本查看 复制代码 Generic<String> g1 = new Generic<String>();
g1.setT("林青霞");
System.out.println(g1.getT());
Generic<Integer> g2 = new Generic<Integer>();
g2.setT(30);
System.out.println(g2.getT());
[AppleScript] 纯文本查看 复制代码 public class Generic {
public <T> void show(T t) {
System.out.println(t);
}
}
泛型方法的使用
[AppleScript] 纯文本查看 复制代码 Generic g = new Generic();
g.show("林青霞");
g.show(30);
g.show(true);
g.show(12.34);
[AppleScript] 纯文本查看 复制代码 public interface Generic<T> {
void show(T t);
}
public class GenericImpl<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
[AppleScript] 纯文本查看 复制代码 Generic<String> g1 = new GenericImpl<String>();
g1.show("林青霞");
Generic<Integer> g2 = new GenericImpl<Integer>();
g2.show(30);
类型通配符向上限定<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型
类型通配符向下限定<? super 类型>
List<? super Number>：它表示的类型是Number或者其父类型
什么是可变参数
可变参数又称为参数个数可变，用于方法的形式参数使用。
可变参数的注意事项
可变参数其实是一个数组
如果一个方法有多个参数，而且包含可变参数。可变参数要放在最后
JDK中提供的类使用可变参数的方法
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) ：返回一个包含任意数量元素的不可变集合
Set集合的特点有哪些 无索引、元素不能重复、元素存取无序
HashSet集合保证元素唯一依赖哪两个方法 hashCode()和equals()方法
LinkedHashSet集合的特点是 保证元素存取顺序
自然排序使用的接口和方法是 Comparable接口中的compareTo()方法
比较器排序使用的接口和方法是 Comparator接口中的compare()方法
--------------------------------------------------------------------------------------------------------------
Map集合的特点
1.键值对映射关系
2.一个键对应一个值
3.键不能重复
4.元素存取无序
Map集合的常用方法
V put(K k,V v) 向集合中添加一对元素
V remove(K k) 根据键删除键值对元素
void clear() 清空集合
boolean containsKey(K k) 判断集合中是否包含指定的键
boolean containsValue(V v) 判断集合中是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 获取集合的长度
Map集合常用的获取方法
V get(K k) 根据键获取值
Set<K> keyset() 获取所有的键，保存到Set集合中
Collection<V> values() 获取所有的值，保存到Collection集合中
Set<Map.Entry<K,V>> entrySet() 获取所有键值对，封装成Entry对象
Map集合的第一种遍历方式重点步骤
1.通过keySet()方法获取所有键的集合
2.遍历键的集合，拿到每一个键
3.通过get()方法，通过键获取值
Map集合的第二种遍历方式重点步骤
1.获取所有键值对对象的集合，使用entrySet()实现
2.遍历键值对对象集合，拿到每一个键值对对象
3.调用键值对对象中的getKey()和getValue()方法获取键和值
HashMap集合练习之键是String类型值是Student类型的重要步骤
1.定义一个学生类，包含姓名和年龄两个属性
2.创建HashMap集合对象，泛型为<String,Student>
3.创建几个学生对象，并将学号和学生对象存储到集合中
4.通过两种方式遍历集合
HashMap集合练习之键是Student类型值是String类型的重要步骤
1.定义一个学生类
包含姓名和年龄两个属性
并重写hashCode()和equals()两个方法
2.创建HashMap集合对象，泛型为<Student,String>
3.创建几个学生对象，并将学生对象和居住地存储到集合中
4.遍历集合
ArrayList集合嵌套HashMap集合的主要步骤
1.创建一个ArrayList集合对象，泛型为HashMap<String,String>
2.创建三个HashMap集合，泛型都为String类型
3.向这三个HashMap集合中添加一些数据
4.将这三个HashMap集合添加到ArrayList集合中
5.遍历ArrayList集合，拿到HashMap集合，再遍历HashMap集合
HashMap集合嵌套ArrayList集合的主要步骤
1.创建一个HashMap集合，泛型为<String,ArrayList<String>>
2.创建三个ArrayList集合对象，并存储一些元素
3.将键和三个ArrayList集合对象添加到HashMap集合中
4.遍历HashMap集合，获取键和ArrayList集合，再遍历ArrayList集合
统计字符串中每个字符出现的次数的重要步骤
1.键盘录入一个字符串数据
2.创建一个HashMap集合，键Character，值Integer类型
3.遍历字符串，得到每一个字符。
4.将字符作为集合的键去找值。看其返回的结果
如果为null，则将字符作为键，值为1存入
如果不为null，则将字符作为键，值+1存储
5.遍历集合，按照指定格式输出结果
Collections集合工具类常用方法
void sort() 对集合元素排序
void reverse() 对集合元素反转
void shuffle() 对集合元素随机置换
ArrayList集合存储学生并排序的主要步骤
1.定义一个学生类，包含姓名和年龄两个属性
2.创建ArrayList集合对象，泛型为学生对象类型
3.创建几个学生对象，并添加到集合中
4.使用Collections工具类中的sort()方法进行排序
5.遍历集合，输出结果
模拟斗地主案例的主要步骤
1.定义一个数组，用于保存牌的花色
2.定义一个数组，用于保存牌的数字
3.创建ArrayList集合对象，将花色和数字进行拼接后添加到集合中
4.调用Collections工具类中的shuffle()方法洗牌
5.创建三个玩家集合一个底牌集合，进行发牌动作
6.遍历玩家和底牌的集合，查看内容
斗地主案例升级版案例的主要步骤
1.创建HashMap集合，键为编号，值为牌
2.创建ArrayList集合，存储编号
3.创建花色和点数的数组
4.将编号和花色存储到map集合中，将编号单独存储list集合中
5.使用Collections中的shuffle()方法将list集合进行随机置换
6.创建玩家和底牌的TreeSet集合，并进行发牌
7.遍历集合，查看内容
Map集合的特点有哪些 1.键值对映射关系 2.一个键对应一个值 3.键不能重复 4.元素存取无序
Map集合的常用方法有哪些 put() remove() clear() containsKey() containsValue() isEmpty() size()
Map集合的常用获取方法有哪些 get() keySet() values() entrySet()
Map集合的两种遍历方式是 keySet方式和entrySet方式
Collections工具类常用方法有哪些 sort() reverse() shuffle()
♪(^∇^*)
| 
收藏
淘帖
踩
