Java 笔记

原谅糖 2019-09-04 in 胡诌

JRE 和 JDK

JRE：Java 程序的运行时环境，包含 JVM 和运行时所需要的核心类库。
JDK：Java 程序开发工具包，包含 JRE 和开发人员使用的工具。

编译和运行

编译：指将编写的 Java 源文件翻译成 JVM 能认识的 class 字节码文件，javac 编译器会检查程序中是否有错，有错误就会提示，无错误则编译成功。
运行：指将 class 文件交给 JVM 运行。

基本数据类型

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-2的31次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	-3.4028E+38~3.4028E+38
双精度浮点数	double（默认）	8个字节	-1.7977E+308~1.7977E+308
字符型	char	2个字节	0~65535
布尔型	boolean	1个字节	true，false

引用数据类型

除了八种基本数据类型，其他全都是引用数据类型，如 String。

数据类型转换

自动转换：从小到大，byte-short-char-->int-->long-->float-->double
强制转换：从大到小，浮点到整数可能会发生精度损失，int 转 short 可能会发生数据溢出（丢失）

格式：数据类型变量名 = (数据类型) 被转数据值;

ASCII 编码表

字符	数值
0	48
A	65
a	97

在 char 类型和 int 类型计算的过程中，char 类型的字符先查询编码表，得到 97，再和 1 求和，结果为 98。char 类型提升为了 int 类型。char 类型内存 2 个字节，int 类型内存 4 个字节。

重载和重写

重载：方法名相同，参数不同，返回类型可以相同也可以不同，方法体不同。一般用在构造器方法上，JVM 会根据传入参数的不同，选择不同的构造方法。
重写：方法名，参数，返回类型相同，方法体不同。一般用在子类对父类方法的重写，定义子类自己的行为。

Java 内存区域

JDK1.8 之后：图片丢失

类和对象

类：一类事物的属性和行为的集合，抽象的。
对象：一类事物的具体体现，类的一个实例，具体的。

类是对象的模板，对象是类的实体。

成员变量的默认值

	数据类型	默认值
基本类型	整数	0
	浮点	0.0
	字符	'\u0000'
	布尔类型	false
引用类型	数组、类、接口	null

面向对象三大基本特征

封装：将类的属性和方法隐藏起来，提供一个安全的接口供外界调用，减少耦合。缺点是重复代码，要写很多 getter 和 setter。
继承：子类继承父类的属性和方法，减少代码重复，提高可维护性，程序更加有层次，缺点是增加了耦合。
多态：同一个接口或者类，使用不同的实例完成不同的操作。减少耦合，提高可维护性。三个必要条件：继承，重写，父类引用指向子类对象。缺点是无法调用子类特有的方法。

Scanner 和 Random

//Scanner
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
//Random
Random r = new Random();
int i = r.nextInt();

Java 集合

List：顺序结构，有序可以重复
- ArrayList：底层是 Object 数组，可以根据 index 快速访问
- LinkedList：底层是双向链表，无法快速访问
Set：不允许重复
- HashSet：无序唯一，底层基于 HashMap，存储Key
- LinkedHashSet：底层基于 LinkedHashMap
Map：键值对 key&value 形式，key 无法重复，value 可以
- HashMap：底层是数组+链表，链表用于存储哈希冲突产生的多个 value，JDK1.8 之后链表换成了红黑树，查询效率更高
- LinkedHashMap：在 HashMap 基础上增加了一条双向链表，来保证存取顺序一定

HashSet 检查重复：先计算对象的 hashcode 值，与集合中的其他对象的 hashcode 值比较，如果没有相同的则存储。如果有相同的，则使用 equals() 方法判断是否相同。而 hashcode 并不完美，两个不同的对象，有概率 hashcode 值也相同，所以在需要使用 HashSet 存储对象时，一定要重写 hashcode 和 equals。

== 与 equals

没有重写 equals() 方法，则两者相同：对基本类型比较值，对引用类型比较内存地址。
有重写 equals() 方法，则 equals() 比较的是对象的内容是否相等。

String 类

常用方法：equals，length，charAt，indexOf，toCharArray，replace，split

字符串类，一旦被创建赋值之后，无法改变，只能将变量指向其他字符串的内存地址。

static 关键字

可以修饰成员变量和成员方法，被修饰之后的变量和方法属于类，建议直接用类名调用。

静态代码块：在类加载之后只执行一次。

Arrays 类

常用方法：toString，sort，asList

Math 类

常用方法：abs（返回 double 的绝对值），ceil（返回大于等于参数的最小整数），floor（返回小于等于参数最大的整数），round（返回最接近参数的 long，相当于四舍五入）

final 关键字

可以修饰类、方法和变量

类：不能被继承
方法：不能被重写
变量：基础数据类型不能被重新赋值，引用类型不能再指向另一个对象

权限修饰符

	public	protected	default（空）	private
同类中	✔	✔	✔	✔
同一包中	✔	✔	✔
不同包的子类	✔	✔
不同包中的无关类	✔

public 任意访问，private 只有同类能访问，default 只能在同包中访问，protected 在不同包子类中也能访问。

匿名内部类

本质是一个带具体实现父类或父接口的匿名的子类对象。

new 父类名或者接口名(){     
    // 方法重写     
    @Override      
    public void method() {         
        // 执行语句     
    } 
};

Object 类

Java 中所有类的父类

常用方法：toString，equals

Objects 是一个工具类，其中的 equals 方法直接传递两个参数，可以防止空指针异常。

Date 类

无参构造自动设置系统当前时间的毫秒时刻（距 1970年1月1日00:00:00 GMT），有参构造传递一个 long 值可以自定义时刻。

常用方法：getTime（把日期对象转换成时间毫秒值）

DateFormat 类

抽象类，可使用子类 SimpleDateFormat，构造方法传递一个日期格式。

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

常用方法：format（将 Date 对象格式化为字符串），parse（将字符串解析为 Date 对象）

System 类

常用方法：currentTimeMillis（获取当前时间到 1970年1月1日00:00:00 GMT 的毫秒值），arraycopy（将数组中指定的数据拷贝到另一个数组中）

StringBuilder 类

为了解决 String 类无法修改造成的效率问题。

无参构造创建一个空的 StringBuilder 容器，有参构造创建一个StringBuilder 容器，传递一个字符串进去。

常用方法：append（在循环中效率比 + 更高），toString（将 StringBuilder 对象转换成 String 对象）

包装类

基本类型效率高，但是功能少，Java 提供了基本类型对应的包装类，实现更多功能。

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱：从基本类型转换成对应的包装类对象
拆箱：从包装类对象转换成对应的基本类型

JDK1.5 开始，装箱和拆箱可以自动完成。

基本类型和字符串之间的转换

基本类型转换成字符串直接拼接：+""

字符串转换成对应的基本类型使用对应包装类的 praseXxx 方法

Collection 集合

所有单列集合（List 和 Set）的根接口

常用方法：add，remove，contains，isEmpty，size

Iterator 接口

构造方法获取一个集合对应的迭代器

常用方法：next（返回下一个元素），hasNext（返回是否还有元素）

增强 for 的原理是迭代器

for(元素的数据类型  变量 : Collection集合or数组){ 
    //写操作代码
}

泛型

集合里可以存储不同类型的对象，但是没必要，一般都是同类型的。如果传递了不同的类型，取出时会发生强转异常。

可以在类或方法中预支地使用未知的类型，将运行时异常转移到了编译时期。

常见的数据类型

栈，队列，数组，链表，二叉树

Collections 工具类

常用方法：addAll，shuffle（打乱顺序），sort（排序，按指定规则排序）

comparable 和 comparator 的区别

comparable 接口下有一个 compareTo(Object obj) 方法用来排序。用于在类中定义排序方法。
comparator 接口下有一个 compare(Object obj1, Object obj2) 方法用来排序。用于在匿名内部类中重写排序方法。

Throwable 类

Error：严重错误，无法通过修改代码处理的错误
Exception：表示异常，可以通过修改代码纠正使程序继续运行

常用方法：printStackTrace，getMessage

Exception 分类

编译期异常（如日期格式化异常）和运行时异常（数学异常）

异常处理：

throw 直接抛出给调用者
throws 声明异常给调用者不处理
try...catch 捕获异常

try{      
    编写可能会出现异常的代码 
}catch(异常类型  e){      
    处理异常的代码      
        //记录日志/打印异常信息/继续抛出异常 
}ﬁnally{
    最终一定执行的代码
        //当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。
        //以下情况，ﬁnally 不会被执行：
        //1.在 finally 语句块第一行发生了异常。 因为在其他行，finally 块还是会得到执行
    	//2.在前面的代码中用了 System.exit(int)已退出程序。 exit 是带参函数 ；若该语句在异常语句之后，finally 会执行
    	//3.程序所在的线程死亡。
    	//4.关闭 CPU。
}

可以捕获多个异常，子异常在父异常上方

并发和并行

并发：多个事件在同一个时间段发生
并行：多个事件在同一时刻发生

线程和进程

进程：是指程序的一次执行过程，是系统运行的基本单位。
线程：是进程中的一个执行单元，一个进程可以产生多个线程。

线程的几种状态

new，runnable，blocked，waiting，timewaiting，terminated

创建线程的方法

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

Thread 和 Runnable 的区别

实现 Runnable 接口比继承 Thread 类更好：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

synchronized 关键字

保证被它修饰过的方法或者代码块在同一时刻只有一个线程执行

synchronized(同步锁){      
    需要同步操作的代码 
}
//锁对象可以是任意类型，多个线程对象要使用同一把锁

public synchronized void method(){     
    可能会产生线程安全问题的代码   
}
//当有执行该方法的线程时，其他线程无法使用此方法

说说 sleep() 方法和 wait() 方法区别和共同点?

sleep 方法不会释放锁，wait 方法会释放锁
除非使用 wait(long timeout) 方法传递一个时间，否则 wait() 无法自动苏醒，需要其他线程调用 notify
wait 用于线程间通信，sleep 用于暂停执行
都可以暂停线程的执行

使用线程池的步骤

创建线程池
创建 Runnable 接口子类对象
提交 Runnable 接口子类对象
关闭线程池

File 类

绝对路径：从盘符开始的路径
相对路径：相对于项目目录的路径

常用方法：exist，isDirectory，isFile，createNewFile（当且仅当该名称的文件不存在时，创建一个新的空文件），delete，mkdir（创建此File表示的目录），mkdir（创建此File表示的目录以及任何必需但不存在的父目录），list（返回一个String数组，表示该File目录中所有的子文件或目录），listFiles（返回一个File数组，表示该File目录中所有的子文件或目录）

递归

指在当前方法内调用自己的这种现象

直接递归自身调用自身
间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法

递归一定要有限定条件，保证递归能够停下，并且递归次数不能过多，否则会发生栈内存溢出。构造方法禁止递归。

public class DiGuiDemo {    
    //计算n的阶乘，使用递归完成        
    public static void main(String[] args) {         
        int n = 3;        
        // 调用求阶乘的方法            
        int value = getValue(n);        
        // 输出结果
        System.out.println("阶乘为:"+ value);     } 
    /*           
    通过递归算法实现.         
    参数列表:int          
    返回值类型: int        
    */        
    public static int getValue(int n) {        
        // 1的阶乘为1            
        if (n == 1) {             
            return 1;         
        }        
        /*             
        n不为1时,方法返回 n! = n*(n‐1)!              
        递归调用getValue方法        
        */            
        return n * getValue(n ‐ 1);     
    } 
}

public class DiGuiDemo3 {     
    public static void main(String[] args) {         
        // 创建File对象         
        File dir  = new File("D:\\aaa");        
        // 调用打印目录方法            
        printDir(dir);     
    }       
    public static void printDir(File dir) {        
        // 获取子文件和目录            
        File[] files = dir.listFiles();                 
        // 循环打印            
        for (File file : files) {             
            if (file.isFile()) {                
                // 是文件，判断文件名并输出文件绝对路径
                if (file.getName().endsWith(".java")) {                     
                    System.out.println("文件名:" + file.getAbsolutePath());                 
                }             
            } else {                 
                // 是目录，继续遍历,形成递归                 
                printDir(file);             
            }         
        }     
    } 
}

文件过滤器

public class DiGuiDemo4 {     
    public static void main(String[] args) {         
        File dir = new File("D:\\aaa");         
        printDir2(dir);     
    }        
    public static void printDir2(File dir) {        
        // 匿名内部类方式,创建过滤器子类对象  
        File[] files = dir.listFiles(new FileFilter() {             
        @Override             
            public boolean accept(File pathname) {                 
                return pathname.getName().endsWith(".java")||pathname.isDirectory();             

            }         
        });        
        // 循环打印            
        for (File file : files) {             
            if (file.isFile()) {                 
                System.out.println("文件名:" + file.getAbsolutePath());             
            } else {                 
                printDir2(file);             
            }         
        }     
    } 
}

字节流

字节输出流 OutputStream

常用方法：close（完成操作之后必须执行），flush，write

文件输出流 FileOutputStream

构造方法传递 File 对象或者 String 路径创建文件输出流，加一个 true 可追加数据

Windows 换行符号：\r\n

Unix 换行符号：\n

字节输入流 InputStream

常用方法：close（完成操作之后必须执行），read（读取字节时会自动提升为int类型）

文件输入流 FileInputStream

构造方法传递 File 对象或者 String 路径创建文件输入流

字符流

中文字符占用多个字节存储，所以使用字符流处理文本文件更方便。使用系统默认的字符编码和默认字节缓冲区。字符流无法处理图片视频等非文本文件。

FileWriter 与 FileOutputStream 不同，如果不关闭，数据只是保存到缓冲区，并未保存到文件。

在 close 执行之后，流对象无法继续使用写出别的内容，所以必须在 close 之前执行 flush 方法。

在实际开发中，IO 异常一定要处理。

缓冲流

对四个基本流的增强，在创建流对象时，创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统 IO 次数，提高读写效率。

字节缓冲流：BufferedInputStream，BufferedOutputStream

// 创建字节缓冲输入流 
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")); 
// 创建字节缓冲输出流 
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

读取时 read 传递一个 byte 数组，效率更高。

字符缓冲流：BufferedReader，BufferedWriter

// 创建字符缓冲输入流 
BufferedReader br = new BufferedReader(new FileReader("br.txt")); 
// 创建字符缓冲输出流 
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法：readLine（读取一行文字），newLine（写一行分隔符）

转换流

是字节与字符间的桥梁

InputStreamReader 类：Reader 的子类，读取字节解码为字符。

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt")); InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

OutputStreamWriter 类：Writer 的子类，读取字符编码为字节。

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt")); OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

序列化

对象序列化，用一个字节序列表示一个对象，字节序列中存储对象的数据，类型和属性等信息，可以写出到文件，持久化存储。反之，还可以从文件中读取字节序列，重构对象，称为反序列化。

ObjectOutputStream 类

FileOutputStream fileOut = new FileOutputStream("employee.txt"); ObjectOutputStream out = new ObjectOutputStream(fileOut);

一个对象想要序列化，必须实现 Serializable 接口，对象内部的所有属性必须可序列化，如果有某个属性不需要序列化，可使用 transient 关键字修饰。

常用方法： writeObject（将指定的对象写出）

ObjectInputStream 类：

FileInputStream fileIn = new FileInputStream("employee.txt"); ObjectInputStream in = new ObjectInputStream(fileIn);

常用方法：readObject

如果能找到类对应的 class 文件，则反序列化成功，如果没有，则会抛出 ClassNotFoundException 异常。
如果找到的 class 文件在序列化对象之后发生了修改，则反序列化失败，抛出 InvalidClassException 异常。

Serializable 提供了序列版本号的功能，验证序列化对象和类的版本是否一致。

private static final long serialVersionUID = 1L; 
//指定1L，即使修改过类，反序列化也不会抛异常报错

TCP/IP 协议

应用层，传输层，网络层，数据链路层，物理层

TCP 面向连接，三次握手：

客户端向服务器发出请求，等待服务器确认
服务器向客户端发回一个相应，通知客户端已经收到了请求
客户端再次向服务器端发送确认信息，确认连接

UDP 面向无连接，直接传输不需要建立连接

网络编程三要素：协议，IP 地址，端口号

Socket 类

Socket：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

构造方法

Socket client = new Socket("127.0.0.1", 6666);

常用方法：getInputStream（返回此套接字的输入流），getOutputStream，close，shutdownOutput（禁用此套接字的输出流）

ServerSocket 类：这个类实现了服务器套接字，该对象等待通过网络的请求。

ServerSocket server = new ServerSocket(6666);

常用方法：accept（侦听并接受连接，返回一个新的 Socket 对象，用于和客户端实现通信）

注解

注解是给计算机看的，注释是给程序员看的。也叫元数据，一种代码级别的说明。

反射

将类的各个组成部分封装为其他对象。

可以在程序运行过程中操作这些对象，可以解耦，提高程序可扩展性。

获取 class 对象的方式：

Class.forName("全类名")，用于配置文件
类名.class，用于参数传递
对象.getClass()，用于对象获取字节码

同一个字节码文件在一次程序运行过程中只会被加载一次。

class 对象功能：获取成员变量 Field，获取构造方法 Constructor，获取成员方法 Method，获取全类名

如何解决无法使用最新的 springboot--2.2.6.RELEASE 下载 dependencies

到 maven 的 settings.xml 里注释掉阿里云的镜像，让 maven 从官方库下载，就没问题了

@RestController 写在类上，导致类中的方法全部返回了 json 数据，无法通过视图解析器跳转到页面

@RestController 是包括 @Controller 和 @ResponseBody 的组合注解

@Repository 和 @Mapper 注解的区别

@Mapper 注解是 Mybatis 的注解，是用来说明这个是一个 Mapper，对应的 xxxMapper.xml 就是来实现这个 Mapper。然后在 service 层使用 @Autowired 注解注入。 @Repository 注解是 Spring 的注解，使用该注解把当前类注册成一个 bean，再使用 @Autowired注入。接口上的 @Mapper 也是可以去掉的，但是要在启动类上加上 @MapperScan(value = {"cn.yltang.mapper"})。这句话的意思是在指定位置扫描 Mapper 类。

前置通知

切入点方法之前执行

MVC 设计模式

model模型层，封装数据，实体类；view视图层，jsp，html，展示数据；controller控制层，处理程序逻辑

SpringMVC 中返回 String 时 return 的写法

return "main"，返回视图。
需要携带request用forward，不需要则redirect。
相对路径不带/，绝对路径带/。

#{} 与 ${} 的区别

#{}表示一个占位符号，通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换， #{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称。

${} 表示拼接 sql 串，通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

MyBatis 设计模式

工厂模式 SqlSessionFactory，代理模式 MapperProxyFactory，构建者模式 SqlSessionFactoryBuilder

MyBatis 自动提交事务的设置

@Test 
public void testSaveUser() throws Exception {   
    User user = new User();   
    user.setUsername("mybatis user09"); 
    //6.执行操作   
    int res = userDao.saveUser(user);   
    System.out.println(res);   
    System.out.println(user.getId());  
}   
@Before//在测试方法执行之前执行  
public void init()throws Exception { 
    //1.读取配置文件   
    in = Resources.getResourceAsStream("SqlMapConfig.xml");   
    //2.创建构建者对象   
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();   
    //3.创建 SqlSession 工厂对象   
    factory = builder.build(in);
    //4.创建 SqlSession 对象   
    session = factory.openSession(); //传递一个 true 打开自动提交事务
    //5.创建 Dao 的代理对象   
    userDao = session.getMapper(IUserDao.class);  
}   
@After//在测试方法执行完成之后执行  
public void destroy() throws Exception{   
    //7.提交事务 
    session.commit(); //自动提交事务则此行不需要
    //8.释放资源
    session.close();
    in.close();  
}

Mybatis 延迟加载

就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载

好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

<settings> 
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/> 
</settings>

Mybatis 缓存

一级缓存：是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。
二级缓存：是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。需要开启。

<settings> 
    <!-- 开启二级缓存的支持 -->  
    <setting name="cacheEnabled" value="true"/>
</settings>

Mybatis 接口绑定

与映射文件名相同，基于动态代理来生成对象执行sql

Mybatis 和 hebernate

h是通过实体映射模型全自动，m是写sql半自动

Mybatis 核心对象

SqlSessionFactory

MySQL5.7 之后修改默认密码

ALTER USER 'root'@'localhost' IDENTIFIED BY 'root密码';

增删改

insert into 表名(列名1,列名2,...列名n) values(值1,值2,...值n);
delete from 表名 [where 条件]
update 表名 set 列名1 = 值1, 列名2 = 值2,... [where 条件];

查询

select
    字段列表
from
    表名列表
where
    条件列表
group by
    分组字段
having
    分组之后的条件
order by
    排序
limit
    分页限定

多个字段查询

select 字段名1，字段名2... from 表名；

去除重复

select distinct 字段名1，字段名2... from 表名；

where 条件

* > 、< 、<= 、>= 、= 、<>
* BETWEEN...AND  
* IN( 集合) 
* LIKE：模糊查询
    * 占位符：
    	* _:单个任意字符
    	* %：多个任意字符
* IS NULL  
* and  或 &&
* or  或 || 
* not  或 !
    	
-- 查询年龄大于等于20 小于等于30
    		
SELECT * FROM student WHERE age >= 20 &&  age <=30;
SELECT * FROM student WHERE age >= 20 AND  age <=30;
SELECT * FROM student WHERE age BETWEEN 20 AND 30;
    		
-- 查询年龄22岁，18岁，25岁的信息
SELECT * FROM student WHERE age = 22 OR age = 18 OR age = 25
SELECT * FROM student WHERE age IN (22,18,25);
    		
-- 查询英语成绩为null			
SELECT * FROM student WHERE english IS NULL;
    		
-- 查询英语成绩不为null
SELECT * FROM student WHERE english  IS NOT NULL;
    		
-- 查询姓马的有哪些？ like
SELECT * FROM student WHERE NAME LIKE '马%';
    		
-- 查询姓名第二个字是化的人
SELECT * FROM student WHERE NAME LIKE "_化%";
    		
-- 查询姓名是3个字的人
SELECT * FROM student WHERE NAME LIKE '___';

-- 查询姓名中包含德的人
SELECT * FROM student WHERE NAME LIKE '%德%';

排序分组

-- 排序 ASC：升序，默认的。DESC：降序。 
order by 排序字段1 排序方式1 ，  排序字段2 排序方式2...

-- 聚合函数
1. count：计算个数
    1. 一般选择非空的列：主键
    2. count(*)
2. max：计算最大值
3. min：计算最小值
4. sum：计算和
5. avg：计算平均值
* 注意：聚合函数的计算，排除null值。
    	解决方案：
    		1. 选择不包含非空的列进行计算
    		2. IFNULL函数

-- 分组查询
    1. 语法：group by 分组字段；
    2. 注意：
    	1. 分组之后查询的字段：分组字段、聚合函数
    	2. where 和 having 的区别？
    		1. where 在分组之前进行限定，如果不满足条件，则不参与分组。having在分组之后进行限定，如果不满足结果，则不会被查询出来
    		2. where 后不可以跟聚合函数，having可以进行聚合函数的判断。

    	-- 按照性别分组。分别查询男、女同学的平均分

    	SELECT sex , AVG(math) FROM student GROUP BY sex;
    	
    	-- 按照性别分组。分别查询男、女同学的平均分,人数
    	
    	SELECT sex , AVG(math),COUNT(id) FROM student GROUP BY sex;
    	
    	--  按照性别分组。分别查询男、女同学的平均分,人数 要求：分数低于70分的人，不参与分组
    	SELECT sex , AVG(math),COUNT(id) FROM student WHERE math > 70 GROUP BY sex;
    	
    	--  按照性别分组。分别查询男、女同学的平均分,人数 要求：分数低于70分的人，不参与分组,分组之后。人数要大于2个人
    	SELECT sex , AVG(math),COUNT(id) FROM student WHERE math > 70 GROUP BY sex HAVING COUNT(id) > 2;
    	
    	SELECT sex , AVG(math),COUNT(id) 人数 FROM student WHERE math > 70 GROUP BY sex HAVING 人数 > 2;

-- 分页查询
    1. 语法：limit 开始的索引,每页查询的条数;
    2. 公式：开始的索引 = （当前的页码 - 1） * 每页显示的条数
    	-- 每页显示3条记录 

    	SELECT * FROM student LIMIT 0,3; -- 第1页
    	
    	SELECT * FROM student LIMIT 3,3; -- 第2页
    	
    	SELECT * FROM student LIMIT 6,3; -- 第3页

    3. limit 是一个MySQL"方言"

约束

* 概念： 对表中的数据进行限定，保证数据的正确性、有效性和完整性。	
* 分类：
    1. 主键约束：primary key 自增 auto_increment
    2. 非空约束：not null
    3. 唯一约束：unique
    4. 外键约束：foreign key

-- 外键约束
foreign key,让表于表产生关系，从而保证数据的正确性。
    1. 在创建表时，可以添加外键
    	* 语法：
    		create table 表名(
    			....
    			外键列
    			constraint 外键名称 foreign key (外键列名称) references 主表名称(主表列名称)
    		);

    2. 删除外键
    	ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;

    3. 创建表之后，添加外键
    	ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段名称) REFERENCES 主表名称(主表列名称);
    4. 级联操作
    	1. 添加级联操作
    		语法：ALTER TABLE 表名 ADD CONSTRAINT 外键名称 
    				FOREIGN KEY (外键字段名称) REFERENCES 主表名称(主表列名称) ON UPDATE CASCADE ON DELETE CASCADE  ;
    	2. 分类：
    		1. 级联更新：ON UPDATE CASCADE 
    		2. 级联删除：ON DELETE CASCADE

多表查询

-- 内连接查询：
    		1. 从哪些表中查询数据
    		2. 条件是什么
    		3. 查询哪些字段
-- 隐式内连接：使用where条件消除无用数据
    		* 例子：
    		-- 查询所有员工信息和对应的部门信息

    		SELECT * FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
    		
    		-- 查询员工表的名称，性别。部门表的名称
    		SELECT emp.name,emp.gender,dept.name FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
    		
    		SELECT 
    			t1.name, -- 员工表的姓名
    			t1.gender,-- 员工表的性别
    			t2.name -- 部门表的名称
    		FROM
    			emp t1,
    			dept t2
    		WHERE 
    			t1.`dept_id` = t2.`id`;
-- 显式内连接：
    		* 语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件
    		* 例如：
    			* SELECT * FROM emp INNER JOIN dept ON emp.`dept_id` = dept.`id`;	
    			* SELECT * FROM emp JOIN dept ON emp.`dept_id` = dept.`id`;	

-- 外链接查询：
    	1. 左外连接：
    		* 语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
    		* 查询的是左表所有数据以及其交集部分。
    		* 例子：
    			-- 查询所有员工信息，如果员工有部门，则查询部门名称，没有部门，则不显示部门名称
    			SELECT 	t1.*,t2.`name` FROM emp t1 LEFT JOIN dept t2 ON t1.`dept_id` = t2.`id`;
    	2. 右外连接：
    		* 语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
    		* 查询的是右表所有数据以及其交集部分。
    		* 例子：
    			SELECT 	* FROM dept t2 RIGHT JOIN emp t1 ON t1.`dept_id` = t2.`id`;

-- 子查询：
    	* 概念：查询中嵌套查询，称嵌套查询为子查询。
    		-- 查询工资最高的员工信息
    		-- 1 查询最高的工资是多少 9000
    		SELECT MAX(salary) FROM emp;
    		
    		-- 2 查询员工信息，并且工资等于9000的
    		SELECT * FROM emp WHERE emp.`salary` = 9000;
    		
    		-- 一条sql就完成这个操作。子查询
    		SELECT * FROM emp WHERE emp.`salary` = (SELECT MAX(salary) FROM emp);

    	* 子查询不同情况
    		1. 子查询的结果是单行单列的：
    			* 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
    			* 
    			-- 查询员工工资小于平均工资的人
    			SELECT * FROM emp WHERE emp.salary < (SELECT AVG(salary) FROM emp);
    		2. 子查询的结果是多行单列的：
    			* 子查询可以作为条件，使用运算符in来判断
    			-- 查询'财务部'和'市场部'所有的员工信息
    			SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部';
    			SELECT * FROM emp WHERE dept_id = 3 OR dept_id = 2;
    			-- 子查询
    			SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部');

    		3. 子查询的结果是多行多列的：
    			* 子查询可以作为一张虚拟表参与查询
    			-- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
    			-- 子查询
    			SELECT * FROM dept t1 ,(SELECT * FROM emp WHERE emp.`join_date` > '2011-11-11') t2
    			WHERE t1.id = t2.dept_id;
    			
    			-- 普通内连接
    			SELECT * FROM emp t1,dept t2 WHERE t1.`dept_id` = t2.`id` AND t1.`join_date` >  '2011-11-11'

事务

如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。

开启事务： start transaction;
回滚：rollback;
提交：commit;

事务提交的两种方式：

自动提交：mysql就是自动提交的，一条DML(增删改)语句会自动提交一次事务

手动提交：Oracle 数据库默认是手动提交事务，需要先开启事务，再提交

事务的四大特征：

原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
持久性：当事务提交或回滚后，数据库会持久化的保存数据。
隔离性：多个事务之间。相互独立。
一致性：事务操作前后，数据总量不变

隔离级别：

read uncommitted：读未提交，产生的问题：脏读、不可重复读、幻读
read committed：读已提交（Oracle）产生的问题：不可重复读、幻读
repeatable read：可重复读（MySQL默认）产生的问题：幻读
serializable：串行化，可以解决所有的问题

批量将数据库中的某个字段的部分字符串更新

UPDATE T SET images = REPLACE(images,'#','*')

数据表 A 操作三题

name	class	grade
张三	英语	31
张三	语文	49
李四	数学	90
王五	英语	45
王五	语文	57
李四	化学	51
王五	化学	70
李四	语文	81

使用 MySQL 语法。用一个 sql 语句查询出每门课都小于 60 分的学生姓名

SELECT
    NAME
FROM
    A
GROUP BY
    NAME
HAVING
    max(grade) < 60;

SELECT DISTINCT
    NAME
FROM
    A
WHERE
    NAME NOT IN (
    	SELECT DISTINCT
    		NAME
    	FROM
    		A
    	WHERE
    		grade >= 60
    );

使用 MySQL 语法。用一个 sql 查出出现次数大于 3 次的人名

SELECT DISTINCT
    NAME
FROM
    A
WHERE
    NAME IN (
    	SELECT
    		NAME
    	FROM
    		A
    	GROUP BY
    		NAME
    	HAVING
    		COUNT(NAME) >= 3
    );

使用 MySQL 语法。用一个 sql 查询以下结果，如果分数 0-59 展示不及格 , 60-79 展示良好，80-100 展示优秀

name	class	level
张三	英语	不及格
张三	语文	不及格
李四	数学	优秀
王五	英语	不及格
王五	语文	不及格
李四	化学	不及格
王五	化学	良好
李四	语文	优秀

SELECT name,class,
    (
    	CASE
    	WHEN grade >= 80 THEN
    		'优秀'
    	WHEN grade <= 59 THEN
    		'不及格'
    	ELSE
    		'良好'
    	END
    ) as level
FROM
    A;

合并两个数据表

select * from T1 union all select * from T2;

输出数据表中相同的字段

select * from T where name in (select name from T group by name having count(*)>1);

在已有的表中添加列（字段）

ALTER TABLE people ADD name VARCHAR(100);

删除数据表 A 中 name 字段为空的数据

delete from A where name is null;

查询科目语文分数大于 90 分的学生列表

SELECT * FROM A where id in(SELECT id from B WHERE score>90 and SUBJECT = "语文");

查询名字为张三的所有科目的成绩

SELECT * FROM B where id in(SELECT id from A WHERE name = "张三";

实体类注解

表名默认使用类名,驼峰转下划线(只对大写字母进行处理),如UserInfo默认对应的表名为user_info。
表名可以使用@Table(name = "tableName")进行指定,对不符合第一条默认规则的可以通过这种方式指定表名.
字段默认和@Column一样,都会作为表字段,表字段默认为Java对象的Field名字驼峰转下划线形式.
可以使用@Column(name = "fieldName")指定不符合第3条规则的字段名
使用@Transient注解可以忽略字段,添加该注解的字段不会作为表字段使用.如果你的实体类中包含了不是数据库表中的字段，你需要给这个字段加上@Transient注解，这样通用Mapper在处理单表操作时就不会将标注的属性当成表字段处理！
建议一定是有一个@Id注解作为主键的字段,可以有多个@Id注解的字段作为联合主键.
默认情况下,实体类中如果不存在包含@Id注解的字段,所有的字段都会作为主键字段进行使用(这种效率极低).
实体类可以继承使用,可以参考测试代码中的tk.mybatis.mapper.model.UserLogin2类.
由于基本类型,如int作为实体类字段时会有默认值0,而且无法消除,所以实体类中建议不要使用基本类型.
主键回显：@GeneratedValue(strategy = GenerationType.IDENTITY)

常用接口方法

基础接口

Select

接口：SelectMapper 方法：List select(T record); 说明：根据实体中的属性值进行查询，查询条件使用等号

接口：SelectByPrimaryKeyMapper 方法：T selectByPrimaryKey(Object key); 说明：根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号

接口：SelectAllMapper 方法：List selectAll(); 说明：查询全部结果，select(null)方法能达到同样的效果

接口：SelectOneMapper 方法：T selectOne(T record); 说明：根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常，查询条件使用等号

接口：SelectCountMapper 方法：int selectCount(T record); 说明：根据实体中的属性查询总数，查询条件使用等号

Insert

接口：InsertMapper 方法：int insert(T record); 说明：保存一个实体，null的属性也会保存，不会使用数据库默认值

接口：InsertSelectiveMapper 方法：int insertSelective(T record); 说明：保存一个实体，null的属性不会保存，会使用数据库默认值

Update

接口：UpdateByPrimaryKeyMapper 方法：int updateByPrimaryKey(T record); 说明：根据主键更新实体全部字段，null值会被更新

接口：UpdateByPrimaryKeySelectiveMapper 方法：int updateByPrimaryKeySelective(T record); 说明：根据主键更新属性不为null的值

Delete

接口：DeleteMapper 方法：int delete(T record); 说明：根据实体属性作为条件进行删除，查询条件使用等号

接口：DeleteByPrimaryKeyMapper 方法：int deleteByPrimaryKey(Object key); 说明：根据主键字段进行删除，方法参数必须包含完整的主键属性

base 组合接口

接口：BaseSelectMapper 方法：包含上面Select的4个方法

接口：BaseInsertMapper 方法：包含上面Insert的2个方法

接口：BaseUpdateMapper 方法：包含上面Update的2个方法

接口：BaseDeleteMapper 方法：包含上面Delete的2个方法

CRUD 组合接口

接口：BaseMapper 方法：继承了base组合接口中的4个组合接口，包含完整的CRUD方法

Example 方法

接口：SelectByExampleMapper 方法：List selectByExample(Object example); 说明：根据Example条件进行查询 重点：这个查询支持通过Example类指定查询列，通过selectProperties方法指定查询列

接口：SelectCountByExampleMapper 方法：int selectCountByExample(Object example); 说明：根据Example条件进行查询总数

接口：UpdateByExampleMapper 方法：int updateByExample(@Param("record") T record, @Param("example") Object example); 说明：根据Example条件更新实体record包含的全部属性，null值会被更新

接口：UpdateByExampleSelectiveMapper 方法：int updateByExampleSelective(@Param("record") T record, @Param("example") Object example); 说明：根据Example条件更新实体record包含的不是null的属性值

接口：DeleteByExampleMapper 方法：int deleteByExample(Object example); 说明：根据Example条件删除数据

Example 组合接口

接口：ExampleMapper 方法：包含上面Example中的5个方法

Condition 方法

Condition方法和Example方法作用完全一样，只是为了避免Example带来的歧义，提供的的Condition方法

接口：SelectByConditionMapper 方法：List selectByCondition(Object condition); 说明：根据Condition条件进行查询

接口：SelectCountByConditionMapper 方法：int selectCountByCondition(Object condition); 说明：根据Condition条件进行查询总数

接口：UpdateByConditionMapper 方法：int updateByCondition(@Param("record") T record, @Param("example") Object condition); 说明：根据Condition条件更新实体record包含的全部属性，null值会被更新

接口：UpdateByConditionSelectiveMapper 方法：int updateByConditionSelective(@Param("record") T record, @Param("example") Object condition); 说明：根据Condition条件更新实体record包含的不是null的属性值

接口：DeleteByConditionMapper 方法：int deleteByCondition(Object condition); 说明：根据Condition条件删除数据

Condition 组合接口

接口：ConditionMapper 方法：包含上面Condition中的5个方法

RowBounds

默认为内存分页，可以配合PageHelper实现物理分页

接口：SelectRowBoundsMapper 方法：List selectByRowBounds(T record, RowBounds rowBounds); 说明：根据实体属性和RowBounds进行分页查询

接口：SelectByExampleRowBoundsMapper 方法：List selectByExampleAndRowBounds(Object example, RowBounds rowBounds); 说明：根据example条件和RowBounds进行分页查询

接口：SelectByConditionRowBoundsMapper 方法：List selectByConditionAndRowBounds(Object condition, RowBounds rowBounds); 说明：根据example条件和RowBounds进行分页查询，该方法和selectByExampleAndRowBounds完全一样，只是名字改成了Condition

RowBounds 组合接口

接口：RowBoundsMapper 方法：包含上面RowBounds中的前两个方法，不包含selectByConditionAndRowBounds

special 特殊接口

这些接口针对部分数据库设计，不是所有数据库都支持

接口：InsertListMapper 方法：int insertList(List recordList); 说明：批量插入，支持批量插入的数据库可以使用，例如MySQL,H2等，另外该接口限制实体包含id属性并且必须为自增列

接口：InsertUseGeneratedKeysMapper 方法：int insertUseGeneratedKeys(T record); 说明：插入数据，限制为实体包含id属性并且必须为自增列，实体配置的主键策略无效

MySQL 专用

接口：MySqlMapper 继承方法：int insertList(List recordList); 继承方法：int insertUseGeneratedKeys(T record); 说明：该接口不包含方法，继承了special中的InsertListMapper和InsertUseGeneratedKeysMapper

Jsp 四个作用域九个内置对象

名称	作用域
application	在所有应用程序中有效
session	在当前会话中有效
request	在当前请求中有效
page	在当前页面有效

out，request，response，session，application，pageContext，page，config，exception

常用快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Ins	自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头	移动当前代码行

IDEA 将包展开

右键项目目录左边竖向的Project按钮，取消勾选Compact Middle Packages。

IDEA 设置项目文件夹类型

在任意需要更改类型的文件夹上右键选择Make Directory as。
File-Project Structure-Modules。

IDEA设置背景图片

双击shift搜索
输入image

Cannot access org.springframework.context.ConfigurableApplicationContext

新导入项目，提示报 Cannot access org.springframework.context.ConfigurableApplicationContext的错，百度一番，需删除导入项目自动生成的xxx.iml ，然后刷新下右侧maven tab即可，这里记录一下。

创建版本库

在需要创建版本库的目录下执行：

git init

会创建一个隐藏的.git目录。

Git 工作流程

从远程仓库克隆项目至本地：

git clone https://github.com/luhexyz/site-Blog.git

在本地仓库中checkout代码并修改；
将代码提交到暂存区：

git add .

提交修改到本地仓库：

git commit -m "message"

将改动推送到远程仓库：

git push

从远程仓库拉取并合并代码：

git pull

Git 设置代理

Windows 下的命令行 CMD 设置代理：

set https_proxy=http://127.0.0.1:1080

在 Git 里设置代理：

git config --global https.proxy https://127.0.0.1:1080

取消代理：

git config --global --unset https.proxy

macOS 下的命令设置代理：

export https_proxy=socks5://127.0.0.1:7891

添加子模块

git submodule add <url> <path>

此时子模块文件夹里是空的，在项目根目录执行：

git submodule initgit submodule update

或者：

git submodule update --init --recursive

即可下载子模块代码。

若在整个项目clone时添加--recursive，也可以下载子模块代码：

git clone --recursive https://github.com/luhexyz/site-Blog.git

删除子模块

Kepler为子模块名。

git rm --cached Kepler
rm -rf Kepler

删除.gitmodules文件中的相关模块信息：

[submodule "Kepler"]
  path = Kepler
  url = https://github.com/AlanDecode/Maverick-Theme-Kepler.git

删除.git/config中的相关子模块信息：

[submodule "Kepler"]
  url = https://github.com/AlanDecode/Maverick-Theme-Kepler.git

删除.git文件夹中的相关子模块文件：

rm -rf .git/modules/Kepler