[TOC]
复习
11.14晨考题
1.final可以修饰哪些内容？有什么特征？
成员变量
成员变量要求在执行之前必须初始化，赋值之后无法修改，一般用于带有名称的常量
初始化方式
1. 定义时直接初始化赋值操作
2. 利用构造方法在实例化对象过程中，对 final 修饰成员变量进行赋值操作
成员方法
不能被重写，子类有且只能使用父类方法
类
不能被继承，Java 中的 String 类就是一个 final 修饰类
局部变量
一旦被赋值无法修改
【注意】
final 修饰引用数据类型
1. 指向不可变
2. 指向数据空间内容可变
2.abstract 修饰方法有什么要求和特征？
1. abstract 修饰的方法没有方法体
2. abstract 修饰的方法有且只能定义在 abstract 修饰类内或者 interface 接口内
3. 一个非 abstract 类，继承 abstract 类或者遵从 interface 接口，要求必须实现所有 abstract 方法
4. abstract 修饰的类不能实例化对象
3.static关键字修饰方法有什么特征？
1. 建议使用类名调用，不建议使用类对象调用
2. static 修饰的静态成员方法不可以直接使用类内的其他非静态成员(非静态成员变量和非静态成员方法)
3. static 修饰的静态成员方法可以直接使用类内的其他静态成员(静态成员变量和静态成员方法)
4. static 修饰的静态成员方法可以称之为类方法
5. static 修饰的静态成员方法一般用于工具类封装
4.接口中成员变量和成员方法的缺省属性是什么？如果需要在接口中实现有方法体方法用什么关键字？
成员变量缺省属性
public static final 要求定义时必须初始化
成员方法缺省属性
public abstract 没有方法体，有且只有方法声明
default 修饰的默认方法，可以有方法体
5.JavaBean规范有什么要求？
1. 要求所有成员变量全部私有化
2. 要求必须提供无参数构造方法，其他有参数构造方法按需提供
3. 要求给予所有私有化成员变量提供 Setter and Getter 方法
6.ArrayList集合扩容方法流程？
1. 确定最小容量要求， 有效元素个数 + 本次添加操作元素个数【参数 int minCapacity】
2. 得到原数组容量 oldCapacity
3. 计算得到新数组容量 newCapacity = oldCapacity + (oldCapacity >> 1); 新容量大约是原容量的 1.5
4. 判断新容量是否满足最小容量要求
5. 判断新容量是否超出最大容量要求 MAX_ARRAY_SIZE
6. 根据新容量创建新数组
7. 移动数据到新数组
8. 保存新数组地址
Map 双边队列，文件操作以及匿名内部类
1. Map 双边队列
1.1 Map概述和键值对模型思想
键值对模型：
Key=Value 模式
Key ==> 数据说明，名称说明，可以分析类型声明
Value ==> 值，数据类型
例如：
name=张三&age=16&gender=男
{
name: 张三
age: 16
gender: 男
}，
{
name: 张三
age: 25
gender: 男
}
<person>
<name>张三</name>
<age>16</age>
<gender>男</gender>
</person>
Map 是 Java 中针对于键值对模型数据类型
interface Map<K,V>
Java 中双边队列，键值对数据存储模型类型的规范接口,要求 Map 数据结构中，Key 不可以重复，Value 可以重复
--| class HashMap<K, V>
底层结构为哈希表结构，根据 Key 对应数据来计算当前键值对模型应该存储到哈希表的哪一个单元格位置
--| class TreeMap<K, V>
底层结构为树形结构，要求 Key 对应的数据必须有自然顺序或者可比较的方式。
【重点】
1. 常用 Map 为 HashMap
2. Key 常用数据类型为 String 类型，强调名称，名词
后期使用最多的是
Map<String, Object>
1.2 Map 常用操作方法
增
put(K k， V v);
根据实例化 Map 双边队列对象过程中，泛型约束对应 Key 和 Value 数据类型，添加键值对数据。
putAll(Map<? extends K, ? extends V> map);
添加参数 Map 到当前调用方法 Map 双边队列中，要求参数 Map 数据存储类型和调用方法 Map 存储类型一致，或者其子类
删
V remove(Object key);
根据指定 Key 删除 Map 存储键值对数据，返回值是 Key 对应 Value
boolean remove(Object key, Object value);
根据指定的 Key 和 Value 删除在 Map 中存储的键值对数据，要求键值同时匹配
改
put(K k, V v);
如果 Map 中存在对应 Key，使用参数 value 替换原本的 value
查
int size();
Map 双边队列有效键值对个数
boolean isEmpty();
Map 双边队列是否为空，键值对个数是否为 0
boolean containsKey(Object key);
判断指定 Key 是否在 Map 双边队列中存在
boolean containsValue(Object value);
判断指定 Value 是否在 Map 双边队列中存在
Collection<V> values();
得到 Map 双边队列中所有值对应的 Collection 集合 【注意】 value 可以重复
Set<K> keySet();
得到 Map 双边队列中所有键对应的 Set 集合 【注意】 Key 不可以重复
1.3 方法演示
package com.qfedu.a_map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map 双边队列方法演示
*/
public class Demo1 {
public static void main(String[] args) {
/*
* 利用 Map 双边队列接口实现类 HashMap 演示方法
*/
Map<String, Integer> map1 = new HashMap<String, Integer>();
// 添加键值对数据
map1.put("羊肉串", 4);
map1.put("烤韭菜", 12);
map1.put("烤茄子", 12);
map1.put("烤辣椒", 12);
map1.put("烤鱼", 35);
map1.put("考板筋", 3);
System.out.println(map1);
Map<String, Integer> map2 = new HashMap<String, Integer>();
map2.put("羊肉灌汤包", 15);
map2.put("烤羊排", 50);
map2.put("青岛啤酒", 8);
map2.put("原浆啤酒", 10);
map2.put("烤羊腿", 168);
// 添加另一个 Map 双边队列
map1.putAll(map2);
System.out.println(map1);
//键存在，修改对应值
map1.put("羊肉串", 5);
System.out.println(map1);
Integer value = map1.remove("青岛啤酒");
System.out.println(value);
System.out.println(map1);
boolean ret = map1.remove("烤韭菜", 15);
System.out.println(ret);
System.out.println(map1);
ret = map1.remove("烤韭菜", 12);
System.out.println(ret);
System.out.println(map1);
System.out.println(map1.size());
System.out.println(map1.isEmpty());
map2.clear();
System.out.println(map2.isEmpty());
System.out.println("containsKey: " + map1.containsKey("烤韭菜"));
System.out.println("containsKey: " + map1.containsKey("羊肉串"));
System.out.println("containsValue: " + map1.containsValue(10));
System.out.println("containsValue: " + map1.containsValue(5));
System.out.println();
Set<String> keySet = map1.keySet();
keySet.forEach(System.out::println);
System.out.println();
Collection<Integer> values = map1.values();
values.forEach(System.out::println);
}
}1.4 entrySet 方法
Map 双边队列存储的数据为【键值对模型】，键和值都无法单独存在。Map 中包含一个类型 Entry 类型，是【键值对类型】
简单实现一个伪代码
// K, V 是延续 Map 类型的 K, V
class Entry<K, V> {
K k;
V v;
K getKey();
V getValue();
}
例如：
Map<String, Integer> map = {考板筋=3, 烤鱼=35, 烤茄子=15}
Entry entry1 ==> 考板筋=3
K k ==> String K => "考板筋";
V v ==> Integer v => 3;
Entry entry2 ==> 烤鱼=35
K k ==> String K => "烤鱼";
V v ==> Integer v => 35;
Entry entry3 ==> 烤茄子=15
K k ==> String K => "烤茄子";
V v ==> Integer v => 15;
特征方法：
Set<Map.Entry<K, V>> entrySet():
Set<E> 对外类型为 Set 集合
E ==> Map.Entry Map 双边队列，Entry 是键值对类型 Map 中的 Entry。双边队列的键值对模型类型
Entry<K, V> 泛型对应的是 Map 实例化过程中对应的类型。 K ==> 键 V ==> 值
返回值 Map 中所有 键值对模型 Entry 对象 Set 集合
package com.qfedu.a_map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo2 {
public static void main(String[] args) {
/*
* 增强 for 循环
*
* 格式：
* for(集合/数组存储数据类型 遍历操作使用的临时变量：集合/数组) {
* 针对于元素的操作
* }
*/
int[] arr = {1, 3, 4, 5, 7, 9};
// fore Alt + /
for (int i : arr) {
System.out.println(i);
}
/*
* 利用 Map 双边队列接口实现类 HashMap 演示方法
*/
Map<String, Integer> map1 = new HashMap<String, Integer>();
// 添加键值对数据
map1.put("羊肉串", 4);
map1.put("烤韭菜", 12);
map1.put("烤茄子", 12);
map1.put("烤辣椒", 12);
map1.put("烤鱼", 35);
map1.put("烤板筋", 3);
//
Set<Map.Entry<String, Integer>> entrySet = map1.entrySet();
for (Map.Entry<String, Integer> entry : entrySet) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}2. 文件操作
2.1 File 类概述
文件操作有且只用于文件或者文件夹操作，可以涉及到文件或者文件夹的创建，修改，数据获取，判断属性，不涉及到任何的文件内容。
相对路径：
隔壁办公室，隔壁老王
以当前文件为参照，去往其他文件或者文件夹的捷径
· 当前工作目录
·· 当前工作目录的上级目录
【开发中】 相对路径都是基于 · or ·· 开头
绝对路劲：
郑州市二七区航海中路 60 号还为科技园
对于 Windows 操作系统电脑，绝对路径是基于 盘符根目录
C:/aaa/1.txt C:/aaa/3.txt
对于 Linux UNIX macOS 操作系统电脑中，绝对路径是基于 / 跟目录完成
File 类
Java 提供给程序员操作文件或者文件夹的一个相关类
涉及到的构造方法：
File(String filePath);
根据给予的文件路径 or 文件夹路径，创建一个 File 对象
FIle(String parent, String child);
根据给予的父目录文件夹路径和子文件或者子文件夹的名称，创建一个 File
File(File parent, String child);
根据给予的父目录 File 对象和子文件或者子文件夹的名称，创建一个 File 对象
补充说明：
文件分隔符：
Linux UNIX macOS 以 / 为路径分隔符 /斜杠 \反斜杠
Windows 默认以 \ 为路径分隔符， 但是支持 /
URL: 网址资源路径分隔符 /
www.baidu.com/search
一般情况下使用 /package com.qfedu.b_file;
import java.io.File;
/*
* File 类构造方法演示
*/
public class Demo1 {
public static void main(String[] args) {
File file1 = new File("Z:/aaa/1.txt");
File file2 = new File("Z:/aaa", "1.txt");
File parent = new File("Z:/aaa");
File file3 = new File(parent,"1.txt");
System.out.println(file1);
System.out.println(file2);
System.out.println(file3);
}
}2.2 创建相关
boolean createNewFile();
通过 File 类对象调用，创建 File 类对象存储路径对应的普通文件。
失败原因：
1. 路径不合法
2. 指定文件夹没有写入权限
3. File 类对象存储路径对应文件夹已经存在
boolean mkdir();
通过 File 类对象调用， 创建 File 类对象存储路径对应的普通文件
失败原因：
1. 路径不合法
2. 指定文件夹没有写入权限
3. File 类对象存储路径对应文件夹已经存在
boolean mkdirs();
通过 File 类对象调用，创建 File 类对象存储路径对应的普通文件，但是可以创建中间路径
【有个性，有基调，有能力】
boolean renameTo(File dest);
调用方法的 File 对象对应文件或者文件夹转换到参数 File 对象对应的路径中。
可以用于重命名，移动操作package com.qfedu.b_file;
import java.io.File;
import java.io.IOException;
/*
File 创建相关方法演示
*/
public class Demo2 {
public static void main(String[] args) throw IOException {
File file = new File("G:/aaa/1.txt");
boolean ret = file.createNewFile();
System.out.println(ret);
File dir = new File("G:/aaa/bbb");
ret = dir.mkdir();
System.out.println(ret);
File dir2 = new File("G:/aaa/d/f/e/w/q/da/e/tr/f/s/fsd/gg//gd/hg/h");
ret = dir2.mkdirs();
System.out.println(ret);
File file2 = new File("G:/aaa/2.txt");
File file3 = new File("G:/aaa/bbb/菊花残.txt");
file2.renameTo(file3);
}
}2.3 删除操作
boolean delete();
通过 File 类对象调用，直接删除 File 对象对应的文件或者文件夹，要求文件夹不能有内容。
【慎用】 当前删除不是放入回收站，是直接抹掉数据。
void deleteOnExit();
通过 File 类对象调用，在程序退出之后，删除 File 对象对应的文件或者文件夹，可以用于清理缓存文件，缓冲文件夹.....
package com.qfedu.b_file;
import java.io.File;
/*
删除操作
*/
public class Demo3
public static void main(String[] args) throws InterruptedException {
File parent = new File("G:/aaa");
boolean ret = new File(parent, "3.txt").delete();
System.out.println(ret);
ret = new File(parent, "c").delete();
System.out.println(ret);
System.out.println("________________");
new File(parent, "d").deletenOnExit();
new File(parent, "5.txt").deleteOnExit();
Thread.sleep(3000);
System.out.println("程序退出中...");
Thread.sleep(1000);
}
}2.4判断相关
boolean isFile();
通过 File 类对象调用，判断是否为普通文件
boolean isDiretory();
通过 File 类对象调用，判断是否为文件夹
boolean exist();
通过 File 类对象调用，判断 File 类对象对应文件或者文件夹是否存在
boolean isAbsolute();
通过 File 类对象调用，判断是否使用绝对路径
boolean isHidden();
通过 File 类对象调用，判断文件或者文件节哀是否为隐藏文件package com.qfedu.b_file;
import java.io.File;
/*
判断方法
*/
public class Demo4 {
public static void main(String[] args) {
File file = new File(".");
System.out.println("isFile : " + file.isFile());
System.out.prinln("isDirectory : "
+ file.isDirectory());
System.out.println("excits : " + file.excits());
System.out.println("isAbsolute : " + file.isAbsolute());
System.out.println("isHidden : " + file.isHidden());
}
}2.5 获取相关
与文件是否存在无关，仅为字符串解析方法
String getPath();
获取 File 类对象存储路径信息
String getParent();
获取 File 类对象存储路径信息的父目录
String getName();
获取 File 类对象存储路径信息的文件或者文件夹名
与文件存在有一定的相关性
long length();
通过 File 类对象调用，获取文件大小，如果是文件夹，返回值为 0
long lastModified();
通过 File 类对象调用，获取文件或者文件夹的最后修改时间
String getAbsolutePath();
获取指定文件或者文件夹的绝对路径
File getAbsoluteFile();
获取指定文件或者文件夹的绝对路径对应 File 对象package com.qfedu.b_file;
import java.io.File;
import java.sql.Date;
import java.text.SimpleDateFormat;
/*
* File 类 获取相关
*/
public class Demo5 {
public static void main(String[] args) {
File file = new File("X:/zzz/aa/1.txt");
String path = file.getPath();
String parent = file.getParent();
String name = file.getName();
System.out.println(path);
System.out.println(parent);
System.out.println(name);
System.out.println();
String str = "X:/zzz/aa/1.txt";
String parent2 = str.substring(0, str.lastIndexOf('/'));
System.out.println(parent2);
String name2 = str.substring(str.lastIndexOf('/') + 1);
System.out.println();
File file2 = new File("D:/aaa/1.txt");
System.out.println("length: " + file2.length());
/*
* 时间戳
* 从 1970 年 1 月 1 日 00:00:00到指定时间的秒
*/
long lastModified = file2.lastModified();
System.out.println("lastModified: " + lastModified);
// 时间标准转换格式类
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
System.out.println("lasModified: " + simpleDateFormat.format(new Date(lastModified)));
File file3 = new File(".");
System.out.println(file3.getAbsolutePath());
File file4 = file3.getAbsoluteFile();
System.out.println(file4);
}
}2.6 文件列表方法
public static File[] listRoots();
有且只有 Windows 有效，可以获取所有盘符信息。
String[] list();
通过 File 类对象调用，获取对应文件夹中所有子文件或者子文件夹的名称。
File[] listFiles();
通过 File 类对象调用，获取对应文件夹所有子文件或者子文件夹的 File 对象package com.qfedu.b_file;
import java.io.File;
/*
* 文件列表方法
*/
public class Demo6 {
public static void main(String[] args) {
File[] listRoots = File.listRoots();
for (File file : listRoots) {
System.out.println(file);
}
System.out.println();
File file = new File("D:/aaa");
String[] list = file.list();
for (String string : list) {
System.out.println(string);
}
System.out.println();
File[] listFiles = file.listFiles();
for (File file2 : listFiles) {
System.out.println(file2);
}
}
}2.7 文件名过滤器
/*
文件名过滤器接口
*/
interface FilenameFilter {
/**
* 文件名过滤器要求方法，方法参数指定文件夹 File 对象，第二个是文件名
*/
boolean accept(File dir, String name);
}
可以提供给
String[] list(FilenameFilter filter);
File[] listFiles(FilenameFilter);
完成操作，仅留存指定文件夹中的 .java 文件
1. 文件名 .java 结尾
2. 文件类型是普通文件package com.qfedu.b_file;
import java.io.File;
import java.io.FilenameFilter;
/*
public interface FilenameFilter {
boolean accept(File dir, String name);
}
*/
class MyFilter implements FilenameFilter {
/*
* dir 是目标文件的 File 对象
* name 是子文件或者子文件夹的名称
*/
@Override
public boolean accept(File dir, String name) {
/*
* name.endsWith(".java") 文件名称是否以 .java 结尾
* new File(dir, name).isFile(); 判断对应的文件是否为普通文件
*/
return name.endsWith(".java") && new File(dir, name).isFile();
}
}
public class Demo7 {
public static void main(String[] args) {
File dir = new File("D:/aaa");
File[] listFiles = dir.listFiles(new MyFilter());
for (File file : listFiles) {
System.out.println(file);
}
}
}3. 匿名内部类
3.1 接口操作复习
interface A {
void test();
}
class TypeA implements A {
@Override
public void test() {
System.out.println("遵从接口 A 实现的方法");
}
}3.2 代码组成分析
3.3 代码实现
package com.qfedu.c_interface;
interface A {
void test();
}
class TypeA implements A {
@Override
public void test() {
System.out.println("遵从接口 A 实现的方法");
}
}
public class Demo1 {
public static void main(String[] args) {
TypeA typeA = new TypeA();
typeA.test();
/*
* 1. A a
* a 接口 A 的对象？
* b 接口 A 引用数据类型变量？ 【正确】
*
* 2. {....}里面的内容
* 大括号完成的方法是一个【遵从】接口 A 实现类要求的方法，
* 同时也可以看做是一个类的本体
* 2.1 大括号里面的内容和接口 A 有关系，【遵从】 接口 A
* 2.2 大括号是一个类，但是没有名字，匿名
* 【小总结】 遵从接口 A 但是没有名字的类
*
* 3. new A()
* 3.1 new 作用，在内存堆区申请必要的数据空间，然后将数据空间
* 内容进行清理。【实例化对象过程相关】
* 3.2 A() 看上去是一个接口的构造方法，只能说是特殊的一个操作
* A 表示大括号里面的内容和接口 A 相关，大括号里面的内容要求遵从的接口为 A 接口
* () 小括号是一个方法标记，表示这里依然是一个构造方法，
* 但是类型的名称没有，仅知道是接口 A 的实现类， 匿名类
* 3.3 new A() {....} 实例化遵从接口 A的匿名内部类对象。 接口 A 的匿名实现类对象。
*
*/
A a = new A() {
@Override
public void test() {
System.out.println("匿名内部类");
}
};
a.test();
/*
* Lambda
*/
A b=(() -> System.out.println("Lambda"));
b.test();
}
}4. 作业
1. 案例代码三遍
2. 方法抄写
3. 字符串练习
String str = "[name=张三, age=16, gender=男][name=李四, age=18, gender=男]";
将字符串内容拆解成
List<HashMap<String, String>> =
[
{
name: 张三
age: 16
gender: 男
}
,
{
name: 李四
age: 18
gender: 男
}
]
66
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
