牛客练习题

1. 建立Statement对象的作用是执行SQL语句
2. 正则表达式：
3. JAVA8的switch支持10种类型。byte char short int Byte,Short,Character,Integer String enum

1. 实际只支持int类型 Java实际只能支持int类型的switch语句，那其他的类型时如何支持的 a、基本类型byte char short 原因：这些基本数字类型可自动向上转为int, 实际还是用的int。 b、基本类型包装类Byte,Short,Character,Integer 原因：java的自动拆箱机制 可看这些对象自动转为基本类型 c、String 类型 原因：实际switch比较的string.hashCode值，它是一个int类型 如何实现的，网上例子很多。此处不表。 d、enum类型 原因 ：实际比较的是enum的ordinal值（表示枚举值的顺序），它也是一个int类型 所以也可以说 switch语句只支持int类型

1. 局部内部类、成员内部类、匿名内部类、final。

1. Dbuble是基本类的封装类，不可直接赋值
2. run()方法是线程的具体逻辑方法，执行完，线程就结束。
3. int [] Int = new int[2];//默认0 String[] strings = new String[2];//默认null
4. 类的加载包括：加载，验证，准备，解析，初始化。
5. 抽象类可以包含普通方法
6. 抽象类到底能不能被实例化是初学者很容易犯的错误，抽象类确实有构造方法，但这个构造方法是用来被子类调用的，因为任何子类都必须调用从Object开始的所有父亲的构造方法，才算完成初始化工作。如果抽象类被实例化，就会报错，编译无法通过。而接口里不包含构造器，自然无法被实例化。
7. 类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。

1. 接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。

1. 在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
2. abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
3. is-a，理解为是一个，代表继承关系。 如果A is-a B，那么B就是A的父类。 like-a，理解为像一个，代表组合关系。 如果A like a B，那么B就是A的接口。 has-a，理解为有一个，代表从属关系。 如果A has a B，那么B就是A的组成部分。
4. java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的
5. 方法重载的返回值的类型可以不同，因为判断方法重载的方法主要是根据方法的参数不同来判定；方法重写的返回值类型需要相同，重写就是子类继承了父类的方法，并在此方法上重写属于自己的特征，既然是继承过来的，那么它的返回值类型就必须要相同

1. json对象要求属性必须加双引号。
2. json对象必须由一组有序的键值对组成。

1.  JSON语法可以表示以下三种类型的值:  1.简单值：使用与JavaScript 相同的语法，可以在JSON中表示字符串，数值，布尔值和null。  2.对象：对象作为一种复杂数据类型，表示的是一组有序的键值对。而每组键值对中的值可以是简单值，也可以是复杂数据类型的值。  3.数组：数组也是一种复杂数据类型，表示一组有序的值的列表，可以通过数值索引来访问其中的值。数组的值也可以是任意类型--简单值，对象或数组。
2. 一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效
3. Iterator  支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。
4. 执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
5. 执行redirect时，服务器端告诉浏览器重新去请求地址
6. forward是内部重定向，redirect是外部重定向
7. 两个数值进行二元操作时，会有如下的转换操作： 如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。 否则，如果其中一个操作数是float类型，另一个将会转换为float类型。 否则，如果其中一个操作数是long类型，另一个会转换为long类型。 否则，两个操作数都转换为int类型。
8. 虚拟机是运行在操作系统之上的，不与硬件交互
9. 多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响

1. System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。

1. 基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较
2. 两个基本封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
3. 基本型封装类型调用equals (), 但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行比较
4. System.out.println(a==b);//true int a=257; Integer b=257;

1. where 条件查询
2. （3）数据控制（DCL）包括对基本表和视图的授权，完整性规则的描述，事务控制等内容。
3. （4）嵌入式SQL的使用规定（TCL）涉及到SQL语句嵌入在宿主语言程序中使用的规则。
4. alter table 表名 add constraint FK_ID foreign key(你的外键字段名) REFERENCES 外表表名(对应的表的主键字段名);
5. 局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰
6. final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
7. 通过super可以调用父类构造函数

8. protected成员在子类可见性可以修改

9. 父类一般具有通用性，子类更具体

子类能够集成父类中的方法。

1. 继承具有传递性
2. 局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
3. 首写字母可以为下划线
4. Servlet过滤器的配置包括两部分： 第一部分是过滤器在Web应用中的定义，由<filter>元素表示，包括<filter-name>和<filter-class>两个必需的子元素 第二部分是过滤器映射的定义，由<filter-mapping>元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。
5. 同步是害怕在操作过程的时候被其他线程也进行读取操作，一旦是原子性的操作就不会发生这种情况。
6. 因为一步到位的操作，其他线程不可能在中间干涉。另外三项都有读取、操作两个步骤，而X=1则是原子性操作。

1. 抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
2. 抽象类必须有“abstract class”修饰

1. String s = new String("xyz");创建了几个StringObject？两个或一个都有可能

1. 参数传递分为两种 a.基本类型 b.引用类型
2. 基本类型：形式参数的改变不影响实际参数
3. 引用类型：形式参数的改变直接影响实际参数
4.                    String 作为参数传递，效果和基本类型作为参数传递一样的
5. 基本类型是值传递，引用类型是引用传递
6.                    值传递不改变原来的值，引用传递会改变原来的值。
7. x.append(y)是对x所指向的堆进行操作，修改后x与a依然指向这个堆，所以可以修改成功
8. y=x，等于修改了y的指向，b的指向还是以前的地方
9. jar   将许多文件组合成一个jar文件

1. javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。

1. javah 把java代码声明的JNI方法转化成C\C++头文件

1. CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
2. Callable类的call()方法可以返回值和抛出异常
3. 局部变量在使用前必须被初始化，成员变量会默认赋初始值。
4. 实例变量是类的成员变量
5. 隐藏细节应该是封装干的事情
6. 原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为"不可被中断的一个或一系列操作" 。原子操作就是不可再分的操作。在多线程程序中原子操作是一个非常重要的概念，它常常用来实现一些同步机制。由不可分性可知，原子性是拒绝多线程操作的（只有分解为多步操作，多个线程才能对其操作：就像一个盒子里有多个兵乓球，多个人能够从盒子里拿乒乓球；如果盒子只有一个兵乓球，一个人拿的话，其他人就拿不到了；这就是原子性，乒乓球就具有原子性，人就相当于原子）

1. 构造方法不能被重写。  
2. 子类构造函数调用父类构造函数用super
3. 子类重写父类方法后，若想调用父类中被重写的方法，用super
4. 未被重写的方法可以直接调用。

只有向上转型之后，才能向下转型

1. 客户端通过new Socket()方法创建通信的Socket对象 服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求
2. Object 是引用数据类型，只申明而不创建实例，只会在栈内存中开辟空间，默认为空，空占1 bit.
3. volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性。
4. 按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
5. 节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
6. 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
7. JAVA常用的节点流：
8. 文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。 字符串 StringReader StringWriter 对字符串进行处理的节点流。 数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。 管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
9. 常用处理流（关闭处理流使用关闭里面的节点流）
10. 缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter  增加缓冲功能，避免频繁读写硬盘。
11. 转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
12. 数据流 DataInputStream DataOutputStream  等-提供将基础数据类型写入到文件中，或者读取出来.
13. 流的关闭顺序
14. 一般情况下是：先打开的后关闭，后打开的先关闭
15. 另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b 可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法

1. 在C++中，char是基础数据类型，8位，1个字节。byte不是基础数据类型，一般是typedef unsigned char byte;这样子的，也就是说，byte其实是unsigned char类型，那么也是8位，1个字节。不同的是，char可以表示的范围是-128-127，而byte可以表示的范围是0-255。

在java中，char和byte都是基础数据类型，其中的byte和C++中的char类型是一样的，8位，1个字节，-128-127。但是，char类型，是16位，2个字节， '\u0000'-'\uFFFF'。

因为java内部都是用unicode的，所以java其实是支持中文变量名的

Java默认使用Unicode字符集来表示字符

Java语言中,中文字符所占的字节数取决于字符的编码方式,采用ISO8859-1编码方式时,一个中文字符与一个英文字符一样只占1个字节

采用GB2312或GBK或Unicode编码方式时,一个中文字符占2个字节

而采用UTF-8编码方式时,一个中文字符会占3个字节。

1. short → float 无须强制转换。
2. long → float  无须强制转换。
3. float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。
4. double → float 没有强制转换，错误。
5. 抽象类可以包含抽象方法，也可以不包含。
6. 类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中。

1. i++也是一个表达式，是有返回值的，返回值就是i自增前的值

1. 抽象类和接口中的方法都没有方法体。
2. 添加进TreeSet中的元素都指定了排序规则，有两种指定方式，要么 元素实现java.lang.Comparable接口，要么创建TreeSet的时候传入一个java.util.Comparator类型的比较器。一般我们往TreeSet中添加的数字、字符串等类型的元素，都是用的第一种方式，sun公司在定义的这些类都实现了java.lang.Comparable，这就是所谓的自然规则。而如果需要向TreeSet中添加自定义类型的元素，也必须指定排序规则(两种方式都可以)，否则在进行添加的时候会报错(一个非受检异常java.lang.ClassCastException)
3. LinkedHashSet按添加顺序排序。
4. &运算符：两个数都转为二进制，然后从两个数的最高位进行与运算，两个都为真（1），结果才为真（1），否则为假（0）
5. Vector实现了List接口，List是一个接口。
6. 抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。

当x和y的正负相同时，取余和取模结果相同；

当x和y的正负不同时，取余结果的符号和x相同，取模结果的符号和y相同。（口诀：取余取头，取模取尾）

1. while循环能够实现的操作，for循环也能实现
2. for(;;) 就是while(true) 死循环
3. 我们使用while 就是为了他的循环次数的不一定的 而for循环一般限定了循环次数
4. while(条件) {
5.     //执行语句
6. }
7. 都可以替换成
8. for(;条件;) {
9.     //执行语句
10. }
11. hashMap可以以null为key HashTable不能
12. 输入输出流编程中，读和写时都要抛出IOException
13. 选项AbstractSet类实现Set接口
14. 选项HashSet继承 AbstractSet类，同时也实现set
15. ClassLoader就是用来动态加载class文件到内存当中用的
16. ClassLoader使用的是双亲委托模型来搜索类的
17. Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension ClassLoader，App ClassLoader
18. boolean 1个字节或4个字节，在java规范2中，如果boolean用于声明一个基本类型变量时占4个字节，如果声明一个数组类型的时候，那么数组中的每个元素占1个字节

1. synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性。
2. ResultSet中记录行的第一列索引为1。

通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。

其中string的字符数组是final修饰的，所以字符数组不可以修改。

stringbuffer的字符数组没有final修饰，所以字符数组可以修改。

string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。

1. 至于地址所指内容能不能修改，则需要看字符数组可不可以修改。
2.  HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。HashMap的底层结构是一个数组，数组中的每一项是一条链表。
3. 解决冲突主要有三种方法：定址法，拉链法，再散列法
4. HashMap中的key-value都是存储在Entry数组中的。
5. Java中静态变量只能在类主体中定义，不能在方法中定义。 静态变量属于类所有而不属于方法。
6. 静态成员属于类成员，在方法区分配内存，而不是堆。静态变量属于类本身，成员变量属于类的某个实例。
7. 同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。
8. String str="123456a";
9. int e=Integer.parseInt(str);//java.lang.NumberFormatException 非纯数字的字符串转化为Integer对象会报数字格式异常。
10. java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
11. java.lang.RuntimeException：运行时异常
12. java.lang.ArrayindexOutOfBoundsException：数组下标越界
13. 抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。
14. abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。

1. 静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。

1. 被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

1. 同样是新增5000个对象，LinkedLIst比ArrayList更快

1. 在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
2. 我们自定义异常的情况，请仔细读：我们可以用违例（Exception）来抛出一些并非错误的消息，可以，并非错误的消息。比如我自定义一个异常，若一个变量大于10就抛出一个异常，这样就对应了B选项说的情况，我用抛出异常说明这个变量大于10，而不是用一个函数体（函数体内判断是否大于10，然后返回true或false）判断，因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大！
3. Vector是Collection集合下的实现类，实现至List接口，是线程安全的，其底层和ArrayList同为数组，可实现自动扩容，但是ArrayList是非线程安全的。
4. 接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。

1. 线程安全概念：
2. 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
3. 线程安全问题都是由全局变量及静态变量引起的。
4. 若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
5. LinkedList 和 ArrayList 都是不同步的，线程不安全；
6. Vector 和 Stack 都是同步的，线程安全；
7. Set是线程不安全的；
8. Hashtable的方法是同步的，线程安全；
9. HashMap的方法不是同步的，线程不安全；
10. jre 判断程序是否执行结束的标准是所有的前台线程执行完毕。
11. 后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。 前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。
12. 托管线程池中的线程都是后台线程，使用new Thread方式创建的线程默认都是前台线程。
13. 不管是前台线程还是后台线程，如果线程内出现了异常，都会导致进程的终止。
14.  应用程序的主线程以及使用Thread构造的线程都默认为前台线程 
15.  使用Thread建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。一般后台线程用于处理时间较短的任务，如在一个Web服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在Web服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序

finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

在try语句块或catch语句块中执行到System.exit(0)直接退出程序。

1. 由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\\.".
2. 加载驱动方法
3. 1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
4. 2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());
5. 3.System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver")
6. Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里

>>是算术右移操作符

运算符“>>”执行算术右移，它使用最高位填充移位后左侧的空位。

 右移的结果为：每移一位，第一个操作数被2除一次，移动的次数由第二个操作数确定。

逻辑右移或叫无符号右移运算符“>>>“只对位进行操作，没有算术含义，它用0填充左侧的空位。

1. HashMap可以用null值和空字符串作为K,不过只能有一个
2. HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

finally代码块在return中间执行。return的值会被放入临时空间，然后执行finally代码块，如果finally中有return，会刷新临时空间的值，方法结束返回临时空间值。

1. 在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

1. equals和==的区别 ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同.

1. Java堆中存储的是对象，而不是引用。

1. 在Java中，对象引用存储在堆中，而对象本身的数据结构存储在堆中。对象引用是存储在栈中的指针，它指向内存中对象的具体位置。这意味着，当我们通过引用访问一个对象时，实际上是通过栈中的引用找到堆中对象的位置来进行访问和操作的。堆内存用于动态存储对象和数组等数据，其存储空间较大，且数据的生命周期可以通过垃圾回收器来管理。相对地，栈内存用于存储局部变量、方法参数和返回地址等数据，是一种线性结构，其存储空间有限，且数据的生命周期与方法的执行周期相同
2. 在源码中 toLowerCase 是重新 new String()。
3. 在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
4. 包装类就是引用类型，基本数据类型就是值类型
5. 锁只能使方法在一次调用的时候具备原子性，不能使多次调用的整体操作具备原子性。

^表示异或 就是相同是0 不同是1 。14是1110，3是0011。所以14^3=1101，即13

 三种定义方法：    1.String [] arr = new String[4];    2.String [] arr = new String[]{"a","b","c","d"};3.String [] arr = {"a","b","c","d"};注意这种写法->String [] arr = new String[4]{"a","b","c","d"}; 编译会不通过

1. finalize是方法名，在垃圾收入集器将对象从内存中清除出去之前做必要的清理工作。
2. Java网络编程API建立在Socket基础之上
3. Java网络接口支持IP以上的所有高层协议
4. java虚拟机栈：线程私有，生命周期和线程一致。描述的是 Java 方法执行的内存模型：每个方法在执行时都会床创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行结束，就对应着一个栈帧从虚拟机栈中入栈到出栈的过程。  没有类信息，类信息是在方法区中
5. java堆：对于绝大多数应用来说，这块区域是 JVM 所管理的内存中最大的一块。线程共享，主要是存放对象实例和数组
6. 方法区：属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

1. 高精度类型得到低精度结果需要进行强转

1. subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。
2. subSet是指向原数据的，原数据修改，subSet也跟着修改.

1. &在逻辑运算中是非短路逻辑与，在位运算中是按位与

1. 导出类调用基类的构造器必须用到的关键字super 基类就是父类，也叫超类。导出类就是子类，也叫派生类。
2. 子类调用父类的构造器使用super(),放在子类构造函数的首行。
3. request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。getAttribute是返回对象,getParameter返回字符串。
4. java中静态属性和静态方法可以被继承。
5. 静态方法，不存在重写，重写只对可见的实例方法有效。静态方法只有隐藏。
6. 重载是根据形参的静态类型确定调用的方法版本，重写是根据调用者在运行期的实际类型来确定调用的方法版本。

1. Java中while()循环语句中，括号内必须为布尔值

1. abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。
2. off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在RAM中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。序列化和反序列化将会影响部分性能（所以可以考虑使用FST-serialization）使用堆外内存能够降低GC导致的暂停。堆外内存不受垃圾收集器管理，也不属于老年代，新生代。
3. off-heap是指JVM进程管理的内存
4. 抛InterruptedException的代表方法有：
5. java.lang.Object 类的 wait 方法
6. java.lang.Thread 类的 sleep 方法
7. java.lang.Thread 类的 join 方法
8. CyclicBarrier是一个屏障类，它的await方法可以简单的理解为：等待多个线程同时到达之后才能继续进行，在此之前它就是这些线程的屏障，线程不能继续进行，而对于失败的同步尝试，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式：如果因为中断、失败或者超时等原因，导致线程过早地离开了屏障点，那么在该屏障点等待的其他所有线程也将通过 BrokenBarrierException（如果它们几乎同时被中断，则用 interruptedException）以反常的方式离开。因此它被中断也是可以抛出interruptedException的，如果还是不清楚，查看一下JavaAPI，对于这个类介绍的清清楚楚。
9. API里面写的：当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常。
10. suspend()这个方法容易造成死锁，已被标记过时 ！！

1. 可以把局部内部类当做一个局部变量，所以它是不需要加任何修饰符的

1. 局部内部类前不能用修饰符public和private,protected
2. 内部类就随意了。
3. A选项：isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/C选项：isIDCard=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/
4. ^：起始符号，^x表示以x开头
5. $：结束符号，x$表示以x结尾
6. [n-m]：表示从n到m的数字
7. \d：表示数字，等同于[0-9]
8. X{m}：表示由m个X字符构成，\d{4}表示4位数字
9. 15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
10. 18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码

1. [1-9]\d{5}：六位出生地区码，出生地区码没有以0开头，因此第一位为[1-9]。
2. [1-9]\d{3}：八位出生日期码的四位年份，同样年份没有以0开头。
3. ((0\d)|(1[0-2]))：八位出生日期码的两位月份，| 表示或者，月份的形式为0\d或者是10、11、12。
4. (([0|1|2]\d)|3[0-1])：八位出生日期码的两位日期，日期由01至31。
5. \d{4}：三位顺序码+一位校验码，共四位。
6. A选项的构成：
7. [1-9]\d{7}：六位出生地区码+两位出生日期码的年份，这里的年份指后两位，因此没有第一位不能为0的限制，所以合并了。
8. java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
9. java.lang： 提供java编成语言的程序设计的基础类java.io：　 包含提供多种输出输入功能的类，
10. java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
11. java.applet： 包含java小应用程序的类
12. java.util：　 包含一些实用性的类
13. . java.util：包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包。
14. 一个类一旦没有显式的定义任何构造，那么JVM会默认给你一个无参构造。无参构造的第一行依然默认是super()。
15. 接口只能继承接口，但是可以多继承。类都是单继承，但是继承有传递性。
16. 子类的构造器第一行默认都是super()，默认调用直接父类的无参构造，一旦直接父类没有无参构造，那么子类必须显式的声明要调用父类或者自己的哪一个构造器。
17. flush（）函数强制将缓冲区中的字符流、字节流等输出，目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。
18. OutputStream类包含方法flush()。
19. abstract类中不可以有private的成员。

1. java没有指针，只有引用。
2. 包装类时针对基本数据类型的。String不是包装类。
3. 子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
4. 不可变类，说的是一个类一旦被实例化，就不可改变自身的状态。常见的比如String和基本数据类型的包装类，对于这种不可变类，一旦在进行引用传递的时候，形参一开始就和实际参数指向的不是一个地址，所以在方法中对形参的改变，并不会影响实际参数。
5. 对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
6. 但是在Thread中，run方法是个空方法，没有具体实现。
7. Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。
8. 真数组： 数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，避免了数据覆盖的可能性，和数据类型覆盖并没有关系。

---

String str1 = "hello";

这里的str1指的是方法区中的字符串常量池中的“hello”，编译时期就知道的；

String str2 = "he"+ newString("llo");

这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。

如果用str1.equal(str2)，那么返回的是true；

---

标识符就是变量的意思。

Java反射机制（Java Reflection） 是 Java 的特征之一，是Java语言中一种动态（运行时）访问、检测和修改它本身的能力，主要作用是动态（运行时）获取类的完整结构信息、调用对象的方法。简单点的说就是Java程序在运行时（动态）通过创建一个类的反射对象，再对类进行相关操作，比如：

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
• 在运行时调用任意一个对象的方法

重点： 是运行时而不是编译时

多数情况下，我们使用某个类，都会知道这个类，以及要用它来做什么，可以直接通过 new 实例化创建对象，然后使用这个对象对类进行操作，这个就属于正射。反射则是一开始并不知道要初始化的是什么类，无法使用new来实例化创建对象，主要是通过JDK提供的反射API来实现，在运行时才知道要操作的是什么类，并且可以获取到类的完整构造以及调用对应的方法，这就是反射。