Java非常规手写代码题

已于 2024-01-07 14:41:28 修改
阅读量270 收藏 1
点赞数
分类专栏： LeetCode 文章标签： java leetcode
于 2023-10-27 11:04:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mys_mys/article/details/134071993
版权

文章目录

1、写三种单例模式的实现方式

1、枚举

简单高效，无需加锁，线程安全，可以避免通过反射破坏枚举单例

public enum Singleton {
    INSTANCE;
    public void doSomething(String str) {
    	System.out.println(str);
     }
}

2、静态内部类

  • 当外部类 Singleton 被加载的时候，并不会创建静态内部类SingletonInner 的实例对象
  • 只有当调用getInstance() 方法时， SingletonInner 才会被加载，此时才会创建单例对象 INSTANCE
  • INSTANCE 的唯⼀性、创建过程的线程安全性，都由 JVM 来保证
  • 无需加锁，线程安全，并且支持延时加载
public class Singleton {
    // 私有化构造⽅法
    private Singleton() {
     }
    // 对外提供获取实例的公共⽅法
    public static Singleton getInstance() {
    	return SingletonInner.INSTANCE;
     }
    // 定义静态内部类
    private static class SingletonInner{
    	private final static Singleton INSTANCE = new Singleton();
     }
}

3、双重检验锁

public class Singleton {
    private volatile static Singleton uniqueInstance;
    // 私有化构造⽅法
    private Singleton() {}
    public static Singleton getUniqueInstance() {
        //先判断对象是否已经实例过，没有实例化过才进⼊加锁代码
        if (uniqueInstance == null) {
        //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                	uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

uniqueInstance = new Singleton(); 三步执行：

  1. 为 uniqueInstance 分配内存空间
  2. 初始化uniqueInstance
  3. 将uniqueInstance指向分配的内存地址

2、编号为 1-n 的循环报 1-3，报道 3 的出列，求最后一人的编号

约瑟夫环问题

  1. 要求出最后留下的那个⼈的编号
  2. 求全过程，即要算出每轮出局的人

公式： (f(n - 1, k) + k - 1) % n + 1

f(n,k) 表示 n 个人报数，每次报数报 到 k 的人出局，最终最后一个人的编号

public class Josephus {
    // 定义递归函数
    public static int f(int n, int k) {
        // 如果只有⼀个⼈，则返回 1
        if (n == 1) {
        	return 1;
        }
        return (f(n - 1, k) + k - 1) % n + 1;
        }
    public static void main(String[] args) {
        int n = 10;
        int k = 3;
        System.out.println("最后留下的那个⼈的编号是：" + f(n, k));
    }
}

3、写两个线程打印 1-n，⼀个线程打印奇数，⼀个线程打印偶数

  1. 线程的等待/通知机制（ wait() 和 notify() ）
  2. 信号量Semaphore
package com.mys.leetcode;

/**
 * @author mys
 * @date 2023/10/26 20:32
 */
public class ParityPrinter {
    private int max; // 总打印次数
    private int number = 1; // 打印次数
    private boolean odd; // 是否该打印奇数

    public ParityPrinter(int max) {
        this.max = max;
    }

    /**
     * 打印奇数
     */
    public synchronized void printOdd() {
        while (number < 100) {
            // 如果当前应该打印偶数，就等待
            while (odd) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println(Thread.currentThread().getName() + ":" + number);
            number ++;

            odd = true;
            notify(); // 唤醒另一个线程
        }
    }

    /**
     * 打印偶数
     */
    public synchronized void printEven() {
        while (number < 100) {
            // 如果当前应该打印偶数，就等待
            while (!odd) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println(Thread.currentThread().getName() + ":" + number);
            number ++;

            odd = false;
            notify(); // 唤醒另一个线程
        }
    }

    public static void main(String[] args) {
        ParityPrinter printer = new ParityPrinter(100);
        Thread t1 = new Thread(printer::printOdd);
        Thread t2 = new Thread(printer::printEven);
        t1.start();
        t2.start();
    }
}

Thread-0:1
Thread-1:2
Thread-0:3
Thread-1:4
Thread-0:5
Thread-1:6
Thread-0:7
Thread-1:8

4、LRU 缓存实现

LRU：最近最少使用

适用场景：频繁访问（缓存、页面置换）、有局部性、数据分布均匀、缓存容量适中

使用LinkedHashMap实现LRUCache

LinkedHashMap内部维护了双链表，增加了元素的顺序信息

removeEldestEntry：是否移除老数据

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private int capacity;
    public LRUCache(int capacity) {
        // LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
    // 当缓存元素个数超过容5时，移除最老的元素
        return size() > capacity;
    }

    public static void main(String[] args) {
        // 创建一个容量为3的LRU缓存
        LRUCache<Integer, String> lruCache = new LRUCache<>(3);
        // 添加数据
        lruCache.put(1, "one");
        lruCache.put(2, "two");
        lruCache.put(3, "three");
        // 此时缓存为：{1=One, 2=Two, 3=Three}
        System.out.println(lruCache);

        // 访问某个元素，使其成为最近访问元素
        String value = lruCache.get(2);
        // 此时缓存为：{1=One, 3=Three, 2=Two}
        System.out.println(lruCache);

        // 添加新数据，触发淘汰
        lruCache.put(4, "Four");
        // 此时缓存为：{3=Three, 2=Two, 4=Four}
        System.out.println(lruCache);
    }
}

{1=One, 2=Two, 3=Three}
{1=One, 3=Three, 2=Two}
{3=Three, 2=Two, 4=Four}

5、用Java 实现栈

public class Stack {
    private int[] arr;
    private int top;

    public Stack(int capacity) {
        arr = new int[capacity];
        top = -1;
    }

    public void push(int element) {
        if (top == arr.length - 1) {
            throw new IllegalStateException("栈已满");
        }
        top ++;
        arr[top] = element;
    }

    public int pop() {
        if (isEmpty()) {
            throw new IllegalStateException("栈为空");
        }
        int element = arr[top];
        top --;
        return element;
    }

    public int top() {
        if (isEmpty()) {
            throw new IllegalStateException("栈为空");
        }
        return arr[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public int size() {
        return top + 1;
    }
}

6、加权轮询算法的实现

加权轮询： 它通过给不同的服务器分配不同的权重来实现请求的均衡分发

  1. 为服务器分配初始权重，权重越高，可以处理更高的请求
  2. 新请求到达，负载均衡器选择权重最高的机器处理请求
  3. 处理之后，服务器权重减去一个设定好的值，减小权重
  4. 所有服务器权重为0，重新赋初值
class Server {
    private String name;
    private int weight;

    public Server(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public int getWeight() {
        return weight;
    }
}
public class WeightedRoundRobin {
    /*
    1. 为服务器分配初始权重，权重越高，可以处理更高的请求
    2. 新请求到达，负载均衡器选择权重最高的机器处理请求
    3. 处理之后，服务器权重减去一个设定好的值，减小权重
    4. 所有服务器权重为0，重新赋初值
     */

    private List<Server> servers;
    private int currentIndex;

    public WeightedRoundRobin(List<Server> servers) {
        this.servers = servers;
        currentIndex = 0;
    }

    // 根据服务器权重，选择下一个服务器
    public Server getNextServer() {
        int totalWeight = calculateTotalWeight(); // 所有服务器总权重
        int maxWeight = findMaxWeight(); // 所有服务器中的最大权重
        int gcd = calculateGCD(); // 所有权重的最大公约数
        // 根据最大权重遍历
        while (true) {
            currentIndex = (currentIndex + 1) % servers.size();
            if (currentIndex == 0) {
                maxWeight -= gcd;
                if (maxWeight <= 0) {
                    maxWeight = findMaxWeight();
                    if (maxWeight == 0) {
                        return null; // 所有服务器的权重都为0，无法分配请求
                    }
                }
            }
            if (servers.get(currentIndex).getWeight() >= maxWeight) {
                return servers.get(currentIndex);
            }
        }
    }

    // 计算所有服务器总权重
    private int calculateTotalWeight() {
        int totalWeight = 0;
        for (Server server : servers) {
            totalWeight += server.getWeight();
        }
        return totalWeight;
    }

    // 找到所有服务器中的最大权重
    private int findMaxWeight() {
        int maxWeight = 0;
        for (Server server : servers) {
            if (server.getWeight() > maxWeight) {
                maxWeight = server.getWeight();
            }
        }
        return maxWeight;
    }

    // 计算所有权重的最大公约数
    private int calculateGCD() {
        int weightsLength = servers.size();
        int[] weights = new int[weightsLength];
        for (int i = 0; i < weightsLength; i ++) {
            weights[i] = servers.get(i).getWeight();
        }
        return findGCD(weights, weightsLength);
    }

    // 找多个权值的最大公约数
    private int findGCD(int[] weights, int n) {
        int result = weights[0];
        for (int i = 0; i < n; i ++) {
            result = gcd(result, weights[i]);
        }
        return result;
    }

    // 计算两个数的最大公约数
    private int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    public static void main(String[] args) {
        List<Server> servers = new ArrayList<>();
        servers.add(new Server("Server1", 3));
        servers.add(new Server("Server2", 5));
        servers.add(new Server("Server3", 1));
        WeightedRoundRobin wrr = new WeightedRoundRobin(servers);
        // 模拟请求分发
        for (int i = 0; i < 10; i++) {
            Server server = wrr.getNextServer();
            System.out.println("Request " + (i + 1) + " sent to: " + server.getName());
        }
    }
}

7、手写死锁

定义、四个必要条件、避免死锁、银行家算法、安全状态

public class DeadLockDemo {
    private static Object resource1 = new Object();
    private static Object resource2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + " get resource1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + " wait resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + " get resource2");
                }
            }
        }, "线程1").start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + " get resource2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + " wait resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + " get resource1");
                }
            }
        }, "线程2").start();
    }
}

Thread[线程1,5,main] get resource1
Thread[线程2,5,main] get resource2
Thread[线程1,5,main] wait resource2
Thread[线程2,5,main] wait resource1

8、快速排序

  1. 确定分界点：q[l] q[(l+r)/2] q[r] 随机
  2. 调整范围：<x放左边，>x放右边
  3. 递归：处理左右两端

代码思想：两指针同时往中间走，若i指向的数<x,指针后移；若j指向的数>x，指针前移。完成之后指针指向的数swap，继续进行下一次循环

public void quickSort(int[] nums, int l, int r) {
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = nums[(l + r) / 2];
    while (i < j) {
        do i ++; while (nums[i] < x);
        do j --; while (nums[j] > x);
        if (i < j) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
    quickSort(nums, l, j);
    quickSort(nums, j + 1, r);
}

思想2：

  1. 从后往前走，找比x更小的数，放在low位置；
  2. 从前往后走，找比x更大的数，放在high位置
  3. 当low>=high，一轮循环结束，确定了x的位置，以x为中心，将数组分为左右两边，左右两边的数组继续循环

eg: 5 1 7 3 1 6 9 4 x=5

第一趟：4 1 1 3 5 6 9 7 确定了5；x1=4, x2=6

第二趟：3 1 1 4 5 6 9 7 确定了4，5，6；x1=3, x2=9

第三趟：1 1 3 4 5 6 7 9

9、生产者消费者

问题：如何确保⽣产者不会往满了的数据缓冲区继续添加数据，而消费者也不会从空的缓冲区取数据——引入⼀个共享的缓冲区

Procuder

public class Producer implements Runnable{
    private final BlockingQueue<Integer> queue;
    private final int MAX_SIZE = 5; // 缓冲区最大容量

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 1; i <= 10; i ++) {
                produce(i); // 生产
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void produce(int item) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == MAX_SIZE) {
                System.out.println("缓冲区已满，生产者等待");
                queue.wait(); // 冲区已满，生产者等待
            }
            queue.put(item); // 生产者放入缓冲区
            System.out.println("生产物品：" + item);
            queue.notifyAll(); // 唤醒所有等待的消费者
        }
    }
}

Comsumer

public class Consumer implements Runnable{
    private final BlockingQueue<Integer> queue;
    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                consume(); // 消费物品
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                System.out.println("缓冲区空，消费者等待");
                queue.wait(); // 缓冲区空，消费者等待
            }
            int item = queue.take(); // 从缓冲区取物品
            System.out.println("消费者消费：" + item);
            queue.notifyAll(); //  唤醒所有等待的生产者
        }
    }
}

Test

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);
        producerThread.start();
        consumerThread.start();
    }
}

生产物品：1
生产物品：2
生产物品：3
生产物品：4
生产物品：5
缓冲区已满，生产者等待
消费者消费：1
消费者消费：2
消费者消费：3
消费者消费：4
消费者消费：5
缓冲区空，消费者等待
qmys
关注
专栏目录
Java高级工程师面试题整理
喜欢猪猪
06-11 6571
面试题： HashMap底层实现原理，红黑树，B+树，B树的结构原理，volatile关键字，CAS（比较与交换）实现原理 Spring的AOP和IOC是什么？使用场景有哪些？Spring事务，事务的属性，传播行为，数据库隔离级别 Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringMVC的工作原理，SpringBoot框架的优点，MyBatis框架的优点 SpringCould组件有哪些，他们的作用是什么？（说七八个）微服务的CAP是什么？B.
字节跳动后台Java2020面试真题（含手写代码及设计题）
少侠露飞的学习笔记
08-10 1378
万万没想到，字节跳动面试官这样问我
Java手写简易数据库
最新发布
艺术的博客
03-16 1691
Java实现数据库
Java基础50道经典练习题（22年新版）
热门推荐
xiaoyu_alive的博客
03-11 6万+
Java的基础练习。
Java面试题大全
woaini886353的博客
04-25 1256
Java面试题大全 1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计
Java 最全面的面试题675道
ethan
01-21 2万+
2019年Java面试675道题     目录 java基础、语法    30 001_Java跨平台原理（字节码文件、虚拟机）    30 002_Java的安全性    31 003_Java三大版本    32 004_什么是JVM？什么是JDK？ 什么是JRE？    32 005_Java三种注释类型    34 006_8种基本数据类型及其字节数    35 007_ i++和++i的...
阿里巴巴Java面试题
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
01-07 6893
Java基础面试题(2022最新版汇总)
Java中级开发面试题
qq_35911118的博客
05-19 1781
面试题： HashMap底层实现原理，红黑树，B+树，B树的结构原理，volatile关键字，CAS（比较与交换）实现原理 Spring的AOP和IOC是什么？使用场景有哪些？Spring事务，事务的属性，传播行为，数据库隔离级别 Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringMVC的工作原理，SpringBoot框架的优点，MyBatis框架的优点 SpringCould组件有哪些，他们的作用是什么？（说七八个）微服务的CAP是什么？BASE是什么？
JAVA开发面试题
coolcooldeteng的博客
09-01 1018
一些java开发面试题,供大家参考
29个要点帮你完成java代码优化
09-03
27. 使用`Arrays.copyOf()`替代手写的数组复制代码，以利用内置的优化。 28. 考虑使用Java 8的流API进行并行处理，充分利用多核处理器。 29. 性能测试和分析：使用工具如JProfiler或VisualVM监控和定位性能瓶颈。 ...
java面试突击（100题）进大厂就这么简单
ZHAOHUODIAN888的博客
08-25 378
这道题目一般出现在（笔试-选择题）举例说明即可：向上转型：Person person = new Student();安全的向下转型：Teacher teacher = (Teacher)person;不安全的。
各大厂800道Java后端经典面试题合集
weixin_70730532的博客
08-30 1948
另外，面试题答案的话，可以私信我， 希望大家都能找到自己理想的offer呀。
800道Java后端经典面试题，希望你找到自己理想的Offer呀~
m0_67322837的博客
06-15 5435
Java 基础 equals与==的区别 final, finally, finalize 的区别 重载和重写的区别 两个对象的hashCode()相同，则 equals()是否也一定为 true？ 抽象类和接口有什么区别 BIO、NIO、AIO 有什么区别？ String，Stringbuffer，StringBuilder的区别 JAVA中的几种基本数据类型是什么，各自占用多少字节呢 Comparator与Comparable有什么区别？ String类能被继承吗，为什么。 说说Java中多态的实现原理
二分法查找
倩mys的博客
08-10 3356
二分查找：思路很简单，细节是魔鬼！ “传统的”二分查找法模板的问题 （1）取中位数索引的代码有问题 int mid = (left + right) / 2 在 left 和 right 都比较大的时候，left + right 很有可能超过 int 类型能表示的最大值，即整型溢出，为了避免这个问题，应该写成： int mid = left + (right - left) / 2 ; or ...
回溯算法总结
倩mys的博客
03-02 1389
回溯算法leetcode题目
leetcode面试题之二叉树
倩mys的博客
04-21 862
01 二叉树层次遍历 p102 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val) * this.left = (left===undefined ? null : left) * this.right = (right===undefined ? null : right) * }
剑指Offer(一)
倩mys的博客
12-27 599
文章目录1、[剑指 Offer 09. 用两个栈实现队列](https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/)2、[剑指 Offer 30. 包含min函数的栈](https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof/)3、[剑指 Offer 06. 从尾到头打印链表](https://leetcode-cn.com/problems
Java手写CCF试题解析：稀疏向量错误与改进
此外，代码还引入了`HashMap`来存储稀疏向量，利用哈希表的高效查找特性，只存储非零元素及其对应的值，进一步优化了空间复杂度。 在`Reader`类中，使用`StringTokenizer`处理输入的字符串，将其分割成多个字段，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值