面试

最新推荐文章于 2024-01-20 20:06:43 发布

置顶 ouly椿

最新推荐文章于 2024-01-20 20:06:43 发布

阅读量125

点赞数

文章标签： java 面试

本文链接：https://blog.csdn.net/weixin_42270329/article/details/105719226

版权

面试问题时间2020.4.23

SQL真的很重要！！！

1.i++和++i的区别

i++简单来说就是先用i的值来参加表达式的计算，然后再自加1
```
  i=1;
  a=i++; //此时，先做a=i=1，再做i++，故a=1，i=2
```

++i则是先自增1，再用自加后的值来做运算。

  i=1;

  a=++i; //此时，先做++i=2，再做a=++1，故a=2,i=2

练习1

public static void main(String[] args){
	int x=1;
	int y=x++ + ++x;
	System.out.println(x);
	System.out.println(y);
}

	x的值等于3

	y的值等于4

	遇到++x时 x先加一 再执行

	遇到x++时 x的值不变，执行完当前操作后，x的值再加一

	x++的时候 x=2

	++x 时候 y=1+3 , y=4 ,x=3

练习2

 int a = 0;
        for (int i = 0; i < 99; i++) {
            a = a ++;
        }
        System.out.println(a);
        //a=0

        int b = 0;
        for (int i = 0; i < 99; i++) {
            b = ++ b;
        }
        System.out.println(b);
        //b=99

  Integer a = 0;
        int b = 0;
        for (int i = 0; i < 99; i++) {
            a = a ++;
            b = a ++;
        }
        System.out.println(a);
        System.out.println(b);
        //a=99,b=98

练习2原文链接java中i++ 和 ++i的区别

2.==和equals

一、理解”==“的含义

 在java中，主要有两个作用。

 1、基础数据类型：比较的是他们的值是否相等，比如两个int类型的变量，比较的是变量的值是否一样。

 2、引用数据类型：比较的是引用的地址是否相同，比如说新建了两个User对象，比较的是两个User的地址是否一样。

二、理解equals的含义

源码中你会发现，比较的是当前对象的引用和obj的引用是否相同，也就是说比较的默认就是地址。
在这里==比较的是引用的地址，equals也是比较的是引用的地址，所以他们的效果在这里是一样的。

三、重写equals

1、String中equals方法
		Object对象里面的==和equals没有什么区别，这样一看equals方法存在的意义真的不大，不过后来String在Object的基础之上重写了equals，于是功能被大大的改变了。
		String中的equals方法其实比较的是字符串的内容是否一样。也就是说如果像String、Date这些重写equals的类

四、总结：

  （1）、基础类型比较
  
  使用==比较值是否相等。
  
  （2）、引用类型比较
  
  ①重写了equals方法，比如String。
  
  第一种情况：使用==比较的是String的引用是否指向了同一块内存
  
  第二种情况：使用equals比较的是String的引用的对象内用是否相等。
  
  ②没有重写equals方法，比如User等自定义类
  
  ==和equals比较的都是引用是否指向了同一块内存。

引自 “原文链接

“+=”和append的区别


String s1 = "a";
String s2 = s1 + "b";
System.out.println(s2 == "ab"); // false

虚拟机开始是定义了一个字符串”a“将其入栈;
然后new了一个StringBuilder对象，将”a“封装到Sb对象中;
之后用StringBuilder的append()方法来完成"a"和"b"的拼接;
这里的"ab"字符串本质上是一个StringBuilder对象，所以再去跟常量"ab"去比较的话会是false

循环时使用+=会创建多个StringBuilder对象，而使用append()，只会创建一个。
所以我们在平时写代码的时候一定注意，不要再循环中使用+=操作，效率很低的。

参考原文链接

JDK8新特性

 1.Lambda表达式

    2.新的日期API

    3.引入Optional

    4.使用Base64

    5.接口的默认方法和静态方法

    6.新增方法引用格式

    7.新增Stream类

    8.注解相关的改变

    9.支持并行（parallel）数组

    10.对并发类（Concurrency）的扩展。

参考原文链接

Stringbuffer与substring

1、Stringbuffer

  Stringbuffer 有append()方法
  Stringbuffer 其实是动态字符串数组
  append()是往动态字符串数组添加，跟“xxxx”+“yyyy”相当那个‘+’号
  跟String不同的是Stringbuffer是放一起的
  String1+String2 和Stringbuffer1.append("yyyy")虽然打印效果一样，但在内存中表示却不一样
  String1+String2 存在于不同的两个地址内存
  Stringbuffer1.append(Stringbuffer2)放在一起

java中substring的用法
str＝str.substring(int beginIndex);截取掉str从首字母起长度为beginIndex的字符串，将剩余字符串赋值给str；

str＝str.substring(int beginIndex，int endIndex);截取str中从beginIndex开始至endIndex结束时的字符串，并将其赋值给str;

例如：把文件名截取出来

String path = "http://218.6.14.165:8085/1234.jpg";
int begin = path.lastIndexOf("/") + 1;// 从“/”的下一位开始截取+1 
int end = path.lastIndexOf(".");
String string = path.substring(begin, end);

public String substring(int beginIndex, int endIndex)

第一个参数int为开始的索引，对应String数字中的开始位置，

第二个参数是截止的索引位置，对应String中的结束位置

1、取得的字符串长度为：endIndex - beginIndex;

2、从beginIndex开始取，到endIndex结束，从0开始数，其中不包括endIndex位置的字符

package com.example;
 
public class MyClass {
 
    public static void main(String[] args){
 
        String test = "Hello World !";
 
        String subTest1 = test.substring(0,3);
        System.out.println("subTest:" + subTest1);
 
        String subTest2 = test.substring(0,test.length());
        System.out.println("subTest:" + subTest2);
 
    }
 
}

subTest:Hel

subTest:Hello World !

注意：

1)、substring(a,b)中的参数a其值可以从索引值0开始，

       当a等于0时，则表示其从字符串的第一个字符开始算起，

       也就是其子字符串是包含第一个字符的，当然，你也可以从后续的其他字符开始；

2)、substring(a,b)中的参数b,其值最大可以为 父字符串的长度，

       但并不包含索引值为b的那个字符。

参考原文链接1
参考原文链接2

正向排序

面试遇到数组正向排序

例子1：顺序排列


public class Main {
 
    public static void main(String[] args){
	int[] a={1,8,5,2,4,9,7};
 	 for(int i=0;i<a.length;i++){
   		for(int j=i+1;j<a.length;j++){
    		if(a[i]>a[j]){
     		//通过交换位置进行排序
    		 int k=a[i];
     		a[i]=a[j];
    		 a[j]=k;
   			 }
 		  }
   			System.out.print(a[i]+",");
 		}
	}
}

例子2，字符串反向排序

public class Main {
 
    public static void main(String[] args){
	String s = "abcdefg";
	StringBuilder a = new StringBuilder(s);
	System.out.println(a.reverse());
	}
}

mybatis 中的 update 返回值

	当数据库中的记录被修改之后，再次执行重复的 update 操作将不会影响到新的行数；
	按照这个逻辑：我们再次执行这个单元测试应该是， resultCode 返回的应该是 0 ，和我们的期望的数字 2 不一致，将会导致测试不通过。
	再次运行单元测试：

	居然还是 passed ,看到这里聪明的你已经看出来了，默认情况下，mybatis 的 update 操作返回值是记录的 matched 的条数，并不是影响的记录条数。
	
	严格意义上来将，这并不是 mybatis 的返回值，mybatis 仅仅只是返回的数据库连接驱动（通常是 JDBC ）的返回值，也就是说，如果驱动告知更新 2 条记录受影响，那么我们将得到 mybatis 的返回值就会是 2 和 mybatis 本身是没有关系的。

解决方法

	通过对 JDBC URL 显式的指定 useAffectedRows选项，我们将可以得到受影响的记录的条数：
	修改数据库链接配置为：增加了 useAffectedRows 字段信息。	
		
	jdbc:mysql://${jdbc.host}/${jdbc.db}?useAffectedRows=true	
	
	此时，mybatis 的 update 操作返回的应该是受影响的条数了，我们再次运行单元测试试试看：
	update 操作返回的是受影响的记录条数，我们知道为 0 和我们预期的 2 不一致，自然而然单元测试不通过咯～。

参考原文链接

list删除重复元素

循环List集合，将新集合中没有的元素添加至新集合，此法可在去重的同时保持原来的顺序

public static void main(String[] args)
{
    //原List集合
    String[] array = { "aa", "bb", "aa", "cc", "dd", "bb", "ee" };
    List<String> list = Arrays.asList(array);
    //使用迭代器删除重复元素，可保持原来的顺序
    Iterator<String> iterator = list.iterator();
    List<String> newList = new ArrayList<String>();
    while (iterator.hasNext())
    {
        String next = iterator.next();
        //将新集合中没有的元素添加到新集合
        if (!newList.contains(next))
        {
            newList.add(next);
        }
    }
    System.out.println(newList);
}

原文链接：https://blog.csdn.net/u013020593/article/details/79041499

ouly椿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
面试

面试问题时间2020.4.23SQL真的很重要！！！1.i++和++i的区别i++简单来说就是先用i的值来参加表达式的计算，然后再自加1 i=1; a=i++; //此时，先做a=i=1，再做i++，故a=1，i=2++i则是先自增1，再用自加后的值来做运算。 i=1; a=++i; //此时，先做++i=2，再做a=++1，故a=2,i=2练习1...
复制链接

扫一扫