Java入门9（HashSet，File文件类）

2023-05-22 12:37 由 te9uila 发表于 #后端开发

HashSet

jdk1.7之前，使用数组加链表的方式实现
jdk1.8之后，在链表长度大于8并且数组长度超过32的情况下，会转成红黑树结构
HashSet的本质是一个HashMap，它所有的value都是一致的，传入的参数作为key，因此HashSet中不允许重复数据
存储的时候，键值对位于的数组位置，之和key的HashCode值有关，无法保证先插入的key的HashCode值一定比较小，因此无法保证存读有序

Set<String> set = new HashSet<>();
set.add("Robot01");
set.add("Robot02");
set.add("Robot03");
// 1. 增强for循环遍历
for (String s : set) {
    System.out.println(s + "\t");
}
System.out.println();
// 2. 迭代器遍历
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next() + "\t");
}

二叉树

SVVQ$IY~6EGXO9BSC1GB

二叉树的节点类

@Data
@AllArgsConstructor
@NoArgsConstructor
// 泛型继承，你提供的泛型类型一定是Comparable类的子类
public class Node<V extends Comparable> {
    private V value;
    private Node<V> leftNode;
    private Node<V> rightNode;
    public void addNode(V value){
        if (null == this.value){
            // 当前节点没有值
            this.value = value;
        }else{
            // 当前节点有值
            if(this.value.compareTo(value)>=0){
                // 当前值小于节点值
                // 判断当前节点的左节点是否为空
                if(null == leftNode){
                    // 左节点为空,新建新节点
                    leftNode = new Node<>();
                }
                // 递归调用
                leftNode.addNode(value);
            } else {
                // 当前值大于节点值
                // 判断当前节点的右节点是否为空
                if (null == rightNode){
                    // 右节点为空,新建新节点
                    rightNode = new Node<>();
                }
                rightNode.addNode(value);
            }
        }
    }
}

// 测试类
public class Application {
    public static void main(String[] args) {
        int[] randoms = {17,34,64,72,37,18,98,37,53,63};
        // 创建根节点
        Node<Integer> root = new Node<>();
        for (int random : randoms) {
            root.addNode(random);
        }
        System.out.println(root.getRightNode().getValue());
    }
}

三种遍历方法（前序遍历，中序遍历，后序遍历）

以中序遍历为例

// 中序遍历
public List<V> inOrder(Node<V> root){
    List<V> nodeList = new ArrayList<>();
    if(null == root.value){
        return nodeList;
    }else{
        if (null != root.leftNode){
            nodeList.addAll(inOrder(root.leftNode));
        }
        nodeList.add(root.value);
        if (null != root.rightNode){
            nodeList.addAll(inOrder(root.rightNode));
        }
        return nodeList;
    }
}

TreeMap和TreeSet

TreeMap中，所有的key是以红黑树进行存储的
在使用TreeMap的时候，如果你key的类型实现了比较器接口，就可以自动排序
TreeSet和TreeMap方法几乎一致，只不过不再提供value的获取，所有方法获取的都是key
两者相同，要么泛型对应的数据类型实现了Comparable接口，要么手动提供一个Comparator比较器对象，否则两者都不可以被实例化（类似于强制排序）

public static void main(String[] args) {
    TreeMap<String, String> treeMap = new TreeMap<>();
    // 根据key的compareTo比较器确定的排序方法
    for (int i = 0; i < 5; i++) {
        treeMap.put("robot0" + i,"i");
    }
    // 返回第一个key（hashcode最小）
    System.out.println(treeMap.firstKey());
    // 返回第一个键值对（hashcode最小）
    System.out.println(treeMap.firstEntry());
    // 返回最后一个键值对（hashcode最大）
    System.out.println(treeMap.lastEntry());
    // 返回最后一个键值对（hashcode最大）
    System.out.println(treeMap.lastKey());
    // 如果匹配的key存在，默认取匹配key
    System.out.println(treeMap.floorKey("robot01"));
    // 如果匹配key存在，则取上一个key
    System.out.println(treeMap.lowerKey("robot01"));
    // 还有很多基于key的排序衍生出来的方法。。。。
}

日期类（Calendar类）

// Calendar 日历类，对日期时间做修改和调整(单例模式)
// add 基于时间单位做日期的前后调整
// set 基于时间单位做日期值的设置
Calendar c = Calendar.getInstance();

// 创建日期对象时，如果没有指定时间，默认使用当前时间
Date now = c.getTime();
System.out.println(c.getTime());

// 获得下个月的今天
// 参数值如果时正数，表示未来，如果为负数，表示过去
c.add(Calendar.MONTH,1);
System.out.println(c.getTime());

// 重置日历时间
c.setTime(now);

// 获取上个月的第三天
c.add(Calendar.MONTH,-1);

// 如果set的是月份那么使用（0~11）来表示1~12月
c.set(Calendar.DATE,3);
System.out.println(c.getTime());

文件类（File类）

Java中借助文件类的对象，来操作和访问磁盘中的真实文件，文件对象只是真实文件的映射，并不代表文件本身，文件是否存在并不影响对象的创建。

文件对象的三种创建方式

基于文件再磁盘中的绝对路径来进行创建

File f1 = new File("文件路径")

基于当前项目所在位置路径进行创建

File f1 = new File("文件名")

基于另一个目录对象作为父目录，创建文件对象

File f1 = new File(f1,"文件名")

返回文件绝对路径

System.out.println(f1.getAbsolutePath());

文件类常用方法

1. 判断文件是否存在

System.out.println(f1.exists());

2.判断是否是文件夹

System.out.println(f1.isDirectory());

3.判断是否是文件

System.out.println(f1.isFile());

4.获取文件长度

System.out.println(f2.length());

5.文件最后修改时间

System.out.println(f2.lastModified());
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
// 日期转字符串
System.out.println(dateFormat.format(f2.lastModified()));
// 字符串转日期，必须保证字符串日期格式与定义的format格式一致，且必须进行异常处理
String str = "2023-05-20 13:59:47 871";
try {
    System.out.println(dateFormat.parse("2023-05-20 13:59:47 871"));
} catch (ParseException e) {
    e.printStackTrace();
}System.out.println(f2.lastModified());

6.设置文件最后修改时间

String str = "2023-05-20 13:59:47 871";
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
try {
    Date d = dateFormat.parse("2023-05-20 13:59:47 871");
    file02.setLastModified(d.getTime());
} catch (ParseException e) {
    e.printStackTrace();
}

7.设置文件只读

file02.setReadOnly();

8. 重命名文件

// 文件重命名，需要提供新的文件对象
File file03 = new File(file01,"HAHAHAHAHA.txt");
file02.renameTo(file03);

9. 以字符串数组的形式返回当前目录下所有文件的文件名称

// 以字符串数组的形式返回当前目录下所有文件的文件名称
String[] fileList = file01.list();
System.out.println(Arrays.asList(fileList));

10. 以文件对象数组的方式，返回当前目录下所有文件所对应的文件对象

// 以文件对象数组的方式，返回当前目录下所有文件所对应的文件对象
File[] files = file01.listFiles();
for (File file : files) {
    System.out.println(file);
}

11.获取当前文件对象父目录的路径

// 获取当前文件对象父目录的路径
System.out.println(file02.getParent());
// 获取当前文件对象父目录所对应的文件对象
File parentFile = file02.getParentFile();
System.out.println(parentFile.getAbsoluteFile());

12.创建文件对象路径所对应的目录

// 创建文件对象路径所对应的目录
File file = new File("绝对路径");
file.mkdirs();

13.创建文件对象的路径所对应的文件

// 创建文件对象的路径所对应的文件
File file = new File("绝对路径");
// 再创建文件之前，应该先判断文件的父目录是否存在
// 如果存在，则直接创建，如果不存在则应该先创建父目录
if (!file.getParentFile().exists()){
    file.getParentFile().mkdirs();
}
try {
    file.createNewFile();
} catch (IOException e) {
    throw new RuntimeException(e);
}

14.删除文件

// 删除文件
file02.delete();
// 退出的时候再删除(用于临时文件)
file02.deleteOnExit();