牛客Java刷题总结
1. java.awt**：**提供了绘图和图像类，主要用于编写GUI程序，包括按钮、标签等常用组件以及相应的事件类。
2. java.lang**：**java的语言包，是核心包，默认导入到用户程序，包中有object类，数据类型包装类，数学类，字符串类，系统和运行时类，操作类，线程类，错误和异常处理类，过程类。
3. java.io**：**包含提供多种输出输入功能的类。
4. java.net**：** 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET等。
5. java.applet**：**包含java小应用程序的类。
6. java.util**：**包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包。
7. java.sql**：**提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API
方法重写
1. 参数 方法名 返回值类型相同
2. 子类访问权限大于等于父类
3. 子类抛出异常小于等于父类
final
final类的方法能否被同一个包的类访问不是由final决定，final只管能不能修改，不管访问
switch
switch的执行是相当于一堆if 从上到下，而不是else if，所以中间需要使用break 进行阻断
switch 的括号里 可填入的类型有 String char int short byte;
https://www.nowcoder.com/test/question/done?tid=51697096&qid=26058#summary
try catch finally
/*
try 中如果有了一场那么就跳到catch中，
如果try中有return 并且存在finally 的话，那么先执行finally 在执行return
finally 无论有没有都会执行
不管catch 是否捕获异常 finally中的语句块都是要被执行的
在try 语句块或catch语句中执行到System.exit(0) 会直接推出程序
finally 块中的return 语句会覆盖try块中的return返回
finally 中的语句块在catch 语句块中的return 语句执行后执行， 但是只是在执行了return 后，会将结果记下，然后执行finally 中的结果，最终在返回记下的结果
*/
取余符号中含有负数
System.out.println(12%5); 2
System.out.println(-12%5); -2
System.out.println(12%-5); 2
System.out.println(-12%-5); -2
被取余的符合和答案的符号一致
servlet 的service方法到底是怎么执行的
servlet 的service方法通过重写do***（）方法来执行
service方法，一般来说这个方法是不需要重写的，因为在HttpServlet中已经有了很好的实现，它会根据请求的方式，调用doGet，doPos以及其他的doXXXt方法，也就是说service是用来转向的，所以我们一般写一个servlet，只需要重写doGet或者doPost就可以了。
servlet 的生命周期
服务器启动的时候（web.xml配置load-on-startup = 1）,默认为0 或者第一次请求该servlet时，就会初始化一个对象，也就是会执行初始化方法（init），该servlet对象去处理所有对象的客户端请求，在service（req，resp）方法中执行，使用destroy方法去销毁
Java的三大注解
2.@Override 注解表名子类中覆盖了超类中的某个方法，如果写错了覆盖形式，编译器会报错
3.@Deprecated 表明不希望别人在以后使用这个类，方法，变量等等
4.@Suppresswarnings 达到抑制编译器产生警告的目的，但是不建议使用，因为后期编码人员看不懂编译器提示的警告，不能更好的选择更好的类去完成任务
父类与 子类的初始化
如果一个类有其父类的话，那么在在创建一个子类的实例的时候，会调用指定的父类的构造函数，
如果没有指定，就会默认调用无参的构造函数，如果父类没有无参构造，那么就会报错
赋值符号
<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符
Collection接口的继承体系
Collection
List Set
ArrayLIst LinkedList Vector hashset linkedHashSet TreeSet
java中的字节流和字符流
字节流：
InputStream
|-- FileInputStream (基本文件流）
|-- BufferedInputStream
|-- DataInputStream
|-- ObjectInputStream
字符流
Reader
|-- InputStreamReader (byte->char 桥梁）
|-- BufferedReader (常用）
Writer
|-- OutputStreamWriter (char->byte 桥梁）
|-- BufferedWriter
|-- PrintWriter （常用）
可以获取cookie的方法
request.getHeader
request.getCookies
1）Cookie[] getCookies()
返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。
2）Object getAttribute(String name)
以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。
3）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；
4）String getParameter(String name)
以字符串形式返回请求参数的值，或者如果参数不存在则返回 null
java 小数处理
double d1=12.5;
System.out.println("Ceil d1="+Math.ceil(d1));//13.0 // 向下取整
System.out.println("floor d1="+Math.floor(d1));//12.0 向上取整
System.out.println("Round d1 = "+ Math.round(d1));//13 四舍五入
对于 Math.round 正数四舍五入 负数六舍五入
System.out.println(String.format("%.2f", d1));//12.50 四舍五入保留两位小数
String StringBuilder StringBUffer
一般来讲的运行效率
StringBuilder > StringBuffer > String
区别
StringBuffer 可变字符序列 效率低 线程安全
StringBuilder 可变字符序列， 效率高 线程不安全
String 使用陷阱
类的初始化过程
初始化 父类中的静态成员变量和静态代码块
初始化子类中的静态成员变量 和 静态代码块
初始化父类中的普通成员变量在执行父类的静态构造方法
初始化子类中的普通成员变量再执行子类中的静态构造方法
接口和抽象类的区别
1. 关键字
抽象类
1.8 以前 抽象类的方法默认为 protected
1.8 时 抽象类的默认访问权限为default
可以定义调用 静态方法
但是 public 和 protect 也都可以
接口 1.8 以前接口中的方法必须是public
1.8 允许 public abstract static 和 strictfp（精确浮点）
1.9 时接口中的方法可以时private
2.抽象类单继承 接口可以多实现，并且在接口之间可以实现多继承
3. 抽象类允许包含某些方法的实现，而接口是不允许的；
接口中的变量 是 public static final 类型
接口中的方法 默认是 public abstract
线程中的join方法
线程中的join方法，是将该线程加入到当前的线程，比如 在线程B中 A.join()，那么之后当A执行完之后才回去执行线程B
Java关键字
在看题的时候要区分标识符和关键字i
标识符的明明规范是
Java标识符命名规范是：
1）只能包含字母a-zA-Z，数字0-9，下划线_和美元符号$；
2）首字母不能为数字；
3）关键字和保留字不能作为标识符。
Java中的位运算操作
&按位与
|按位或
~按位取反
^按位异或
>>右移
>>>无符号右移
<<左移
表达式(short)10/10.2*2运算后结果类型是
首先要注意的是 (short)10/10.2*2 而不是 (short) (10/10.2*2)，又因为式子中存在浮点数，所以结果会进行自动类型的提升，浮点数默认为double，所以答案是double
父类和子类之间的调用
只要是被子类重写的方法，不被super调用都是调用子类方法
假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？
public class Base
{
public void methodOne()
{
System.out.print("A");
methodTwo();
}
public void methodTwo()
{
System.out.print("B");
}
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print("C");
}
public void methodTwo()
{
super.methodTwo();
System.out.print("D");
}
}结果为ABDC
JavaEE中的包
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.
mysql中的组合索引
常见的代码优化技术
常见的代码优化技术有：复写传播，删除死代码, 强度削弱，归纳变量删除
（下面抄几页PPT和别人的博客，QAQ，关键是编译原理没认真学过，咱家不太会。。。)
如果有同学有研究过这部分内容，并总结过，有更好的答案，请联系我删除本篇非原创解答
复写传播:
图片说明
复写语句：形式为f = g 的赋值
优化过程中会大量引入复写
复写传播变换的做法是在复写语句f = g后，尽可能用g代表f
复写传播变换本身并不是优化，但它给其他优化带来机会
常量合并（编译时可完成的计算）
死代码删除
死代码删除
死代码是指计算的结果决不被引用的语句
一些优化变换可能会引起死代码
代码外提
代码外提是循环优化的一种
循环优化的其它重要技术
归纳变量删除
强度削弱
while(i <= limit - 2) ...
// 代码外提后变成
t = limit - 2;
while(i <= t) ...
归纳变量删除
复制代码
j = j - 1
t4 = 4 * j
t5 = a[t4]
if t5 > value goto B3
j和t4的值步伐一致地变化，这样的变量叫作归纳变量
在循环中有多个归纳变量时，也许只需要留下一个
这个操作由归纳变量删除过程来完成
对本例可以先做强度削弱，它给删除归纳变量创造机会
强度削弱
强度削弱的本质是把强度大的运算换算成强度小的运算，例如将乘法换成加法运算。
Java中四种包的访问权限
public 当前类 同包 子类 其他
protect 当前类 同包 子类
default 当前类 同包
private 当前类
已知有下列Test类的说明，在该类的main方法的横线处，则下列哪个语句是正确的？（）
public class Test
{
private float f = 1.0f;
int m = 12;
static int n = 1;
public static void main (String args[])
{
Test t = new Test();
————————
}
}
A t.f = 1 B this.n = 1; C Test.m = 1; D Test.f = 1;
A : 虽然是在main方法中，但仍然是在当前类中，所以仍然是可以调用private 变量
B : this 不能在静态方法中使用
C : 使用类名只能调用静态变量
D : 和 C 相同
JDBC 中 Statement PrepareStatement 和 CallableStatement 的区别
联系
1. Statement PrerpareStatement 和 CallableStatement 都是接口
2. Statement 继承自Wrapper， PrepareStatement 继承自Statement， CallableStatement 继承自PrepareStatement
不同点
包含方法
2. Statement 接口提供了执行语句和获取结果的基本方法
PrepareStatement 接口添加了处理IN参数的方法
CallableStatement接口添加了处理OUT参数的方法
性能
3. Statement 普通的不带参的查询sql；支持批量更新 批量删除
PrepareStatement 可变参数的sql，编译一次多次执行，效率高
安全性好，可以防止sql注入的风险
支持批量更新批量删除
CallableStatement 支持调用存储过程,提供了对输出和输入/输出参数(INOUT)的支持;
JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
https://blog.csdn.net/qq_35448976/article/details/68107591
System.gc()
用于自主垃圾回收
但是 这个方法只是提醒JVM可以进行一次Full GC，但是真正什么时候执行，还是不确定的
Java中实现同步的两种方式
同步块
对于同步来说，都是使用synchronized 方法
每一个对象都有一个监视器，或者叫锁
同步块实例
package ticket;
class Tickets {
public static void main(String[] args)
{
sellTickets st = new sellTickets(); //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket new Thread(st).start(); new Thread(st).start(); new Thread(st).start(); new Thread(st).start();
}
}
class sellTickets implements Runnable {
int ticket = 100;
Object o = new Object();
@Override public void run() { while(true)
{ //每一个对象都有一个监视器，或者叫做锁。同步块示例 synchronized (o) { if(ticket > 0)
{ //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期 try { //线程睡眠,该方法需要写异常 Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
} //第几个线程卖出了第多少张票 System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
ticket--;
}
}
}
}
}
Java和 C++ 都具有封装 继承 和多态
下面复制语句正确的是
double d = 5.3e12 正确
float f = 11.1 错误，在Java中默认的浮点数是double，所以这里要实现强转，
在Java中定义float变量的方法 （float）11.1 或者11.1f
ServletConfig接口默认是哪里实现的？
GenericServlet类的实现接口中包括了ServletConfig接口，但是它自身的init(ServletConfig config)方法又需要外界给它传递一个实现ServletConfig的对象，就是说GenericServlet和ServletConfig的依赖关系既是继承关系，也是一种关联关系。
Java中的字符流和字节流
一般辨认 字符流都是writer 和 Reader
字节流都是 Stream
Java中并发编程的同步器
常用
CountDowmLatch
Semaphore
不常用
Barrer
Exchanger
Socket 通信编程
判断操作是否需要同步
判断是否是原子操作，是则不需要
Java内存区域
Java的jvm内存可分为三个区， 堆 栈方法区
每个线程包含一个栈区，栈中只保存方法中（不包括对象的成员变量）的基础数据类型和自定义对象的引用(不是对象)，对象都存放在堆区中
每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
堆区:
存储的全部是对象实例，每个对象都包含一个与之对应的class的信息(class信息存放在方法区)。
jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身，几乎所有的对象实例和数组都在堆中分配。
方法区:
又叫静态区，跟堆一样，被所有的线程共享。它用于存储已经被虚拟机加载的类信息、常量、静态变量
局部内部类（不加访问修饰符，只能加 abstract 和 final）
public class OutterType {
public void function() {
/** 局部内部类Inner*/
class Inner {
public void print() {
System.out.println("局部内部类...");
}
}
}
}
外部类
外部类的修饰符只能是 public default
成员内部类(可以使用public protected private 进行修饰)
class Circle {
double radius = 0;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println("drawshape");
}
}
}
接口中的变量
接口中的变量默认是由
public static final 进行修饰的
ArrayLIst 和 LinkedList 比较
ArrayList 增删慢 查询快
/*
由于是基于数组是心啊，需要连续的内存空间，如果删除数组中间的值，为了保证下标有效性，所以要将后面的数据往前移，所以删除慢，
当插入A 到 B 的前面的时候，要将 B 往后的对象都往后移一位，所以慢
因为数组的大小是固定的，如果数组满了，就要重新分配空间，然后将旧的数据copy到新new的数组中，所以增加慢
*/
/*
因为是连续空间，可以通过下标查询数据 所以查询块
*/
LinkedList 增删快 查询慢
/*
由于是链表实现，当前节点的next 指向下一个节点，prev 指向上一个节点，不需要连续的存储空间，所以增删快，因为不是连续内存空间，所以不能使用下标查询，只能通过 next 遍历
*/
int i = 5;
int j = 10;
System.out.println(i + ~j);
/*
公式-n=~n+1可推出~n=-n-1，所以~10=-11再加5结果为-6
*/
final 关键字
/*
修饰类 那么这个类不能再被继承
修饰变量 那么这个变量只能被赋值一次 并且 需要被初始化
修饰方法 那么这个方法就不能再被重写 可以被重载
*/
Java中创建对象的方法
1. 使用new 关键字
2. 使用反射的Class 类的newInstance() 方法
3. 使用泛着的 Construcor 类的newInstance方法
4. 使用 使用对象克隆clone()方法： ObjectName obj = obj.clone();
5. 使用反序列化（ObjectInputStream）的readObject()方法：
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }
Integer 的自动装箱 和 自动拆箱
在这里 a1 == a2 Integer 自动装箱的范围是 -127 ~ 128，所以不相等
d1 = d2 d1 自动拆箱得到 2017 所以 和 d2 相等
四种引用
强
弱
虚
软
二维数组创建方法
float []f[] = new float[6][6];
float f[][] = new float[6][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];
数组的比较
数组的 equals 是继承于Object 也即是说 ==，所以不会比较其中的内容
Arrays.equals(nums,nums) 是重写过了的，比较的是 其中的值
Object 中的方法
clone
equals
finallize
getClass()
notify
notityAll
hashCode
toString
wait()
count = count ++
count = count++ 原理是 temp = count； count = count+1 ； count = temp； 因此count始终是0 这仅限于java 与c是不一样的
HashMap特点
HashMap不能保证元素的顺序， 键值都可以是 null
值传递和引用传递
值传递 call by value
引用传递 call by reference
值传递不改变实际的值
引用传递会改变实际的值
值传递和引用传递都不会改变相应的地址
volatile 和 synchronized 的功能
volatile 保证 有序性 和 可见性
synchronized 保证 原子性 有序性 可见性
Java的数据库链接库JDBC使用到了那种设计模式
桥接模式 jdbc 提供两套接口，一个面向数据库厂商，一个面向数据库的使用者
数据类型
byte Boolean short char int float long double
1 1 2 2 4 4 8 8
import java.util.*;
只能访问该目录下的类不能访问该目录下的子目录的类
字符界面下接受用户从键盘输入，需要import的包是：
java.io包
关于静态块和构造块的加载
public class B
{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println("构造块");
}
static
{
System.out.println("静态块");
}
public static void main(String[] args)
{
B t = new B();
}
}
// 在加载静态域的时候，是根据代码的顺序进行加载的， 加载构造函数和构造块永远是按照先构造块后构造函数进行加载的
1.程序入口main方法要执行首先加载类 B，
2.静态域： 分为静态变量，静态方法，静态块。这里涉及到的是静态变量和静态块，当执行到静态域的时候，按照静态域的顺序加载，并且静态域只在类的第一次加载的时候执行。
3.每次new 对象的时候，会执行一次构造快和构造方法，构造快总是在构造方法前执行。
4.根据前三点，首先加载静态类B，执行静态域的第一个静态变量，t1,此时因为静态域已经加载过了，所以加载构造块和构造器，输出构造块和构造方法（这里的构造方法并没有输出什么），在加载t2的构造块并输出 构造块
5.此时在加载t的时候加载的静态域中的静态变量加载完了，下来加载静态块，输出静态块
6.此时 t的静态域加载完了，开始加载构造块和构造方法，输出 构造块
新线程的起点
public void run(){
}
start 方法是启动一个新的线程，当执行run方法的时候，线程才开始执行
Applet 类