五、树和二叉树

已于 2024-09-11 12:55:47 修改
阅读量764 收藏 15
点赞数 30
分类专栏： # Java数据结构 文章标签： java 开发语言
于 2024-09-11 12:46:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44063529/article/details/142136708
版权

文章目录

一、树的引入

在这里插入图片描述

二、树的术语

在这里插入图片描述

三、二叉树

3.1 二叉树的概念

在这里插入图片描述

在这里插入图片描述

3.2 二叉树的遍历

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class BinaryTreeDemo<T> {
    private BinaryNode<T> root;

    public BinaryTreeDemo(BinaryNode<T> root) {
        this.root = root;
    }

    public static void main(String[] args) {
        BinaryNode<String> node1 = new BinaryNode<>("宋江", null, null);
        BinaryNode<String> node2 = new BinaryNode<>("吴用", null, null);
        BinaryNode<String> node3 = new BinaryNode<>("卢俊", null, null);
        BinaryNode<String> node4 = new BinaryNode<>("林冲", null, null);
        BinaryNode<String> node5 = new BinaryNode<>("关胜", null, null);
        node1.left = node2;
        node1.right = node3;
        node3.left = node5;
        node3.right = node4;

        BinaryTreeDemo<String> stringBinaryTreeDemo = new BinaryTreeDemo<String>(node1);

        System.out.println("先序遍历");
        stringBinaryTreeDemo.preOrder(); // 先序遍历
        System.out.println();
        System.out.println("中序遍历");
        stringBinaryTreeDemo.midOrder(); // 中序遍历
        System.out.println();
        System.out.println("后序遍历");
        stringBinaryTreeDemo.afterOrder(); // 后序遍历

    }

    // 先序遍历
    public void preOrder() {
        if (root == null) {
            System.out.println("二叉树为空无法判定");
            return;
        }
        preOrder(root);
    }

    private void preOrder(BinaryNode<T> bn) {
        System.out.println(bn.data);
        if (bn.left != null) {
            preOrder(bn.left);
        }
        if (bn.right != null) {
            preOrder(bn.right);
        }
    }

    // 中序遍历
    public void midOrder() {
        if (root == null) {
            System.out.println("二叉树为空无法判定");
            return;
        }
        midOrder(root);
    }

    private void midOrder(BinaryNode<T> bn) {
        if (bn.left != null) {
            midOrder(bn.left);
        }
        System.out.println(bn.data);
        if (bn.right != null) {
            midOrder(bn.right);
        }
    }

    // 后序遍历
    public void afterOrder() {
        if (root == null) {
            System.out.println("二叉树为空无法判定");
            return;
        }
        afterOrder(root);
    }

    private void afterOrder(BinaryNode<T> bn) {
        if (bn.left != null) {
            afterOrder(bn.left);
        }
        if (bn.right != null) {
            afterOrder(bn.right);
        }
        System.out.println(bn.data);
    }

}

class BinaryNode<T> {
    T data;
    BinaryNode<T> left;
    BinaryNode<T> right;

    public BinaryNode(T data, BinaryNode<T> left, BinaryNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

3.3 二叉树-查找指定结点

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class BinaryTreeSearch<T> {
    BinaryNode<T> root;

    public static void main(String[] args) {
        BinaryNode<String> node1 = new BinaryNode<>("宋江", null, null);
        BinaryNode<String> node2 = new BinaryNode<>("吴用", null, null);
        BinaryNode<String> node3 = new BinaryNode<>("卢俊", null, null);
        BinaryNode<String> node4 = new BinaryNode<>("林冲", null, null);
        BinaryNode<String> node5 = new BinaryNode<>("关胜", null, null);
        node1.left = node2;
        node1.right = node3;
        node3.left = node5;
        node3.right = node4;

        BinaryTreeSearch<String> stringBinaryTreeSearch = new BinaryTreeSearch<>(node1);
        System.out.println(stringBinaryTreeSearch.preSearch("1")); // 前序查找
        System.out.println(stringBinaryTreeSearch.midSearch("林冲")); // 中序查找
        System.out.println(stringBinaryTreeSearch.afterSearch("林冲")); // 后序查找

    }

    public BinaryTreeSearch(BinaryNode<T> root) {
        this.root = root;
    }

    public BinaryNode<T> preSearch(T d) {
        if (root == null) {
            return null;
        }
        return preSearch(root, d);
    }

    private BinaryNode<T> preSearch(BinaryNode<T> bn, T d) {
        if (bn.data.equals(d)) {
            return bn;
        }
        BinaryNode<T> resNode;
        if (bn.left != null) {
            // 左递归前序查找，找到结点，则返回，否则继续判断
            if ((resNode = preSearch(bn.left, d)) != null) return resNode;
        }
        if (bn.right != null) {
            if ((resNode = preSearch(bn.right, d)) != null) return resNode;
        }
        return null;
    }

    public BinaryNode<T> midSearch(T d) {
        if (root == null) {
            return null;
        }
        return midSearch(root, d);
    }

    private BinaryNode<T> midSearch(BinaryNode<T> bn, T d) {
        BinaryNode<T> resNode;
        if (bn.left != null) {
            // 左递归前序查找，找到结点，则返回，否则继续判断
            if ((resNode = midSearch(bn.left, d)) != null) return resNode;
        }
        if (bn.data.equals(d)) {
            return bn;
        }
        if (bn.right != null) {
            if ((resNode = midSearch(bn.right, d)) != null) return resNode;
        }
        return null;
    }


    public BinaryNode<T> afterSearch(T d) {
        if (root == null) {
            return null;
        }
        return afterSearch(root, d);
    }

    private BinaryNode<T> afterSearch(BinaryNode<T> bn, T d) {
        BinaryNode<T> resNode;
        if (bn.left != null) {
            // 左递归前序查找，找到结点，则返回，否则继续判断
            if ((resNode = midSearch(bn.left, d)) != null) return resNode;
        }
        if (bn.right != null) {
            if ((resNode = midSearch(bn.right, d)) != null) return resNode;
        }
        if (bn.data.equals(d)) {
            return bn;
        }
        return null;
    }

}

3.3 二叉树-删除结点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class BinaryRemove<T> {
    BinaryNode<T> root;

    public static void main(String[] args) {
        BinaryNode<String> node1 = new BinaryNode<>("宋江", null, null);
        BinaryNode<String> node2 = new BinaryNode<>("吴用", null, null);
        BinaryNode<String> node3 = new BinaryNode<>("卢俊", null, null);
        BinaryNode<String> node4 = new BinaryNode<>("林冲", null, null);
        BinaryNode<String> node5 = new BinaryNode<>("关胜", null, null);
        node1.left = node2;
        node1.right = node3;
        node3.left = node5;
        node3.right = node4;

        BinaryRemove<String> stringBinaryRemove = new BinaryRemove<String>(node1);
        System.out.println(stringBinaryRemove.delete("关胜"));
    }

    public BinaryRemove(BinaryNode<T> root) {
        this.root = root;
    }

    public boolean delete(T d) {
        if (root == null) {
            return false;
        }
        if (root.data.equals(d)) {
            root = null;
            return true;
        }
        return delete(root, d);
    }

    private boolean delete(BinaryNode<T> bn, T d) {

        // 已经是叶子结点，因此没有对应的数据
        if (bn.left == null && bn.right == null) {
            return false;
        }

        // 左子树的根节点是要删除的元素
        if (bn.left != null && bn.left.data.equals(d)) {
//            bn.left = null;
            if (bn.left.left == null && bn.left.right == null) {
                bn.left = null; // 叶子结点直接删除
            } else if (bn.left.left == null) {
                bn.left = bn.left.right; // 右边有则加入右边
            } else {
                bn.left = bn.left.left; // 左边有或两边都有则加入左边
            }
            return true;
        }

        // 右子树的根节点是要删除的元素
        if (bn.right != null && bn.right.data.equals(d)) {
//            bn.right = null;
            if (bn.right.left == null && bn.right.right == null) {
                bn.right = null; // 叶子结点直接删除
            } else if (bn.right.left == null) {
                bn.right = bn.right.right; // 右边有则加入右边
            } else {
                bn.right = bn.right.left; // 左边有或两边都有则加入左边
            }
            return true;
        }
        // 左递归删除
        if (bn.left != null) {
            if (delete(bn.left, d)) {
                return true;
            }
        }

        // 右递归删除
        if (bn.right != null) {
            // 若左递归没有删除结点，则右递归结果作为最终的
            return delete(bn.right, d);
        }
        // 没有当前结点的删除，因为当前结点在上一层递归中已作出判断
        return false;
    }

}

3.4 顺序存储二叉树

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class ArrBinaryTree {
    int[] arr;

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        new ArrBinaryTree(arr).preSearch();
    }

    public ArrBinaryTree(int[] arr) {
        this.arr = arr;
    }

    public void preSearch() {
        preSearch(0);
    }

    private void preSearch(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能遍历");
            return;
        }
        if (index > arr.length - 1) {
            return;
        }
        System.out.println(arr[index]);
        // 遍历左子树
        preSearch(2 * index + 1);
        // 遍历右子树
        preSearch(2 * index + 2);
    }
}

在这里插入图片描述

3.5 线索化二叉树

  • n个结点对应有n+1个空指针域（左指针域与右指针域工2n个）
    在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3.5.1 线索化二叉树应用案例

  • 处理核心是得到存在空指针的域的结点，设置当前结点的左指针向前驱结点；设置当前结点的前驱结点的右指针指向自己
    在这里插入图片描述
package com.gyh.tree;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class ThreadedBinaryTreeDemo<T> {

    public static void main(String[] args) {
        ThreadBinaryNode<Integer> node1 = new ThreadBinaryNode<Integer>(1, null, null);
        ThreadBinaryNode<Integer> node2 = new ThreadBinaryNode<Integer>(3, null, null);
        ThreadBinaryNode<Integer> node3 = new ThreadBinaryNode<Integer>(6, null, null);
        ThreadBinaryNode<Integer> node4 = new ThreadBinaryNode<Integer>(8, null, null);
        ThreadBinaryNode<Integer> node5 = new ThreadBinaryNode<Integer>(10, null, null);
        ThreadBinaryNode<Integer> node6 = new ThreadBinaryNode<Integer>(14, null, null);
        node1.left = node2;
        node1.right = node3;

        node2.left = node4;
        node2.right = node5;

        node3.left = node6;

        ThreadedBinaryTreeDemo<Integer> binaryTreeDemo = new ThreadedBinaryTreeDemo<>(node1);
        binaryTreeDemo.threadNodes();
        // 测试叶子结点的左右指针指向
        System.out.println("left:" + node5.leftType + " " + node5.left.data);
        System.out.println("left:" + node5.leftType + " " + node5.right.data);
    }

    ThreadBinaryNode<T> root;
    // pre 当前结点对象的前驱结点
    ThreadBinaryNode<T> pre = null;

    public ThreadedBinaryTreeDemo(ThreadBinaryNode<T> root) {
        this.root = root;
    }

    public void threadNodes() {
        if (root == null) {
            return;
        }
        threadNodes(root);
    }

    /**
     * 编写对二叉树进行中序线索化的方法
     *
     * @param cur 当前结点对象
     */
    private void threadNodes(ThreadBinaryNode<T> cur) {
        // 当前结点为空
        if (cur == null) {
            return;
        }

        // 线索化左子树
        threadNodes(cur.left);

        // 线索化当前结点
        // 先处理当前结点的前驱结点
        if (cur.left == null) {
            // 指向前驱结点
            cur.left = pre;
            // 设置左子树表示为前驱结点
            cur.leftType = 1;
        }

        // 处理右指针
        // 是让后继结点处理前驱结点的空指针域（即若前驱结点的右指针域为null，则让其指向当前结点）
        if (pre != null && pre.right == null) {
            // 让前驱结点的右指针指向当前结点
            pre.right = cur;
            // 设置右子树表示为后继结点
            pre.rightType = 1;
        }
        // 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = cur;


        // 线索化右子树
        threadNodes(cur.right);


    }

}

class ThreadBinaryNode<T> {
    T data;
    int leftType; // 为0表示指向的是左子树，如果1则表示前驱
    ThreadBinaryNode<T> left;

    int rightType; // 为0表示指向的是右子树，如果1则表示后继
    ThreadBinaryNode<T> right;


    public ThreadBinaryNode(T data, ThreadBinaryNode<T> left, ThreadBinaryNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public ThreadBinaryNode(T data, int leftType, ThreadBinaryNode<T> left, int rightType, ThreadBinaryNode<T> right) {
        this.data = data;
        this.leftType = leftType;
        this.left = left;
        this.rightType = rightType;
        this.right = right;
    }
}

3.5.2 遍历线索化二叉树

在这里插入图片描述

在这里插入图片描述

public void threadedShow() {
        // 循环找到 leftType == 1的结点，第一个找到就是8结点
        // 结点随着遍历而变化，因为当leftType==1时，说明该节点是按照线索化
        // 处理后的有效结点
        ThreadBinaryNode<T> node = root;
        while (node != null) {
            while (node.leftType == 0) {
                node = node.left;
            }

            System.out.println(node.data);

            // 如果当前结点的右指针指向的是后继节点，就一直输出
            while (node.rightType == 1) {
                // 获取到当前结点的后继节点
                node = node.right;
                System.out.println(node.data);
            }
            // 替换这个遍历的结点
            node = node.right;

        }

3.6 二叉树的应用

3.6.1 堆排序（见 2022.4.5 三、排序算法.md）

3.6.2 赫夫曼树

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

import com.gyh.sort.QuickSort2;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class HuffmanTree {

    public static void main(String[] args) {
        int arr[] = {13, 7, 8, 3, 29, 6, 1};
        Node node = new HuffmanTree().toTree(arr);
        System.out.println(new HuffmanTree().wpl(node, 0));

        // 先序遍历结果
        new HuffmanTree().preOrder(node);
    }

    public void preOrder(Node n) {
        if (n == null) {
            return;
        }
        System.out.println(n.value);
        preOrder(n.left);
        preOrder(n.right);
    }

    /**
     * 计算带权路径长度
     *
     * @param node 根结点
     * @param path 当前结点的路径长度
     * @return
     */
    public int wpl(Node node, int path) {
        if (node == null) {
            return 0;
        } 
        if (node.left == null && node.right == null) {
            return node.value * path; // 叶子结点的带权路径
        }
        return wpl(node.left, path + 1) + wpl(node.right, path + 1);
    }

    public Node toTree(int[] nums) {
        if (nums == null || nums.length <= 0) {
            return null;
        }

//        // 从小到大排序
//        new QuickSort2().sort(nums, true);
        // 从小到大排序并转换为结点
        List<Node> nodes = Arrays.stream(nums)
                .mapToObj(Node::new)
                .collect(Collectors.toList());

        // 作几轮
        while (nodes.size() > 1) {
            // 从小到大排序
            nodes.sort(Comparator.comparingInt(x -> x.value));

            Node node1 = nodes.get(0);
            Node node2 = nodes.get(1);
            Node node = new Node(node1.value + node2.value, node1, node2);

            // 将计算后的结点加入剩余的元素集合中
            nodes.remove(0);
            nodes.remove(0);
            nodes.add(node);
        }

        return nodes.get(0);

    }

}

class Node {
    int value;
    Node left;
    Node right;

    public Node(int value, Node left, Node right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public Node(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
}

3.6.3 赫夫曼编码

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.gyh.tree;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class HuffmanEncode {
    public static void main(String[] args) {
        String content = "i like like like java do you like a java";
        // 分别统计每个字符的频度
        String[] contentStr = content.split("");
        Map<String, Long> statistic = Stream.of(contentStr)
                .collect(Collectors.groupingBy(m -> m, Collectors.counting()));

        HuffmanEncode huffmanEncode = new HuffmanEncode();
        CodeNode root = huffmanEncode.createHuffmanTree(statistic);
        huffmanEncode.getCode(root);
    }

    public void getCode(CodeNode node) {
        getCode(node, "");
    }

    // 获取每个字符的霍夫曼编码（叶子结点作显示）
    private void getCode(CodeNode node, String prefix) {
        if (node == null) {
            return;
        }
        if (node.left == null && node.right == null) {
            System.out.println(node.data + "---->" + prefix);
            return;
        }

        getCode(node.left, prefix + "0");
        getCode(node.right, prefix + "1");
    }

    public CodeNode createHuffmanTree(Map<String, Long> statistic) {
        // 创建结点list
        List<CodeNode> nodes = statistic.entrySet().stream()
                .map(s -> new CodeNode(s.getKey(), s.getValue().intValue()))
                .collect(Collectors.toList());

        while (nodes.size() > 1) {
            // 从小到大排序
            nodes.sort(Comparator.comparingInt(x -> x.weight));
            CodeNode left = nodes.get(0);
            CodeNode right = nodes.get(1);
            CodeNode codeNode = new CodeNode(null, left.weight + right.weight, left, right);
            // 将新结点加入到集合中
            nodes.remove(0);
            nodes.remove(0);
            nodes.add(codeNode);
        }
        return nodes.get(0);

    }
}

class CodeNode {
    String data; // 存放数据本身
    int weight; // 权值，表示数据频度
    CodeNode left;
    CodeNode right;

    public CodeNode(String data, int weight, CodeNode left, CodeNode right) {
        this.data = data;
        this.weight = weight;
        this.left = left;
        this.right = right;
    }

    public CodeNode(String data, int weight) {
        this.data = data;
        this.weight = weight;
    }
}

3.6.4 二叉排序树（见：四、查找算法）

ModelBulider
关注
专栏目录
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
树和二叉树
12-03
6. 二叉树的线索化：线索化是将二叉树中的节点与其在某种遍历次序下的前驱和后继建立直接联系的过程，包括中序线索二叉树、前序线索二叉树和后序线索二叉树。 7. 树、森林与二叉树的转换：通过左孩子右兄弟表示法...
数据结构与算法：树和二叉树.pptx
05-11
二叉树的性质包括：第i层最多有2^(i-1)个结点，深度为k的二叉树最多有2^k-1个结点，以及满二叉树和完全二叉树的定义。 满二叉树是深度为k且具有2^k-1个结点的二叉树，所有非叶子结点都有两个子结点。完全二叉树在...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1389
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 757
JDK1.0主要特性。
Backend - Java 基础
是萝卜干呀的博客
10-11 439
知识量决定了未来能走多远
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1639
2024最新Java面试题，针对一些小厂，中厂
Spring Boot 整合 Minio
cmh1008611的博客
10-09 898
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
【含开题报告+文档+PPT+源码】基于SSM框架的线上交易商城的设计与实现
码蜂窝编程-全网唯一毕设在线答疑，项目包运行成功，全套教学视频一站式辅导机构。
10-07 737
本课程演示的是一款校园二手交易系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。包含：项目源码、项目文档、数据库脚本、软件工具等所有资料带你从零开始部署运行本套系统该项目附带的源码资料可作为毕设使用系统主要功能有：登录注册、公告管理、用户管理、商品管理、商品搜索、购物车、订单管理、用户私聊等模块。
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 570
【代码】springboot 用request.setAttribute 传值到控制层。
JavaScript前端开发技术
最新发布
Chujun123528的博客
10-12 716
JavaScript前端开发是一个充满挑战和机遇的领域。随着技术的不断进步和用户需求的变化，前端开发者需要不断学习新知识、掌握新技能，以应对日益复杂和多样化的开发需求。同时，注重性能优化和安全实践也是前端开发不可或缺的一部分。通过不断探索和创新，我们可以为用户创造更加优质、高效和安全的Web体验。在JavaScript前端开发的学习过程中，建议从基础语法入手，逐步掌握DOM操作、事件处理、Ajax通信等核心技能。同时，关注最新的前端框架和库的发展动态，尝试将它们应用到实际项目中。
Linux线程（十二）线程互斥锁-自旋锁与读写锁详解
Dola的博客
10-10 910
自旋锁与互斥锁很相似，从本质上说也是一把锁，在访问共享资源之前对自旋锁进行上锁，在访问完成后释放自旋锁（解锁）；事实上，从实现方式上来说，互斥锁是基于自旋锁来实现的，所以自旋锁相较于互斥锁更加底层。如果在获取自旋锁时，自旋锁处于未锁定状态，那么将立即获得锁（对自旋锁上锁）；如果在获取自旋锁时，自旋锁已经处于锁定状态了，那么获取锁操作将会在原地“自旋”，直到该自旋锁的持有者释放了锁。由此介绍可知，自旋锁与互斥锁相似，但是互斥锁在无法获取到锁时会让线程陷入阻塞等待状态；
python：PyPDF2 将多个图片转换为pdf，再合并成一个PDF文件
belldeep的专栏
10-05 707
python：from PyPDF2 import PdfMerger 将多个图片转换为pdf，再合并成一个PDF文件。
【hot100-java】二叉树展开为链表
m0_73629042的博客
10-10 353
过关斩将，easy！
在Windows 10上安装Java 17的步骤如下
S.Ybling
10-09 304
至此，Java 17已经成功安装并配置在Windows 10系统中。安装完成后，需要配置环境变量，以便在命令行中可以直接使用。
JavaScript的内置对象有哪些？
2301_81449444的博客
10-08 1344
sort() 是对数字数组的元素进行排序，返回值为修改后的数组，根据参数的不同来判断是进行升序排序还是降序排序，默认无参数时，排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列进行排序的，如果参数为“function(a,b){ return a-b;如果传入了参数，那么则按照参数来创建时间对象。其中new Array() 在没有参数时，创建的是一个空的数组对象，需要后续添加数组元素，但如果在创建数组时传入了一个参数，则参数代表数组的长度，如果传入了多个参数，则参数为数组元素。
JavaEE 多线程第一节 (进程 线程 并行 并发 概念及关系)
2301_80176774的博客
10-06 825
小白必看,一学就会
Java重修笔记 第六十一天 坦克大战（十一）IO 流 - 节点流和处理流、BufferedReader 和 BufferedWriter
Code___slave的博客
10-07 968
3. 处理流（包装流）对节点流进行包装，使用的是修饰器设计模式，通在处理流类中定义一个父类的 reader/writer ，调用相关方法来操作传入的对应子类，而包装流则不会与数据源直接相连。2. 处理流是经过包装过后的节点流，也叫包装流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。1. 修饰器模式强调的是增强自身，通过增强类的方法来调用原有类的方法，调用时不改变原有类的方法，只是。2. 代理模式通过实现目标类的接口实现静态或动态的代理，通过继承或实现原有类，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ModelBulider

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值