JAVA面试中常考的日编程写法

最新推荐文章于 2024-12-18 21:01:28 发布

原创最新推荐文章于 2024-12-18 21:01:28 发布 · 139 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

221 篇文章

订阅专栏

本文深入探讨了Java中的Lambda表达式应用，包括不同类型的参数处理与返回值操作。同时，详细介绍了线程的启动方式，从经典Runnable对象到线程池、Future和Callable的高级用法，以及单例模式和数据结构操作如链表反转和二叉树遍历的实现。

排名不分先后，都是一些无聊的东西

lamda表达式

() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

如何启动线程

经典的传入Runable对象的写法

new Thread(new Runnable() {
 
  @Override
  public void run() {
    // TODO Auto-generated method stub
    }
  }
).start();

继承Thread的写法

public class FirstThreadTest extends Thread {
    int i = 0;

    public FirstThreadTest(int i) {
        super();
        this.i = i;
    }
    public FirstThreadTest(ThreadGroup group, Runnable target, String name,
            long stackSize) {
        super(group, target, name, stackSize);
        // TODO Auto-generated constructor stub
    }

    // 重写run方法，run方法的方法体就是现场执行体
    public void run() {
        //当前线程: this
        System.out.println(this.getName() + "  " + i);
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        new FirstThreadTest(888).start();
    }
}

线程池/Future/Callable的用法

class TestExecutorService implements Runnable{
String name;
public TestExecutorService(String name){
    this.name=name;
}
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            System.out.println(this.name+":"+i);
        }
    }
}

ExecutorService pool = Executors.newFixedThreadPool(2);
        TestExecutorService tes1 = new TestExecutorService("E");
        TestExecutorService tes2 = new TestExecutorService("F");
        pool.execute(tes1);
        pool.execute(tes2);
        pool.shutdown();

public class Test {
     public static void main(String[] args) {   
         ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                 new ArrayBlockingQueue<Runnable>(5));
          
         for(int i=0;i<15;i++){
             MyTask myTask = new MyTask(i);
             executor.execute(myTask);
             System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
             executor.getQueue().size()+"，已执行完别的任务数目："+executor.getCompletedTaskCount());
         }
         executor.shutdown();
     }
}

单例模式

反转单链表

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode node = head.next;
        head.next = null;
        ListNode cur_begin = head;
         while(node != null){
             ListNode next  = node.next;
             node.next = cur_begin;
             cur_begin = node; 
             node = next;
         }
        return cur_begin;
    }
}

二叉树的后续非递归遍历

public List<Integer> postorderTraversal(TreeNode root) {//非递归写法
    List<Integer> res = new ArrayList<Integer>();
    if(root == null)
        return res;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode pre = null;
    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode curr = stack.peek();            
        if((curr.left == null && curr.right == null) ||
           (pre != null && (pre == curr.left || pre == curr.right))){ 
           				//当前节点出栈的条件
                        //1）当前结点左右子节点为空
                        //2）上一个访问的结点为当前结点的子节点时，当前结点出栈
            res.add(curr.val);
            pre = curr;
            stack.pop();
        }else{
            if(curr.right != null) stack.push(curr.right); //先将右结点压栈
            if(curr.left != null) stack.push(curr.left);   //再将左结点入栈
        }            
    }
    return res;        
}