你好,我是方向盘(YourBatman、方哥)
此博文旨在搜集一些JavaSE基础部分的经典面试题,希望能达到一针见血,通过面试题来达到让大家记忆深刻的目的。
持续连载中。。。
public static void main(String[] args) throws Exception {
List<Integer> list = new ArrayList<>();
list.add(1);
//请在此处补全代码
System.out.println(list); //期望输出为:[1, a, 2, b]
}
输出内容eg:
java.lang.Number
java.lang.Integer
等类似的
public static void main(String[] args) throws NoSuchFieldException {
Field id = Son.class.getField("id");
System.out.println(id.getType());
}
class Son extends BaseEntity<Integer> {
public String name;
}
class BaseEntity<PK extends Number> {
public PK id;
}
public static void main(String[] args) throws NoSuchFieldException {
Field id = Son.class.getField("id");
System.out.println(id.getType());
}
class Son extends BaseEntity<Integer> {
public String id;
public String name;
}
class BaseEntity<PK extends Number> {
public PK id;
}
略
答:属性的default默认值都不是必须的。若不指定默认值,使用该注解时每个属性都必填,所以一般建议给默认值
**只有你的属性叫“value()”,并且使用时只给他一个赋值的时候是可以省略的~~~**
,其余情况均不能省略
它支持的类型;
可以的。
// 代码方法内部定义的变量互不干扰,有很好的隔离效果
public void fun1() {
{
String s = "demo";
// 代码块一
}
{
//System.out.println(s); // 此处不能引入变量s
// 代码块二
}
}
要点:答出重写HashCode不能改变==是至少的要求
下面编译报错吗?不抱错会输出什么呢?
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
System.out.println(map.put("a","a"));
System.out.println(map.putIfAbsent("b","b"));
System.out.println(map.putIfAbsent("b","b"));
}
略
public static void main(String[] args) {
PrintStream out = System.out;
out.println("我");
out.close();
out.println("爱");
out.println("中");
out.println("国");
}
请问上述会输出什么?
那为什么我们平时不需要自己手动去关闭呢?请回答
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
System.out.println(map.put("a","a"));
System.out.println(map.putIfAbsent("b","b"));
System.out.println(map.putIfAbsent("b","c"));
//put的用法
System.out.println(map.put("c","c"));
System.out.println(map.put("d","d"));
System.out.println(map.put("c","d"));
}
void.class == Void.class
是true还是false答案:false
public static void main(String[] args) {
System.out.println(void.class); // void
System.out.println(Void.class); // class java.lang.Void
}
同样的int.class == Integer.class
都是false的~
public static void main(String[] args) {
Boolean b = null;
System.out.println(b == Boolean.TRUE); //false 此处不报错
System.out.println(b == true); //java.lang.NullPointerException
}
public static void main(String[] args) {
Boolean b = new Boolean(true);
System.out.println(b == new Boolean(true)); //false
System.out.println(b == Boolean.TRUE); //false
System.out.println(b == Boolean.TRUE.booleanValue()); //true
System.out.println(b == true); //true
}
比如上面的例子。如果是包装类型,千万不要简单的用if(b == true)来判断
说出下面两题的答案:
public static void main(String[] args) throws InterruptedException {
int i = 1;
System.out.println((i++) - (++i));
i=5;
System.out.println((++i)+(++i)+(++i));
}
答案:-2 21
原因(第一题为例):第一个i++是先用i的值,所以表达式取值1,最后i的值变为了2。到第二个++i时,表达式取值为3了。所以最终为1-3 = -2
使用javap -c -l Main.class可以查看字节码最终执行的指令,一目了然
(1)依赖管理,节省空间
(2)一键构建 编码 编译 测试(junit) 运行 打包 部署
(3)应用于大型项目 可以提高开发效率
编译 测试 运行 打包
compile(struts2-core) 要 要 要 要
provided(jsp-api.jar) 要 要 不要 不要
runtime(数据库驱动包) 不要 要 要 要
test(junit.jar) 不要 要 不要 不要
在maven的依赖管理中,有两种方式可以对依赖关系进行,分别是可选依赖(Optional Dependencies)以及依赖排除(Dependency Exclusions)
Clean 清理编译的文件
Compile 编译了主目录的文件
Test 编译并运行了test目录的代码
Package 打包
Install 就是把项目发布到本地仓库
deploy 发布到私服
Tomcat:run 一键启动
Gruop Id
Artifact Id
Version
1、路径最短原则
2、**优先声明原则:**当出现路径长短相同的时候,谁先声明就用谁。如F1和F2的路径距离相同,但是由于F1比F2先声明(B比C先声明),所以最终使用F1。
优先声明的解释:如果你是在自己的pom里书写(并不是间接依赖进来的),那么下面的版本号是会覆盖上面的
怎么解释最近依赖原则?怎么解释同路径长度的依赖呢?
src/main/java
的xml、properties等文件这里面我推荐这篇文章来解答:maven资源文件的相关配置
<!--
directory:属性指定资源文件放置的目录。
includes:包含哪些配置文件(.class文件不用写)
filtering:如果设置为false的话,则表示上文的filters配置失效;如果设置为true,则会根据${env}.properties里面的键值对来
填充includes指定文件里的${xxxx}占位符(若不做环境区分,一般就是false即可)
-->
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
<include>**/*.tld</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
<include>**/*.tld</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
maven的scope决定依赖的包是否加入本工程的classpath
下,下面一幅图就能看懂
optional与scope区别在于:仅限制依赖包的传递性,不影响依赖包的classpath
比如如下例子:A->B, B->C(scope:compile, optional:true)
B的编译/运行/测试classpath都有C,所以非常良好木有问题
但是,A因为是间接依赖的C,但是因为c上有optional:true
,所以A中的编译/运行/测试classpath都是不会有C的。(尽管C是compile),可见optional
的优先级比scope高
optional:true
的功能特别像scope:provided
,所以姑且可以认为他俩没有太大的区别~
public static void main(String[] args) {
System.out.println("================普通for循环:");
for (int i = 0; i < getData().size(); i++) {
System.out.println(i);
}
System.out.println("================增强for循环:");
for (Integer i : getData()) {
System.out.println(i);
}
System.out.println("================Java8提供的foreach循环:");
getData().forEach(System.out::println);
}
private static List<Integer> getData() {
System.out.println("getDate被调用...");
var list = new ArrayList<Integer>();
list.add(10);
list.add(20);
list.add(30);
return list;
}
原因剖析,可参见另外一篇博文:【小家java】剖析for、while、foreach、标签循环语句的控制( break,continue,return )
public static void main(String[] args) {
//若我们得到的都只有Class类对象 可以这么判断
Class<Number> numberClass = Number.class;
Class<Long> longClass = Long.class;
boolean assignableFrom = numberClass.isAssignableFrom(longClass); //longClass是否归属于numberClass
System.out.println(assignableFrom); //true 说明long是number的子类
//进而可以各种强转
Class<? extends Number> aClass = longClass.asSubclass(numberClass);
System.out.println(aClass); //class java.lang.Long 若没报错 说明转换完成
//如果你是两个实例
Long lon = new Long(100);
boolean b = lon instanceof Number;
System.out.println(b); //true
//转换
Number cast = Number.class.cast(lon);
//lon.getClass().cast(Number.class); //这是错误写法
System.out.println(cast); //100
}
数据元素相互之间的关系称为结构。有四类基本结构:集合、线性结构、树形结构、图状结构;Java中有几种常用的数据结构,主要分为Collection和Map两个主要接口,而程序中最终使用的数据结构是继承自这些接口的数据结构类
数组、链表、红黑树、哈希表等
如果两个输入串的hash函数的值一样,则称这两个串是一个碰撞(Collision)。既然是把任意长度的字符串变成固定长度的字符串,所以必有一个输出串对应无穷多个输入串,碰撞是必然存在的。
通常有两类方法处理碰撞:开放寻址(Open Addressing)法和链接(Chaining)法。前者是将所有结点均存放在散列表T0…m-1中;后者通常是把散列到同一槽中的所有元素放在一个链表中,而将此链表的头指针放在散列表T0…m-1中。显然HashMap采用链表法
(据研究,在网络环境好的情况下,发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下,两次包的TCP在验证数据包完整性上,有非常大的优点。)
mysql-cluster配置管理节点、数据节点
集群主要分成三大类( 高可用集群, 负载均衡集群,科学计算集群)
集群是个物理形态,分布式是个工作方式。
1、只要是一堆机器,就可以叫集群,他们是不是一起协作着干活,这个谁也不知道;一个程序或系统,只要运行在不同的机器上,就可以叫分布式
2、集群可能运行着一个或多个分布式系统,也可能根本没有运行分布式系统;分布式系统可能运行在一个集群上,也可能运行在不属于一个集群的多台(2台也算多台)机器上。
3、分布式是相对中心化而来,强调的是任务在多个物理隔离的节点上进行。中心化带来的主要问题是可靠性,若中心节点宕机则整个系统不可用,分布式除了解决部分中心化问题,也倾向于分散负载,但分布式会带来很多的其他问题,最主要的就是一致性。
4、分布式:一个业务分拆多个子业务,部署在不同的服务器上(集群是解决高可用的)
5、集群:同一个业务,部署在多个服务器上(分布式是解决高性能、高并发的)
有界、无界队列对ThreadPoolExcutor执行的影响
通过面试题来看,可以看出目前互联网公司面试考点为: 1.性能调优、算法数据机构 2.高并发下数据安全、接口冪等性、原子性等 3.分布式下协同、已经锁的处理 4.数据库的分库分表、项目之间的垂直拆分 出现频率高的技术点有: 1.HashMap 2.JVM 3.Dubbo 4.Mybatis 5.Zookeeper 6.http tcp/ip
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<Integer> submit = executorService.submit(() -> {
System.out.println("子线程开始执行...");
return 10;
});
//TimeUnit.SECONDS.sleep(1);
System.out.println(submit);
}
输出:
java.util.concurrent.FutureTask@76fb509a
子线程开始执行...
原因:系统创建一个子线程是需要时间开销的,所以肯定主线程先打印了
-----------------------------------------------------
取消掉注释语句,输出:
开始执行...
java.util.concurrent.FutureTask@76fb509a
原因:创建子线程虽有时间开销,但不可能有1s之久
-----------------------------------------------------
注释加上,但把最后一句输出改为:System.out.println(submit.get()); 输出:
开始执行...
10
原因:get()方法是阻塞的,因此肯定得子线程完全结束后,才会继续主线程
1、forloop
2、多线程
3、线程池
4、ForkJoin
5、并行流
byte 1字节
short 2字节
int 4字节
long 8字节
char 2字节(C语言中是1字节)可以存储一个汉字
float 4字节
double 8字节
boolean false/true(理论上占用1bit,1/8字节,实际处理按1byte处理)
JAVA是采用Unicode编码。每一个字节占8位。你电脑系统应该是 32位系统,这样每个int就是 4个字节 其中一个字节由8个二进制位组成
返回null的情况有两种,请分别说出
怎么证明int是32位的? Long的十进制最多多少位呢?(正数19位,负数20位,因为符号也是个字符)
贴源码,一切尽在不言中
// intValue 返回的是基本数据类型
public int intValue() {
return value;
}
public long longValue() {
return (long)value;
}
public double doubleValue() {
return (double)value;
}
//valueOf 返回的包装类型 我们发现valueOf方法是有缓存的,因此效率高。如果需要转化的是字符串,会先调用parseInt方法
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
//parseInt 返回的int类型
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
public static int parseInt(String s, int radix)
throws NumberFormatException
{"较为复杂的代码"}
valueof调用了parseInt方法的,底层有依赖
因此如果只是想把字符串变为数字这么简单,那parseInt效率比valueof效率高
Integer a=new Integer(1);
Integer a=Integer.valueOf(1);
两个都是得到一个Integer对象,但是Integer.valueOf的效率高,开销更小。
要求流水号有规律,但是又不能完全有规律,且应该包含一些有用信息,且要求效率高
问题:有一串数字5937594375973495743,怎么样可以快速的萃取出最后面指定位数的数字?请书写一个函数实现。(提示:使用按位与 & 的语法)
String a = "计算机" + "软件"; 这句话常量池里会放几个
答案:由于JVM存在编译期优化,对于两个直接双引号声明的String的+操作,JVM在编译期会直接优化为“计算机软件”一个字符串。同String a = “计算机软件”,效果是一样的。
参考例子:java7,8中的String pool
字面量是会直接放在String pool中的,其他的你可以通过intern自己放入
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
//方式一:只能转换为Object[]数组 请注意使用
String[] array= (String[]) list.toArray(); //java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
//方式二
Integer[] ints = list.toArray(new Integer[0]); //这里面写0还是写几效果是一样的
//方式三 这种写法也是ok的
Integer[] ints = new Integer[][list.size()];
list.toArray(ints);
System.out.println(ints);
//方式四:这种错误很隐蔽 请类型方便千万不要搞错了
Long[] longs = list.toArray(new Long[0]);
System.out.println(longs); //Exception in thread "main" java.lang.ArrayStoreException
//方式五:如果你用Object接受,就肯定不会有问题了。同toArray()方法
Object[] objects = list.toArray(new Object[0]);
System.out.println(objects);
//方式六:其余自己循环遍历的方式 此处省略
1、User和Daemon两者几乎没有区别,唯一的不同之处就在于虚拟机的离开(但凡只要还有一个User线程在运行,守护线程就不会退出)
2、daemonThread.setDaemon(true); (必须在start()方法调用之前执行这句话,否则会跑出一个IllegalThreadStateException异常)
3、在Daemon线程中产生新的线程也是守护线程
如你可以线程池中自定义ThreadFactory,然后t.setDaemon(true);那么线程池中所有的线程都是守护线程了。也就不用显示调用pool.shutdown();才能关闭线程池了,自己就会结束了
4、不要认为所有的应用都可以分配给Daemon来进行服务,比如读写操作或者计算逻辑(因为这样的话,主线程在推出之前,无法知道守护线程是否已经完成读写任务)
守护线程–也称“服务线程”,在没有用户线程可服务时会自动离开。
方法 值
getName my.ExternalClassConfig
getCanonicalName my.ExternalClassConfig
getSimpleName ExternalClassConfig
getName my.ExternalClassConfig$InternalConfig
getCanonicalName my.ExternalClassConfig.InternalConfig
getSimpleName InternalConfig
getName()返回的是虚拟机里面的class的表示,而getCanonicalName()返回的是更容易理解的表示。其实对于大部分class来说这两个方法没有什么不同的。但是对于array或内部类来说是有区别的。
方法 值
getName [Ljava.lang.String;
getCanonicalName java.lang.String[]
getSimpleName String[]
答案:
Map.Entry<String, String> next = map.entrySet().iterator().next();
这里面主要考的是JavaEE的基本功眨不扎实,能不能运用自如
Array.newInstance
。。。Integer[] integers = (Integer[]) Array.newInstance(Integer.class, 10);
System.out.println(integers.length); // 10
如下例子什么结果?
public static void main(String[] args) {
// 备注:若Child类没有重写equals方法,结果是怎样的?
Child child1 = new Child();
Child child2 = new Child();
System.out.println(child1 == child2); // false
System.out.println(child1.equals(child2)); // false
}
//由此可以看出,假若你没有重写hashCode()方法,equals比较也会是false的
System.exit(int)
已退出程序。 exit是带参函数 ;若该语句在异常语句之后,finally会执行关于try finally返回值问题:
如果try语句里有return,返回的是try语句块中变量值。 详细执行过程如下:
所以如下返回结果,一目了然吧:
public static void main(String[] args) {
System.out.println(fun()); //2 最终返回的是finally里的值,这点需要注意 try里面是不会被返回的
}
private static String fun() {
try {
return "1";
} finally {
return "2";
}
}
class Parent {
// 不给无参构造
public Parent(String a) {
}
}
class Son extends Parent {
public Son() {
}
public Son(String s) {
}
}
报错吗?
答案:编译报错
Java 程序在执行子类的构造方法之前,如果没有用 super() 来调用父类特定的构造方法,则会调用父类中**“没有参数的构造方法”
。因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法,则编译时将发生错误,**
因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法,,所以上面可以两种方法解决编译报错:
1、给Parent一个空构造
2、显示调用父类无参构造
class Son extends Parent {
public Son() {
super("a");
}
public Son(String s) {
super(s);
}
}
1 形式上: 字符常量是单引号
引起的一个字符 字符串常量是双引号
引起的若干个字符
2 含义上: 字符常量相当于一个**整形值( ASCII 值),**可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
3 占内存大小 字符常量只占2个字节
字符串常量占若干个字节(至少一个字符结束标志) (注意: char在Java中占两个字节)
public static void main(String[] args) {
char a = 'a';
System.out.println(a); //a
System.out.println((int) a); //97
System.out.println(a + 10); //107 可以直接做加法运算
String b = "b";
System.out.println(b); //b
System.out.println(b + "10"); //b10 进行了拼接
}
public static void main(String[] args) throws Exception {
int i = true ? null : 0;
System.out.println(i);
}
这样编译不为null,感觉i可议赋值为null一样。但是运行时报错:
Exception in thread "main" java.lang.NullPointerException
比如常见的从MyBatis查出来的数据,类型匹配出错~~
SELECT COUNT(*) FROM ( 原来的SQL )
IFNULL
函数(注意:上面count用IFNULL函数无效) 如: 常见异常信息如下:org.apache.ibatis.binding.BindingException: Mapper method 'com.xx.xx.xx.xx.xx.getCount attempted to return null from a method with a primitive return type (int).
往常我经常会看到一些所谓的优化建议不使用Count(* )
而是使用Count(1)
,从而可以提升性能,给出的理由是Count( *)会带来全表扫描。而实际上如何写Count并没有区别。
解释:
Count(1)和Count(*)实际上的意思是,评估Count()中的表达式是否为NULL,如果为NULL则不计数,而非NULL则会计数。比如我们看代码1所示,在Count中指定NULL(优化器不允许显式指定NULL,因此需要赋值给变量才能指定)
对于Count(列)来说,同样适用于上面规则
我是方向盘(YourBatman、方哥):一个前25年还不会写Hallo World、早已毕业的大龄程序员。