基础面试题

最新推荐文章于 2024-04-25 00:28:12 发布

原创最新推荐文章于 2024-04-25 00:28:12 发布 · 655 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#面试

面试专栏收录该内容

10 篇文章

订阅专栏

1.List和Set集合的区别

List ：有序可重复
Set ：无序不重复

2.String 与 StringBuffer 的区别

String 的值直接存进常量池
StringBuffer的实例在堆内存，里面存放的内容在常量池
在这里插入图片描述

3.Java中的String，StringBuilder，StringBuffer三者的区别

运行速度：
StringBuilder > StringBuffer > String
原因：
String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的
线程安全
String是不可变类，所以是线程安全的( 所有不可变类都是线程安全的，线程安全的类不一定是不可变类，如StringBuffer是可变类，靠锁实现线程安全)
StringBuffer 线程安全
StringBuilder 非线程安全
总结：
String - 适用于少量字符串操作
StringBuilder-适用于单线程下字符缓冲区进行大量操作
StringBuffer- 适用于多线程下字符缓冲区进行大量操作

4. throw 和throws 的区别

throw ：手动制造异常，并抛出异常
throws：声明异常

5. final 、finally 、finalize 的区别？

final ：修饰的类不能继承，修饰的方法不能重写，修饰变量是常量
finally ：try-catch -finally finally总是被执行
finalize：它式object的方法，gc的时候，会自动调用finalize方法

6.HashMap集合中的key 和value 可以为null吗？

可以
LinkedHashMap 也可以存null

7.ArrayList 和LinkedList的区别，以及内存中如何存储

ArrayList：底层是一个数组，查询快，增删慢非线程安全

在这里插入图片描述

LinkedList：查询慢，增删快非线程安全

在这里插入图片描述

8.ArrayList和Vector的区别？

ArrayList: 非线程安全
Vector：线程安全（synchronized）

9.HashTable和HashMap的区别？

Hashtable：线程安全
HashMap ：非线程安全

10.static、final、super、this 关键字的用法？

1.static：

可以修饰属性，方法、静态代码块
static修饰的内容常驻内存，垃圾回收机制是无法回收的，它不符合面向对象的思想，所有尽量少用

2.垃圾回收机制的原理何种情况内存会被回收？

长时间不用的对象
当内存满了之后，回收使用较少的对象
手动回收

3.final：

修饰的类无法被继承
修饰的方法不能被重写
修饰变量是常量
但是final关键字不能用来修饰构造方法：
// 原因：final修饰普通方法，将导致子类无法重写该方法，而构造方法本身就不能够被子类重写，故如果用final修饰，如同多此一举

4.super：

代表的父类

5.this：

当前类

11、Java 三大特性

封装
继承
多态

11.1.说说多态的理解

多态的表现形式 --动态多态
1.父类接收不同的子类的实例
2.接口接收不同实现类的实例

12.你听说过静态多态和动态多态吗？

1.静态多态：
1.重载

同类中两个或两个以上的同名方法，重载与方法参数，方法返回值无关

2.重写

子类重写父类的方法相当于覆盖方法，要求方法名、方法返回值、方法参数完全相同
子类的异常不能超过父类的异常
子类的访问级别不能低于父类的访问级别

2.动态多态

父类接收不同子类的实例
接口接收不同实现类的实例

13.方法访问修饰符级别

在这里插入图片描述

private 只有本类
default 同类、同包
protected 同类、同包、不同包的子类
public 公共的

14. 线程（wait和sleep的区别）

sleep()

sleep() 是线程类( Thread )的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程就进入就绪状态与其他前程一起竞争cpu的执行时间
线程不会释放对象锁

wait()

属于Object 类中
会释放对象锁
通过 notify() 、notifyAll() 来唤醒等待的线程

15、 IO流

字节流
字符流

字节流就是按照byte单位来读取，可以用来读取其他格式的文件

字符流是在字节流的基础上实现的，用来读取文本文件，一个字符一个字符的读取

如果字节流是一滴水一滴水的转移，那么字符流是用勺子一勺一勺水的转移，速度明显加快了

当然使用缓冲Buffer以后，就是一桶一桶水的转移了
在这里插入图片描述

16、序列化

在这里插入图片描述

17、UDP和TCP的区别

TCP 是面向连接的 UDP是面向无连接的
UDP程序结构比较简单
TCP是面向字节流的，UDP是基于数据包的
TCP保证数据正确性，UDP可能丢包
TCP保证数据顺序，UDP不保证

1.什么是面向连接，什么是面向无连接？

在互通之前，面向连接的协议会先建立连接，如TCP有三次握手而UDP不会
2.TCP为什么是可靠连接
通过TCP连接传输的数据无差错，不丢失，不重复，且按顺序到达。
TCP报文头里面的序号能使TCP的数据按序到达
报文头里面的确认序号能保证不丢包，累计确认及超时重传机制
TCP拥有流量控制及拥塞控制的机制
TCP的顺序问题，丢包问题，流量控制都是通过滑动窗口来解决的
拥塞控制是通过拥塞窗口解决的

18、代码块的执行顺序

优先级从高到低

静态代码块 > main方法 > 构造代码块 > 构造方法
静态代码块只执行一次
构造代码块每次创建对象都执行

//静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
//如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。
//注意：1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。


class Code{
    {
      System.out.println("Code的构造块");
    }
    
    static{
        System.out.println("Code的静态代码块");
        }
        
    public Code(){
        System.out.println("Code的构造方法");
        }
    }
    
    
public class CodeBlock03{
     {
      System.out.println("CodeBlock03的构造块");    
     }
     
     static{
        System.out.println("CodeBlock03的静态代码块");
        }
        
        public CodeBlock03(){
             System.out.println("CodeBlock03的构造方法");
            }
        
      public static void main(String[] args){
            System.out.println("CodeBlock03的主方法");
            new Code();
            new Code();
            new CodeBlock03();
            new CodeBlock03();
          }
    }
/*
CodeBlock03的静态代码块
CodeBlock03的主方法
Code的静态代码块
Code的构造块
Code的构造方法
Code的构造块
Code的构造方法
CodeBlock03的构造块
CodeBlock03的构造方法
CodeBlock03的构造块
CodeBlock03的构造方法
*/

19. ==和equals?

首先 equals是Object 类的一个方法，而 == 是Java中一个运算符
== 比较值相等：
如果作为基本数据类型的变量，则直接比较其储存的 ”值“ 是否相等。
如果做为引用类型的变量，则是比较的所知对象的地址
equals 方法：
注意：equals方法不能作用于基本数据类型的变量
equals 继承Object类，比较的是否是一个对象
如果没有对equals 方法进行重写，则比较的是引用类型的变量所指的的对象的地址。
String 、Date等类对equals 方法进行了重写，比较的是所知对象的内容

20 、hashCode 和 equals ？

每当需要对比的时候，首先用hashCode() 去对比，如果hashCode() 不一样，则表示这两个对象肯定不相等，[也就不必再用equal() 再去对比了] ，如果hashCode() 相同，此时他们的equals() 相同，则表示这两个对象是真的想通了，这样就能大大提高了效率也保证了对比的绝对正确性！

21、为什么重写了equals 方法也要重写hashCode？

1、如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；

2、如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)

自我的理解：

由于为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，这对比需要比较的数量很大的效率提高是很明显的，一个很好的例子就是在集合中的使用；

我们都知道java中的List集合是有序的，因此是可以重复的，而set集合是无序的，因此是不能重复的，那么怎么能保证不能被放入重复的元素呢，但靠equals方法一样比较的话，如果原来集合中以后又10000个元素了，那么放入10001个元素，难道要将前面的所有元素都进行比较，看看是否有重复，欧码噶的，这个效率可想而知，因此hashcode就应遇而生了，java就采用了hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。

继续上面的话题，为什么必须要重写hashcode方法，其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。

22、有没有有序的map

LinkedHashMap
链表和哈希表的结合是HashMap的子类，允许存储null值

23、编码转化,怎样实现将utf-8编码的字符串转换为ISO-8859-1编码的字符串?

        String s1 = "你好";
        String s2 = new String(s1.getBytes("utf-8"), "ISO-8859-1");
        System.out.println(s2);
        System.out.println(new String(s2.getBytes("ISO-8859-1"),"utf-8"));

在这里插入图片描述

24、 List的三个实现类?分别介绍一下

在这里插入图片描述

25、线程多线程的实现方式

在这里插入图片描述

状态

26、说说&和&&的区别

都是逻辑运算符

& ：
当两边表达式都为true时，结果才为true，否则为false
&&：
具有短路功能呢，有false 则false，当左边表达式为false时就不再计算第二个表达式

27、字符串String s =“sfds55d676455dfg32434eertre”; 怎么样把非数字全部去除，只保留数字？

              String str = "sfds55d676455dfg32434eertre";

              String longStr =new String(str.replaceAll("[^\\d]+", ""));

              System.out.println("字符串=========：" + longStr);

在这里插入图片描述

28.String s=“Hello”; s=s+“world！”;这两行代码执行后，原始的String对象中的内容到底变了没有？

  -  没有。因为String是不可变类（immutable class），不可变类，顾名思义就是说类的实例是不可被修改的。实例的信息是在创建的时候提供，并且在整个生命周期中都不可改变。在这段代码中，s原来指向一个String对象，内容是“hello”，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为”helloworld！",原来那个对象还存在内存中，只是s这个引用变量不再指向他了。

至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

是否可以继承String类？

String类是由final关键字修饰的，故不可以被继承。

29、String s=new String(“xyz”);创建了几个String Object？二者之前的区别是什么？

两个。第一个对象是字符串常量"xyz" 第二个对象是new String("xyz")的时候产生的，在堆中分配内存给这个对象，只不过这个对象的内容是指向字符串常量"xyz" 另外还有一个引用s，指向第二个对象。这是一个变量，在栈中分配内存。。

30、如果一个List中放了十个 Student对象，需要按照年龄排序，如何实现？

public class ListSort {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<Student>();
        students.add(new Student("张三", 24));
        students.add(new Student("李四", 23));
        students.add(new Student("王五", 25));
        System.out.println("before sort:");
        for (Student bean : students) {
            System.out.println("before sort---->age: " + bean.getAge());
        }
        Collections.sort(students);
        System.out.println("after sort:");
        for (Student bean : students) {
            System.out.println("after sort---->age: " + bean.getAge());
        }
    }
}
class Student implements Comparable<Student> {
    private String name;
    private Integer age;
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    /*
     * s的age小于this的对应字段，则返回负数；
     * 大于则返回正数；
     * 建议去了解compareTo背后的真相
     */
    @Override
    public int compareTo(Student s) {
        return s.getAge().compareTo(this.getAge());
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

从大到小

Collections.sort(students);
JavaBean 中继承
implements Comparable
重写
@Override
public int compareTo(Student s) {
return s.getAge().compareTo(this.getAge());
}

31、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的。用iterator（）方法来区分重复与否。equals（）是判断两个Set是否相等

equals（）和==方法决定引用值是否指向同一对象

equals（）在类中被覆盖，为的是当两个分离对象的内容和类型相配的话，返回真值

32、Collection和Collections的区别

java.util.Collection 是一个集合接口（集合类的一个顶级接口），其直接继承接口有 List和Set
Collections则是集合类的一个工具类，其中提供了一系列的静态方法，用于集合中元素排序，搜索以及线程安全等各种操作
一个详细介绍的链接

33、定义方法，对HashMap<Integer,User>中的User对象按照年龄倒序排序，返回排序后的HashMap<Integer,User>

HashMap本身时不可排序的，所以我们要想到有没有API中有这样的Map结构，
LinkedHashMap 它是Map结构，也是链表结构，有序的，更可喜的是它是HashMap的子类
我们返回LinkedHashMap<Integer,User>即可，还符合面向接口(父类编程的思想)
凡是对集合的操作比如排序算法我们不应该取用冒泡或者选择，而是想到用Collections 集合工具类

class User{
	private String name;
	private int age;
	
	public User(){}
	public User(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
	
}

public class Test01 {
   //
   public static void main(String[] args) {
   	HashMap<Integer,User> users=new HashMap<>();
   	
   	users.put(1, new User("张三",25));
   	users.put(3, new User("李四",22));
   	users.put(2, new User("王五",28));
   	
   	System.out.println(users);
   	
   	HashMap<Integer,User> sortHashMap=sortHashMap(users);
   	System.err.println(sortHashMap);
   	
   }
   // 定义一个进行排序的方法
   // 要求实现 对 HashMap 集合中 value值 即User 对象的 age 属性，进行 排序
   
   public static HashMap<Integer,User> sortHashMap(HashMap<Integer,User> map){
   	// 拿到 map集合键值对
   	Set<Entry<Integer,User>> entrySet=map.entrySet();
       // 将 set 集合 转化为 List 集合
   	List<Entry<Integer,User>> list= new ArrayList<Entry<Integer,User>> (entrySet);
   	// 使用 Collections 集合 工具类 对List 进行 排序,排序规则使用 匿名内部类来实现
   	Collections.sort(list,new Comparator<Entry<Integer,User>>(){
   		
   		// 安照要求 根据 User 的age 的倒序进行排序
   		
   		public int compare(Entry<Integer,User> o1,Entry<Integer,User> o2){
   			return o2.getValue().getAge()-o1.getValue().getAge();
   		}
   		
   	});
   	
   	// 创建 新的 有序的 hahMap 子类的集合
   	LinkedHashMap<Integer,User> linkedHashMap=new LinkedHashMap<Integer,User>();
   	
   	// 将 List 中的数据 存储 在 LinkedHashMap中
   	for(Entry<Integer,User> entry:list){
   		linkedHashMap.put(entry.getKey(),entry.getValue());
   	}
   	
   	return linkedHashMap;
   	
   }
   

}

34、数组和链表分别适用于什么场景，为什么？

数组的应用场景：
数据比较少；经常做的运算按序号访问数据元素，数组更容易实现，任何高级的语言都支持；构建的线性表比较稳定
链表的应用场景：
对线性表的长度或者规模难以估计；频繁的做插入删除操作；构建动态性比较强的线性表
为什么
- 数组：
  优：内存中地址连续，随机访问比较快捷快速，创建比较简单，随机查找比较方便，可以直接给出下标，排序也比较方便，
  缺：不够灵活，删除增加的工作量较时比较麻烦，长度不能实时变化
- 链表
  优：内存中地址不是连续的，插入删除比较方便，长度可以实时变化
  缺：不支持随机查询，查找匀速需要遍历

35、单例设计模式有哪几种？有什么区别

点击跳转：单例模式

36、冒泡排序

点击跳转：冒泡排序，选择排序

37、http常见的状态码有哪些？并说明它们的含义

200 【操作成功】
201 【对象创建成功】
204 【操作已经成功，但是没有返回数据】
415【数据格式错误】
500【服务器错误】
如图所示 ↓

38、mybatis 中 #{}和${}的区别是什么？

#方式能够很大程度防止sql注入。
$方式无法防止Sql注入。
$方式一般用于传入数据库对象，例如传入表名.
一般能用#的就别用$.

详细解释

39、当实体类中的属性名和表中的字段名不一样，怎么办？

属性字段上加上@Column(name = “表中字段名”)

40、mybatis模糊查询怎么实现的

like ‘%#{}%’
最好 %% 在外面拼接好了，在查询

41、mybatis分页怎么实现的?

PageHelper 分页组件

42、mybatis进行多表查询时，数据如何封装到对象中的

对应名称封装
注解版
xml版

43、简单说一说drop、delete与truncate的区别

当表被truncate 后，这个表和索引所占用的空间会恢复到初始大小
delete操作不会减少表或索引所占用的空间。表结构依然存在，只删除表中全部数据
drop语句将表所占用的空间全释放掉。表结构和数据全部被删除。
一般而言，drop > truncate > delete
相同点：
truncate和不带where子句的delete，以及drop 都会删除表内的数据

44、什么是主键？什么是外键？并说出它们的作用

主键唯一标识
外键约束主要用来维护两个表之间数据的一致性。
关系：外键一定是另外某个表的主键

46、输出char和varchar的区别，及它们的适用场景

char的长度是不可变的，而varchar的长度是可变的，也就是说，定义一个char[10]和varchar[10],如果存进去的是‘csdn’,那么char所占的长度依然为10，除了字符‘csdn’外，后面跟六个空格，而varchar就立马把长度变为4了，取数据的时候，char类型的要用trim()去掉多余的空格，而varchar是不需要的。
尽管如此，char的存取数度还是要比varchar要快得多，因为其长度固定，方便程序的存储与查找；但是char也为此付出的是空间的代价，因为其长度固定，所以难免会有多余的空格占位符占据空间，可谓是以空间换取时间效率，而varchar是以空间效率为首位的。
再者，char的存储方式是，对英文字符（ASCII）占用1个字节，对一个汉字占用两个字节；而varchar的存储方式是，对每个英文字符占用2个字节，汉字也占用2个字节。

47、说说where、group by 、having、order by 同时出现时的先后顺序

where – group by – having --order by
对于GROUP BY聚合操作，如果在SELECT中的列，没有在GROUP BY中出现，那么这个SQL是不合法的，因为列不在GROUP BY从句中，也就是说查出来的列必须在group by后面出现否则就会报错，或者这个字段出现在聚合函数里面。
文档指出：ONLY_FULL_GROUP_BY的设定，将不允许查询字段包括非聚集列
正确sql：
SELECT ip,max(last_login) last_login FROM sdb_login_log group by ip;
SELECT last_login,max(last_login) last_login FROM sdb_login_log group by ip;

在这里插入图片描述

参考文档

mysql版本更新后的不同介绍点击跳转

48、说出SQL中内连接、左连接、右连接的区别

内连接：显示左边右边共有的
select a.,b. from a inner join b on a.id=b.parent_id
简写：
select a.,b. from a ， b on a.id=b.parent_id
左连接：左边有的，右边没有的为null
select a.,b. from a left join b on a.id=b.parent_id

左表的某行在右表中没有匹配行，则在相关联的结果集行中右表的所有选择列表列均为空值。

右连接：右边有的，左边没有的为null
select a.,b. from a right join b on a.id=b.parent_id

返回右表的所有行。如果右表的某行在左表中没有匹配行，则将为左表返回空值。

交叉联接 :左表中的所有行，左表中的每一行与右表中的所有行组合。交叉联接也称作笛卡尔

49、mysql 实操题

如有错误或有更好解决方法，还请留言指出不胜感激

在这里插入图片描述

/*
 Navicat Premium Data Transfer

 Source Server         : 5.5.59
 Source Server Type    : MySQL
 Source Server Version : 50559
 Source Host           : localhost:3306
 Source Schema         : test

 Target Server Type    : MySQL
 Target Server Version : 50559
 File Encoding         : 65001

 Date: 24/04/2018 20:51:05
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for course
-- ----------------------------
DROP TABLE IF EXISTS `course`;
CREATE TABLE `course`  (
  `cid` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `cName` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `tid` int(20) NULL DEFAULT NULL,
  PRIMARY KEY (`cid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of course
-- ----------------------------
INSERT INTO `course` VALUES ('001', '企业管理', 3);
INSERT INTO `course` VALUES ('002', '马克思', 3);
INSERT INTO `course` VALUES ('003', 'UML', 2);
INSERT INTO `course` VALUES ('004', '数据库', 1);
INSERT INTO `course` VALUES ('005', '英语', 1);


-- ----------------------------
-- Table structure for sc
-- ----------------------------
DROP TABLE IF EXISTS `sc`;
CREATE TABLE `sc`  (
  `sid` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `cid` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `score` int(10) NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of sc
-- ----------------------------
INSERT INTO `sc` VALUES ('1001', '001', 80);
INSERT INTO `sc` VALUES ('1001', '002', 60);
INSERT INTO `sc` VALUES ('1001', '003', 75);
INSERT INTO `sc` VALUES ('1002', '001', 85);
INSERT INTO `sc` VALUES ('1002', '002', 70);
INSERT INTO `sc` VALUES ('1003', '004', 100);
INSERT INTO `sc` VALUES ('1003', '001', 90);
INSERT INTO `sc` VALUES ('1003', '002', 55);
INSERT INTO `sc` VALUES ('1004', '002', 65);
INSERT INTO `sc` VALUES ('1004', '003', 60);

-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`  (
  `sid` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `sName` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `sAge` datetime NULL DEFAULT '1980-10-12 23:12:36',
  `sSex` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`sid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('1001', '张三丰', '1980-10-12 23:12:36', '男');
INSERT INTO `student` VALUES ('1002', '张无极', '1995-10-12 23:12:36', '男');
INSERT INTO `student` VALUES ('1003', '李奎', '1992-10-12 23:12:36', '女');
INSERT INTO `student` VALUES ('1004', '李元宝', '1980-10-12 23:12:36', '女');
INSERT INTO `student` VALUES ('1005', '李世明', '1981-10-12 23:12:36', '男');
INSERT INTO `student` VALUES ('1006', '赵六', '1986-10-12 23:12:36', '男');
INSERT INTO `student` VALUES ('1007', '田七', '1981-10-12 23:12:36', '女');

-- ----------------------------
-- Table structure for teacher
-- ----------------------------
DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher`  (
  `tid` int(10) NULL DEFAULT NULL,
  `tName` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of teacher
-- ----------------------------
INSERT INTO `teacher` VALUES (1, '李老师');
INSERT INTO `teacher` VALUES (2, '何以琛');
INSERT INTO `teacher` VALUES (3, '叶平');

SET FOREIGN_KEY_CHECKS = 1;

查询“001”课程比“002”课程成绩高的所有学生的学号

## 算是内连接  
select s1.sid from sc s1,sc s2 where s1.sid=s2.sid and s1.cid='001' and s2.cid='002' and s1.score >s2.score

查询没学过“叶平”老师课的同学的学号、姓名

##1.先获取出叶平老师 交哪个学科
select  c.cid from teacher t , course c where t.tid =c.tid and t.tName='叶平'
##2.叶平老师所教的学生
select DISTINCT sc.sid from sc sc ,course c where sc.cid  in (select  c.cid from teacher t , course c where t.tid =c.tid and t.tName='叶平')
##3. 查询出所有学生id 不再叶平老师所教授的学生id之中
select s.sid ,s.sName from student s where s.sid not in()
select s.sid ,s.sName from student s where s.sid not in(select  distinct sc.sid from sc sc ,course c where sc.cid  in (select  c.cid from teacher t , course c where t.tid =c.tid and t.tName='叶平')
)

查询平均成绩大于60分的同学的学号和平均成绩

## 根据id分组  求平均分
select sc.sid, avg(sc.score) from sc sc group by sid    having avg(sc.score)>60

查询成绩都及格的学生信息

#  1. 先查出有不及格的学生id
	select s1.sid from sc s1 where s1.score<60
# 2. 在成绩表里查找除了不及格学生  剩余及格的学生id  去重
	select distinct s2.sid from sc s2 where s2.sid not in ( select s1.sid from sc s1 where s1.score<60)
# 3. 根据id  匹配 student表  显示信息
	select * from student s where s.sid in ( select distinct s2.sid from sc s2 where s2.sid not in ( select s1.sid from sc s1 where s1.score<60))

查询不同老师所教不同课程平均分从高到低显示

# 先根据课程分组 然后 在排序
select avg(sc.score) from sc sc group by sc.cid order by  avg(sc.score) desc

基础面试题

1.List和Set集合的区别

2.String 与 StringBuffer 的区别

3.Java中的String，StringBuilder，StringBuffer三者的区别

4. throw 和throws 的区别

5. final 、finally 、finalize 的区别？

6.HashMap集合中的key 和value 可以为null吗？

7.ArrayList 和LinkedList的区别，以及内存中如何存储

8.ArrayList和Vector的区别？

9.HashTable和HashMap的区别？

10.static、final、super、this 关键字的用法？

11、Java 三大特性

11.1.说说多态的理解

12.你听说过静态多态和动态多态吗？

13.方法访问修饰符级别

14. 线程（wait和sleep的区别）

15、 IO流

16、序列化

17、UDP和TCP的区别

18、代码块的执行顺序

19. ==和equals?

20 、hashCode 和 equals ？

21、为什么 重写了equals 方法也要重写hashCode？

22、有没有 有序的map

23、编码转化,怎样实现将utf-8编码的字符串转换为ISO-8859-1编码的字符串?

24、 List的三个实现类?分别介绍一下

25、线程 多线程的实现方式

26、 说说&和&&的区别

27、字符串String s =“sfds55d676455dfg32434eertre”; 怎么样把非数字全部去除，只保留数字？

28.String s=“Hello”; s=s+“world！”;这两行代码执行后，原始的String对象中的内容到底变了没有？

29、String s=new String(“xyz”);创建了几个String Object？二者之前的区别是什么？

30、 如果一个List中放了十个 Student对象，需要按照年龄排序，如何 实现？

31、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

32、Collection和Collections的区别

33、定义方法，对HashMap<Integer,User>中的User对象按照年龄倒序排序，返回排序后的HashMap<Integer,User>

34、数组和链表分别适用于什么场景，为什么？

35、 单例设计模式有哪几种？有什么区别

36、冒泡排序

37、http常见的状态码有哪些？并说明它们的含义

38、mybatis 中 #{}和${}的区别是什么？

39、当实体类中的属性名和表中的字段名不一样 ，怎么办 ？

40、mybatis模糊查询怎么实现的

41、mybatis分页怎么实现的?

42、mybatis进行多表查询时，数据如何封装到对象中的

43、简单说一说drop、delete与truncate的区别

44、什么是主键？什么是外键？并说出它们的作用

46、输出char和varchar的区别，及它们的适用场景

47、说说where、group by 、having、order by 同时出现时的先后顺序

48、说出SQL中内连接、左连接、右连接的区别

49、mysql 实操题

如有错误或有更好解决方法，还请留言指出 不胜感激

50、

51、

52、

53、

54、

21、为什么重写了equals 方法也要重写hashCode？

22、有没有有序的map

25、线程多线程的实现方式

26、说说&和&&的区别

30、如果一个List中放了十个 Student对象，需要按照年龄排序，如何实现？

35、单例设计模式有哪几种？有什么区别

39、当实体类中的属性名和表中的字段名不一样，怎么办？

如有错误或有更好解决方法，还请留言指出不胜感激