重生之我要精通JAVA--第五周笔记

文章目录

API
- JDK7时间
- - Date时间类
  - Calendar
  - SimpleDateFormat 类
  - - SimpleDateFormat 类作用
- JDK8时间
- - Zoneld时区
- 包装类
- - Integer成员方法
- Arrays
Lambda表达式
- 标准格式
- 注意点
- 好处
- 省略写法
集合进阶
- Collection
- 迭代器遍历
- - Collection集合获取迭代器
  - Iterator中的常用方法
  - 细节注意点
- 增强for遍历
- - 格式
- Lambda表达式遍历
- List
- - 特点
  - 特有方法
- 五种遍历方法
- ArrayList集合底层原理
- LinkedList集合
- 泛型
- - 好处
  - 细节
  - 泛型类
  - 泛型方法
  - 泛型接口
- 数据结构
- - 平衡二叉树（左旋）
  - 平衡二叉树（右旋）
  - 数据结构（平衡二叉树）需要旋转的四种情况
  - - 1.左左：（1次旋转）
    - 2.左右：（2次旋转）
    - 3.右右：（1次旋转）
    - 4.右左：（2次旋转）
  - 红黑树
  - - 数据结构(红黑树)红黑规则
    - 添加节点规则
- Set
- - HashSet
  - - 哈希值
    - 特点
    - HashsetJDK8以后底层原理
  - LinkedHashset底层原理
  - Treeset的特点
  - Treeset的两种比较方式
- 双列集合
- - Map
  - HashMap
  - LinkedHashMap
  - TreeMap
  - - 代码书写两种排序规则
  - 可变参数
  - 细节
  - Collections
- 不可变集合
Stream流
- 步骤
- 中间方法
- 终结方法
方法引用
- 引用成员方法
- 方法引用的规则
- 引用数组的构造方法
异常
- JVM默认处理异常的方式:
- 捕获异常
- - 格式
  - 灵魂四问
- Throwable的成员方法
- 自定义异常
- - 步骤
File
- 路径

API

JDK7时间

Date时间类

Date类是一个JDK写好的avabean类，用来描述时间，精确到毫秒
利用空参构造创建的对象，默认表示系统当前时间，
利用有参构造创建的对象，表示指定的时间

创建时间对象

Date date = new Date(); //系统当前时间
Date date =new Date(指定毫秒值); //时间原点开始加指定毫秒值后的时间

修改时间对象中的毫秒值：
void setTime(毫秒值);时间原点开始加指定毫秒值后的时间获取时间对象中的毫秒值
long getTime();

Calendar

Calendar代表了系统当前时间的日历对象，可以单独修改、获取时间中的年，月，日
细节：Calendar是一个抽象类，不能直接创建对象，

获取日历类对象方法：static Calendar getInstance()

国外月份减1

平闰年判断练习

  public static void method1() {
        Scanner sc = new Scanner(System.in);
        Calendar calendar = Calendar.getInstance();
        int year = sc.nextInt();
        calendar.set(year, 2, 1);
        calendar.add(Calendar.DATE, -1);
        int date = calendar.get(Calendar.DATE);
        if (date == 29) {
            System.out.println("闰年");
        } else {
            System.out.println("平年");
        }
    }

SimpleDateFormat 类

SimpleDateFormat 类作用

格式化：把时间变成我们喜欢的格式。
解析：把字符串表示的时间变成Date对象。

构造方法	说明
`public simpleDateFormat()`	构造一个simpleDateFormat，使用默认格式
`public SimpleDateFormat(string pattern)`	构造一个simpleDateFormat，使用指定的格式

常用方法	说明
`public final string format(Date date)`	格式化(日期对象->字符串)
`public Date parse(string source)`	解析(字符串 ->日期对象)

public class test02 {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat();

        Date date1 = new Date();
        String s = sdf.format(date1);
        System.out.println(s);

        Date date2 = sdf.parse("2024/5/11 下午9:58");
        System.out.println(date2);
    }
}

public class test02 {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = new Date();
        String s = sdf.format(date1);
        System.out.println(s);

        Date date2 = sdf.parse("2024-05-11 22:04:28");
        System.out.println(date2);
    }
}

sdf.parse只能解析sdf对应的格式

JDK8时间

Date类
日期格式化类：SimpleDateFormat
日历类：Calendar
工具类

Zoneld时区

方法名	说明
`static Set\<string> getAvailableZoneIds()`	获取Java中支持的所有时区
`static ZoneId systemDefault()`	获取系统默认时区
`static ZoneId of(String zoneId)()`	获取一个指定时区

包装类

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

方法名	说明
`public Integer(int value)`	根据传递的整数创建一个Integer对象
`public Integer(string s)`	根据传递的字符串创建一个Integer对象
`public static Integer valueof(int i)`	根据传递的整数创建一个Integer对象
`public static Integer valueof(string s)`	根据传递的字符串创建一个Integer对象
`public static Integer valueof(string s,int radix)`	根据传递的字符串和进制创建一个Integer对象

Integer成员方法

方法名	说明
`public static Sting toBinaryString(int i)`	得到二进制
`public static String toOctalString(int i)`	得到八进制
`public static String toHexString(int i)`	得到十六进制
`public static int parselnt(String s)`	将字符串类型的整数转成int类型的整数

Arrays

操作数组的工具类

方法名	说明
`public static String toString(数组)`	把数组拼接成一个字符串
`public static int binarySearch(数组, 查找的元素)`	二分查找法查找元素
`public static int[] copyOf(原数组, 新数组长度)`	拷贝数组
`public static int[] copyOfRange(原数组, 起始索引, 结束索引)`	拷贝数组(指定范围)
`public static void fill(数组, 元素)`	填充数组
`public static void sort(数组)`	按照默认方式进行数组排序
`public static void sort(数组, 排序规则)`	按照指定的规则排序

Lambda表达式

标准格式

Arrays.sort(arr,(Integer ol,Integer o2)->{
	return o1 - o2;
	}
);

注意点

Lambda表达式可以用来简化匿名内部类的书写
Lambda表达式只能简化函数式接口的匿名内部类的写法
函数式接口：
有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@Functionalinterface注解

好处

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。

省略写法

核心：可推导，可省略

参数类型可以省略不写
如果只有一个参数，参数类型可以省略，同时()也可以省略。
如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略

集合进阶

List系列集合：添加的元素是有序、可重复、有索引

Set系列集合：添加的元素是无序、不重复、无索引

Collection

方法名称	说明
`public boolean add(E e)`	把给定的对象添加到当前集合中
`public void clear()`	清空集合中所有的元素
`public boolean remove(E e)`	把给定的对象在当前集合中删除
`public boolean contains(Object obj)`	判断当前集合中是否包含给定的对象
`public boolean isEmpty()`	判断当前集合是否为空
`public int size()`	返回集合中元素的个数/集合的长度

迭代器遍历

迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式。

Collection集合获取迭代器

方法名称	说明
`Iterator\<E> iterator()`	返回迭代器对象，默认指向当前集合的0索引

Iterator中的常用方法

方法名称	说明
`boolean hasNext()`	判断当前位置是否有元素，有元素返回true,没有元素返回false
`E next()`	获取当前位置的元素，并将迭代器对象移向下一个位置

细节注意点

报错NoSuchElementException
迭代器遍历完毕，指针不会复位
循环中只能用一次next方法
迭代器遍历时，不能用集合的方法进行增加或者删除

增强for遍历

增强for的底层就是迭代器，为了简化迭代器的代码书写的
它是JDK5之后出现的，其内部原理就是一个Iterator迭代器
所有的单列集合和数组才能用增强for进行遍历

格式

for (元素的数据类型 变量名 : 数组或者集合) {
    
}

for (String s : list) {
    System.out.println(s);
}

修改增强for中的变量，不会改变集合中原本的数据。

Lambda表达式遍历

得益于JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

方法名称	说明
`default void forEach(Consumer<? super T> action)：`	结合lambda遍历集合

List

特点

有序：存和取的元素顺序一致
有索引：可以通过索引操作元素
可重复：存储的元素可以重复

特有方法

Collection的方法List都继承了
List集合因为有索引，所以多了很多索引操作的方法

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

五种遍历方法

迭代器遍历：在遍历的过程中需要删除元素，请使用迭代器
列表迭代器：在遍历的过程中需要添加元素，请使用列表迭代器
增强for遍历：仅仅想遍历，那么使用增强for或Lambda表达式
Lambda表达式：同上
普通for：如果遍历的时候想操作索引，可以用普通for。

ArrayList集合底层原理

利用空参创建的集合，在底层创建一个默认长度为0的数组
添加第一个元素时，底层会创建一个新的长度为10的数组
存满时，会扩容1.5倍
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

LinkedList集合

底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。
LinkedList本身多了很多直接操作首尾元素的特有API。

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

泛型

泛型：是IDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查
泛型的格式：<数据类型>
注意：泛型只能支持引用数据类型

好处

统一数据类型。
把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来。

细节

泛型中不能写基本数据类型
指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
如果不写泛型，类型默认是Object

泛型类

使用场景：当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

修饰符 class 类名<类型> {
    
}

public class ArrayList<E> {
    
}

泛型方法

方法中形参类型不确定时：
方案①：使用类名后面定义的泛型（所有方法都能用）
方案②：在方法申明上定义自己的泛型（只有本方法能用）

修饰符<类型> 返回值类型 方法名(类型 变量名){
    
}

public<T> void show(T t){
    
}

泛型接口

修饰符 interface 接口名<类型>{
    
}

public interface List<E>{
    
}

重点:：如何使用一个带泛型的接口

方式1：实现类给出具体类型
方式2：实现类延续泛型，创建对象时再确定

数据结构

平衡二叉树（左旋）

确定支点：从添加的节点开始，不断的往父节点找不平衡的节点

以不平衡的点作为支点
把支点左旋降级，变成左子节点
晋升原来的右子节点
以不平衡的点作为支点
将根节点的右侧往左拉
原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右子节点

平衡二叉树（右旋）

以不平衡的点作为支点
就是将根节点的左侧往右拉
原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点

数据结构（平衡二叉树）需要旋转的四种情况

左左
左右
右右
右左

1.左左：（1次旋转）

当根节点左子树的左子树有节点插入，导致二叉树不平衡

2.左右：（2次旋转）

当根节点左子树的右子树有节点插入，导致二叉树不平衡

3.右右：（1次旋转）

当根节点右子树的右子树有节点插入，导致二叉树不平衡

4.右左：（2次旋转）

当根节点右子树的左子树有节点插入，导致二叉树不平衡

红黑树

红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构
1972年出现，当时被称之为平衡二叉B树。后来，1978年被修改为如今的"红黑树"
它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色
每一个节点可以是红或者黑；红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的

数据结构(红黑树)红黑规则

①每一个节点或是红色的，或者是黑色的
②根节点必须是黑色
③如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点(Nil)是黑色的
④如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
⑤对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点

添加节点规则

默认颜色：添加节点默认是红色的（效率高）

Set

无序：存取顺序不一致
不重复：可以去除重复
无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素
Hashset：无序、不重复、无索引
LinkedHashset：有序、不重复、无索引
Treeset：可排序、不重复、无索引

HashSet

Hashset集合底层采取哈希表存储数据
哈希表是一种对于增删改查数据性能都较好的结构
JDK8之前：数组+链表
JDK8开始：数组+链表+红黑树

哈希值

根据hashcode方法算出来的int类型的整数
该方法定义在Object类，所有对象都可以调用，默认使用地址值进行计算
一般情况下，会重写hashCode方法，利用对象部的属性值计算哈希值

特点

如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
如果已经重写hashCode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样(哈希碰撞)

HashsetJDK8以后底层原理

创建一个默认长度16，默认加载因为0.75的数组，数组名table
根据元素的哈希值跟数组的长度计算出应存入的位置
判断当前位置是否为null，如果是null直接存入
如果位置不为null，表示有元素，则调用equals方法比较属性值

一样：不存----------不一样：存入数组，形成链表
JDK8以前：新元素存入数组，老元素挂在新元素下面
JDK8以后：新元素直接挂在老元素下面

IDK8以后，当链表长度超过8，而且数组长度大于等于64时，自动转换为红黑树

如果集合中存储的是自定义对象，必须要重写hashCode和eguals法

LinkedHashset底层原理

有序、不重复、无索引。
这里的有序指的是保证存储和取出的元素顺序一致
原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

Treeset的特点

不重复、无索引、可排序
可排序：按照元素的默认规则(有小到大)排序
Treeset集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。

Treeset的两种比较方式

方式一：

默认排序/自然排序:Javabean类实现Comparable接口指定比较规则

方式二：

比较器排序:创建TreeSet对象时候，传递比较器Comparator指定规则

使用原则:默认使用第一种，如果第一种不能满足当前需求，就使用第二种

双列集合

① 双列集合一次需要存一对数据，分别为键和值
②键不能重复，值可以重复
③ 键和值是-一对应的，每一个键只能找到自己对应的值
④ 键+值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象"

Map

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

put方法的细节：
添加/覆盖
在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回nu11
在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回

HashMap

HashMap是Map里面的一个实现类
没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
特点都是由键决定的：无序、不重复、无索引

LinkedHashMap

由键决定：有序、不重复、无索引
这里的有序指的是保证存储和取出的元素顺序一致
原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序

TreeMap

TreeMap跟Treeset底层原理一样，都是红黑树结构的。
由键决定特性：不重复、无索引、可排序
可排序：对键进行排序
注意：默认按照键的从小到大进行排序，也可以自己规定键的排序规则

代码书写两种排序规则

实现Comparable接口，指定比较规则。
创建集合时传递Comparator比较器对象，指定比较规则。

可变参数

方法形参的个数是可以发生变化的，0，1，2，3…
格式：属性类型…名字
int…args

细节

在方法的形参中最多只能写一个可变参数
在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后

Collections

java.util.Collections:是集合工具类
作用：Collections不是集合，而是集合的工具类，

方法名称	说明
`public static <T> boolean addAll(Collection<T> c, T... elements)`	批量添加元素
`public static void shuffle(List<?> list)`	打乱List集合元素的顺序
`public static <T> void sort(List<T> list)`	排序
`public static <T> void sort(List<T> list, Comparator<? super T> c)`	根据指定的规则进行排序
`public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)`	以二分查找法查找元素
`public static <T> void copy(List<? super T> dest, List<? extends T> src)`	拷贝集合中的元素
`public static <T> void fill(List<? super T> list, T obj)`	使用指定的元素填充集合
`public static <T> T max(Collection<? extends T> coll)`	获取最大值
`public static <T> T min(Collection<? extends T> coll)`	获取最小值
`public static void swap(List<?> list, int i, int j)`	交换集合中指定位置的元素

不可变集合

如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。
当集合对象被不可信的库调用时，不可变形式是安全的。

方法名称	说明
`static <E> List<E> of(E...elements)`	创建一个具有指定元素的List集合对象
`static <E> Set<E> of(E...elements)`	创建一个具有指定元素的Set集合对象
`static <K, V> Map<K, V> of(E...elements)`	创建一个具有指定元素的Map集合对象

Stream流

结合了Lambda表达式，简化集合、数组的操作

步骤

先得到一条Stream流(流水线)，并把数据放上去
利用Stream流中的API进行各种操作

获取方式	方法名	说明
单列集合	default Stream<E> stream()	Collection中的默认方法
双列集合	无	无法直接使用stream流
数组	public static <T> Stream<T> stream(T[] array)	Arrays工具类中的静态方法
一堆零散数据	public static <T> Stream<T> of(T… values)	Stream接口中的静态方法

中间方法

名称	说明
`Stream<T> filter(Predicate<? super T> predicate)`	过滤
`Stream<T> limit(long maxSize)`	获取前几个元素
`Stream<T> skip(long n)`	跳过前几个元素
`Stream<T> distinct()`	元素去重，依赖`hashCode`和`equals`方法
`static <T> Stream<T> concat(Stream a, Stream b)`	合并a和b两个流为一个流
`Stream<R> map(Function<T, R> mapper)`	转换流中的数据类型

注意：

中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
修改Stream流中的数据，不会影响原来集合或者数组中的数据

终结方法

名称	说明
`void forEach(Consumer action)`	遍历
`long count()`	统计
`toArray()`	收集流中的数据，放到数组中
`collect(Collector collector)`	收集流中的数据，放到集合中

toArray()

直接使用toArray()方法：

Object[] arr1 = list.stream().toArray();

将流中的元素按照其出现顺序，收集到一个Object类型的数组中。

使用toArray(IntFunction)方法：

String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});

apply的形参：流中数据的个数，要跟数组的长度保持一致

apply的返回值：具体类型的数组

允许指定数组的长度，并根据需要为其分配内存。

它的作用是根据流中元素的数量创建一个指定类型的数组，然后将流中的元素按照其出现顺序放入数组中。

在这个例子中，我们实现了IntFunction接口，并覆盖了其中的apply()方法。这个方法接受一个整数参数，表示数组的长度。在apply()方法中，我们根据这个长度创建了一个String类型的数组，然后返回它。这个数组最终用于收集流中的元素

方法引用

::为方法引用符

用法：类::方法名

引用成员方法

格式：对象::成员方法

其他类：其他类对象::方法名
本类：this::方法名
父类：super::方法名

方法引用的规则

需要有函数式接口
被引用的方法必须已经存在
被引用方法的形参，需要跟抽象方的第二个形参到最后一个形参保持一致，返回值需要保持一致。
被引用方法的功能需要满足当前的需求

引用数组的构造方法

格式：数据类型[ ]::new
范例：int[ ]::new

异常

Error：代表的系统级别错误(属于严重问题)
系统一旦出现问题，sun公司会把这些错误封装成Error对象，
Error是给sun公司自己用的，不是给我们程序员用的，因此我们开发人员不用管它。

Exception：叫做异常，代表程序可能出现的问题，
我们通常会用Exception以及他的子类来封装程序出现的问题。

运行时异常：RuntimeException及其子类
编译阶段不会出现异常提醒，
运行时出现的异常(如：数组索引越界异常)。

JVM默认处理异常的方式:

把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
程序停止执行，异常下面的代码不会再执行了

捕获异常

格式

try{
    可能出现异常的代码;
}catch(异常类名 变量名){
    异常的处理代码;
}

目的：当代码出现异常时，可以让程序继续往下执行。

灵魂四问

Throwable的成员方法

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

自定义异常

定义异常类
写继承关系
空参构造
带参构造

步骤

定义自定义异常类：

你可以创建一个继承自 Exception 或 RuntimeException 的新类。继承 Exception 会创建一个受检异常（checked exception），继承 RuntimeException 会创建一个非受检异常（unchecked exception）。

java复制代码// 自定义受检异常
public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
    
    public CustomCheckedException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 自定义非受检异常
public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
    
    public CustomUncheckedException(String message, Throwable cause) {
        super(message, cause);
    }
}

使用自定义异常：

你可以在代码中抛出和捕获自定义异常。

java复制代码public class Main {
    public static void main(String[] args) {
        try {
            methodThatThrowsCheckedException();
        } catch (CustomCheckedException e) {
            e.printStackTrace();
        }

        try {
            methodThatThrowsUncheckedException();
        } catch (CustomUncheckedException e) {
            e.printStackTrace();
        }
    }

    public static void methodThatThrowsCheckedException() throws CustomCheckedException {
        // 某些代码逻辑
        throw new CustomCheckedException("This is a custom checked exception");
    }

    public static void methodThatThrowsUncheckedException() {
        // 某些代码逻辑
        throw new CustomUncheckedException("This is a custom unchecked exception");
    }
}

File

路径

相对路径

路径1：“a.txt”
路径2：“abc\\a.txt”

绝对路径

路径1：“c:\\a.txt”
路径2：“c:\\abc\\a.txt”

File对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径
这个路径可以是存在的，也允许是不存在的

方法名称	说明
`public File(String pathname)`	根据文件路径创建文件对象
`public File(String parent, String child)`	根据父路径名字符串和子路径名字符串创建文件对象
`public File(File parent, String child)`	根据父路径名对应文件对象和子路径名字符串创建文件对象

参考资料：黑马程序员Java零基础视频教程

已经到底啦！！