Java面试题一

最新推荐文章于 2021-02-26 11:40:26 发布
最新推荐文章于 2021-02-26 11:40:26 发布
阅读量185 收藏
点赞数
分类专栏： Java面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32447005/article/details/78056882
版权

1.    Java实现一个高逼格的冒泡排序

把这个数组从小到大的排列

import java.util.Comparator;

/**
 * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)
 */
public interfaceSorter {
    /**
     * 排序
     *
     * @param list 待排序的数组
     */
    public <T extends Comparable<T>> void sort(T[] list);

    /**
     * 排序
     *
     * @param list 待排序的数组
     * @param comp 比较两个对象的比较器
     */
    public <T> void sort(T[] list, Comparator<T> comp);
}

 

import java.util.Comparator;

public class BubbleSorter implements Sorter {

    @Override
    public <T extends Comparable<T>> void sort(T[] list) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (list[j].compareTo(list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
    @Override
    public <T> void sort(T[] list, Comparator<T> comp) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (comp.compare(list[j], list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
}
  }
}

2.    Java实现一个高逼格的二分法查找

折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组已经为空，则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一半，其时间复杂度是O(logN)。

说明：下面的代码中给出了折半查找的两个版本，一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2的方式，因为加法运算可能导致整数越界，这里应该使用以下三种方式之一：low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1（>>>是逻辑右移，是不带符号位的右移

import java.util.Comparator;
public class BinarySearch {

    public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
        return binarySearch(x, 0, x.length - 1, key);
    }

    // 使用循环实现的二分查找
    public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
        int low = 0;
        int high = x.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int cmp = comp.compare(x[mid], key);
            if (cmp < 0) {
                low = mid + 1;
            } else if (cmp > 0) {
                high = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    // 使用递归实现的二分查找
    private static <T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
        if (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (key.compareTo(x[mid]) == 0) {
                return mid;
            } else if (key.compareTo(x[mid]) < 0) {
                return binarySearch(x, low, mid - 1, key);
            } else {
                return binarySearch(x, mid + 1, high, key);
            }
        }
        return -1;
    }
}

 

3.死锁

/*
    死锁
*/
public class DeadLock {
    public static void main(String[] args) {

        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new Thread(new T1(o1, o2));
        Thread t2 = new Thread(new T2(o1, o2));

        t1.start();
        t2.start();

    }
}

class T1 implements Runnable {
    Object o1;
    Object o2;

    T1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    @Override
    public void run() {
        synchronized (o1) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
            synchronized (o2) {

            }
        }
    }
}

class T2 implements Runnable {
    Object o1;
    Object o2;

    T2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
            synchronized (o1) {

            }
        }
    }
}

3. 阐述Spring框架中Bean的生命周期？ 

1.  Spring IoC容器找到关于Bean定义，调用无参构造器，创建实例对象。

2.  调用参数setter方法，为属性注入值。

3.  如果Bean实现了BeanNameAware接口，则会执行此接口的setBeanName（String beanId）将获取容器中改bean的id名称。

4.  如果实现了BeanFactoryAware接口，则会执行setBeanFactory（BeanFactory factory）,使bean类获取到BeanFactory对象。

5.  如果定义并注册了BeanPostProcessor，则调用其postProcessorBeforeInitialization()方法.

6.  如果Bean实现了InitializaingBean接口，则执行接口方法afterPropertiesSet（）。该方法在Bean所有属性set方法执行完毕之后执行，是Bean初始化结束标志，即Bean实例化结束。

7.  如果设置了init-method方法，则执行。

8.  如果定义注册了Bean后处理器BeanPostProcessor，则执行postProcessAfterInitialization（）方法。

9.  执行业务方法。

10.当销毁Bean实例时，如果Bean实现了DisposableBean接口，则调用destroy（）方法。

11.如果设置destroy-method方法，则执行。

 

4. 依赖注入是如何注入集合属性？

可以在定义Bean属性时，通过<list> / <set> /<map> / <props>分别为其注入列表、集合、映射和键值都是字符串的映射属性。

5、如何在web项目中配置Spring的IoC容器？

如果需要在Web项目中使用Spring的IoC容器，可以在Web项目配置文件web.xml中做出如下配置：

<context-param>
    <param-name>contextConfigLocation</param-name>
   <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<listener>
    <listener-class>
       org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

5. 如何在Web项目中配置Spring MVC?

要使用SpringMVC需要在Web项目配置文件中配置其前端控制器DispaterServlet，如下所示：

<web-app>

   <servlet>
       <servlet-name>example</servlet-name>
        <servlet-class>
           org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
       <load-on-startup>1</load-on-startup>
    </servlet>

   <servlet-mapping>
       <servlet-name>example</servlet-name>
       <url-pattern>*.html</url-pattern>
    </servlet-mapping>

</web-app>

6、如何在Spring IoC中配置数据源？

DBCP配置：

<beanid="dataSource"
       class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
    <property name="driverClassName"value="${jdbc.driverClassName}"/>
    <property name="url"value="${jdbc.url}"/>
    <property name="username"value="${jdbc.username}"/>
    <property name="password"value="${jdbc.password}"/>
</bean>
<context:property-placeholder location="jdbc.properties"/>

 

C3P0配置：

<beanid="dataSource"
       class="com.mchange.v2.c3p0.ComboPooledDataSource"
 destroy-method="close">
    <property name="driverClass"value="${jdbc.driverClassName}"/>
    <property name="jdbcUrl"value="${jdbc.url}"/>
    <property name="user"value="${jdbc.username}"/>
    <property name="password"value="${jdbc.password}"/>
</bean>

<context:property-placeholderlocation="jdbc.properties"/>

7、Spring中如何使用注解来配置Bean？有哪些相关的注解？

   首先需要在Spring配置文件中增加如下配置：

<context:component-scan base-package="org.example"/>

然后可以用@Component、@Controller、@Service、@Repository注解来标注需要由Spring IoC容器进行对象托管的类。这几个注解没有本质区别，只不过@Controller通常用于控制器，@Service通常用于业务逻辑类，@Repository通常用于仓库类（例如DAO实现类），普通类用@Component来标注。

8、Spring IoC容器配置Bean的方式？

- 基于XML文件进行配置。

- 基于注解进行配置。

- 基于Java程序进行配置（Spring 3+）

9、选择使用Spring框架的原因（Spring框架为企业级开发带来的好处有哪些）？

可以从以下几个方面作答： 
- 非侵入式：支持基于POJO的编程模式，不强制性的要求实现Spring框架中的接口或继承Spring框架中的类。 
- IoC容器：IoC容器帮助应用程序管理对象以及对象之间的依赖关系，对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码，因为代码的修改可能意味着项目的重新构建和完整的回归测试。有了IoC容器，程序员再也不需要自己编写工厂、单例，这一点特别符合Spring的精神"不要重复的发明轮子"。 
- AOP（面向切面编程）：将所有的横切关注功能封装到切面（aspect）中，通过配置的方式将横切关注功能动态添加到目标代码上，进一步实现了业务逻辑和系统服务之间的分离。另一方面，有了AOP程序员可以省去很多自己写代理类的工作。 
- MVC：Spring的MVC框架是非常优秀的，从各个方面都可以甩Struts 2几条街，为Web表示层提供了更好的解决方案。 
- 事务管理：Spring以宽广的胸怀接纳多种持久层技术，并且为其提供了声明式的事务管理，在不需要任何一行代码的情况下就能够完成事务管理。 
- 其他：选择Spring框架的原因还远不止于此，Spring为Java企业级开发提供了一站式选择，你可以在需要的时候使用它的部分和全部，更重要的是，你甚至可以在感觉不到Spring存在的情况下，在你的项目中使用Spring提供的各种优秀的功能。 

10、如何配置配置事务增强？ 

<?xmlversion="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
     http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx.xsd
     http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

 <!-- this is the service object that we want to make transactional -->
  <bean id="fooService"class="x.y.service.DefaultFooService"/>

 <!-- the transactional advice -->
  <tx:advice id="txAdvice"transaction-manager="txManager">
  <!-- the transactional semantics... -->
  <tx:attributes>
    <!-- all methods starting with 'get' are read-only -->
    <tx:method name="get*"read-only="true"/>
    <!-- other methods use the default transaction settings(see below) -->
    <tx:method name="*"/>
  </tx:attributes>
  </tx:advice>
  <!-- ensure that the above transactional
     advice runs for any execution
    of an operation defined by the
    FooService interface -->
  <aop:config>
  <aop:pointcut id="fooServiceOperation" 
    expression="execution(*x.y.service.FooService.*(..))"/>
  <aop:advisor advice-ref="txAdvice"
     pointcut-ref="fooServiceOperation"/>
  </aop:config>

 <!-- don't forget the DataSource -->
  <bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource" 
    destroy-method="close">
  <property name="driverClassName"
     value="oracle.jdbc.driver.OracleDriver"/>
  <property name="url"
    value="jdbc:oracle:thin:@localhost:1521:orcl"/>
  <property name="username" value="scott"/>
  <property name="password" value="tiger"/>
  </bean>

 <!-- similarly, don't forget the PlatformTransactionManager -->
  <bean id="txManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
  </bean>

 <!-- other <bean/> definitions here -->

</beans>

lifeflower241
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面试题以及答案整理.pdf
05-11
为了在Java面试中脱颖而出，了解和掌握常见的面试题及答案至关重要。以下是一些关键知识点的详细解析： 1. **super()与 this()的区别** `super()`用于调用父类的构造器，确保子类实例化时父类的初始化；`this()`则...
Java面试题集（136-150）
热门推荐
骆昊的技术专栏
01-01 1万+
这一部分主要是数据结构和算法相关的面试题目，虽然只有15道题目，但是包含的信息量还是很大的，很多题目背后的解题思路和算法是非常值得玩味的。
Java常见算法之二分法查找算法详解
weixiaohuai的博客
10-19 7740
一、简介 二分法查找，是在已经排好序的序列中，定义一个起始位置start(即序列第一个元素)和一个终止位置end(即序列最后一个元素),通过mid=(start+end)/2计算出中间位置，通过待查找元素与mid中间位置的元素进行比较，如果待查找元素比中间位置mid对应的值小，那么将end = mid -1(即将end结束位置移动到mid中间左边一个位置),如果比中间对应的值大，那么将start...
Java 编程下的二分法查找
weixin_33980459的博客
02-13 1470
算法：当数据量很大适宜采用该方法。采用二分法查找时，数据需是有序不重复的。 基本思想：假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止。 假设有一个数组 { 12, 23, 34, 45, 56, 67, 77, 89, 90 }，现...
Java 面试题总结
zjf1665119803的博客
12-27 1060
1、int和Integer有什么区别？ 答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。 Java 为每个原始类型提供了包装类型： ...
java面试（编程）题（二分法、笛卡尔积、裴波拉契、死锁）
weixin_39115437的博客
07-31 640
一、使用二分法查找元素 public int getPos(vector&lt;int&gt; A, int n, int val) {         if(A.size()==0 || n == 0)//异常处理             return -1;         int left = 0, right = n-1, mid = 0;         while(left &lt;...
java笔试题1.txt
最新发布
01-25
java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1java笔试题1
Java面试笔试题大汇总(最全+详细答案)
03-15
Java面试笔试题大汇总(最全+详细答案)
java面试资料java面试题集java笔试题汇总资料
02-13
java面试资料java面试题集java笔试题汇总资料，java面试资料java面试题集java笔试题汇总资料，java面试资料java面试题集java笔试题汇总资料，包括基础面试题、JavaWeb面试题、JAVA面试题集.txt、分布式相关面试题...
java面试（上）
10-30 48
http://blog.csdn.net/jackfrued/article/details/44921941 1、面向对象的特征有哪些方面？答：面向对象的特征主要有以下几个方面：- 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。- 继承：继承是从已有类得到继承信息创建新类的过程。...
java中的 二分查找
singleton_zw
03-04 477
java中的 二分查找
面试准备（五）二分法查找
huotong
06-25 311
二分法查找 二分法是当数据量很大时适宜采用，但是采用二分法的前提是，数据是有序不重复的。二分法又称折半查找，故名思意就是就是从中间开始比较查找，其基本思路是：假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止。所以二分法查找的速度比较快,...
二分法查找java代碼_今天的面试题-二分法查找-java
weixin_39823269的博客
02-26 72
1.[代码]二分法查找/** To change this license header, choose License Headers in Project Properties.* To change this template file, choose Tools | Templates* and open the template in the editor.*/package conso...
Java面试题七
lifeflower
09-21 2942
60、SpringMVC工作原理 SpringMVC的工作原理图： SpringMVC流程 1、  用户发送请求至前端控制器DispatcherServlet。 2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3、  处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回
java面试题六
lifeflower
09-21 1292
51、 什么时候使用字节流、什么时候使用字符流，二者的区别 在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。 InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象, Reader和Writer.两个是为字符流（一个字符占两个字节）设计的
Java面试题二
lifeflower
09-21 262
11、如何正确终止一个线程？ /**  * 如何正确的更好的终止一个正在执行的线程.  * 需求：线程启动5S之后终止。  */ public class ThreadTest09 {     public static void main(String[] args) throws Exception {         Processor p = new Processor();      
Java面试题五
lifeflower
09-21 254
41、Mybatis都有哪些Executor执行器？它们之间的区别是什么？ Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。 SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。 ReuseExecutor：执行upda
Java面试题四
lifeflower
09-21 242
31、编写多线程程序有几种实现方式？ 有三种：                (1)继承Thread类，重写run函数                                创建：                                class xx extends Thread{                                  public void run
达内Java笔试面试题解析
“达内最新笔试面试题，包含Java SE部分的题目，涉及标识符的有效性、代码编译、类与接口的关系以及程序执行结果预测。” 本文将深入解析这些Java编程相关的笔试面试题，帮助理解Java语言的基础知识和关键概念。 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值