arraylist
1）arraylist底层数组结构，原理：数组复制
2）底层自动扩容数组，初始为10，每次扩容上次的1/2
3）善于查询
4）利用index按顺序存储
linkedlist
1）底层链表结构（双链表）
2）善于插入删除数据
3）特殊方法：addlast（），addfirst（），removefirst（），remove（）删除第一个；removelast（）
总结：arraylist更适合读取数据，linkedlist更多的时候添加或删除数据。
arraylist内部是使用可増长数组实现的，所以是用get和set方法是花费常数时间的，但是如果插入元素和删除元素，除非插入和删除的位置都在表末尾，否则代码开销会很大，因为里面需要数组的移动。
linkedlist是使用双链表实现的，所以get会非常消耗资源，除非位置离头部很近。但是插入和删除元素花费常数时间。
重写：不同类中，方法体结构相同，逻辑代码可以不同，方法被定义为final不能被重写。
重载：同一类中，方法体结构相同参数列表类型和个数不能相同。
&和&&都可以作逻辑与，&它的左边无论是true还是false，右边的条件都要进行判断，&&它的左边如果是false，右边则不用进行判断。
&可以用作位运算符，将左边和右边两个数转换成二进制数然后进行与运算。
抽象类特点：
1）不能被实例化（子类继承后可实例化子类）
2）充当父类
3）有属性，方法，构造方法，抽象方法
4）抽象类中抽象方法必须被重写
5）子类有且只有一个父类
接口特点：
1）不能被实例化
2）充当父接口
3）有属性，抽象方法（属性必须初始化，且不能更改）
4）子类可以实现多个接口
抽象类（abstract class）：
1：abstract 关键字修饰，并且没有方法体
2：抽象类不能直接创建实例
3：抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法
接口（interface）：
1：实现接口的一定要实现接口里定义的所有方法
2：接口可以实现多重继承
区别：
1：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用
2：一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类
3：接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法
4：抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的
5：抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法
6.接口可以继承接口，甚至可以继承多个接口；类可以实现多个接口，只能继承一个类。
5:写出jdbc操作数据库的步骤?
1：加载驱动
class.forname("com.mysql.jdbc.driver");
2：创建连接
connection con = drivermanager.getconnection ("url",
"1111", "1111");
3：创建语句
preparedstatement ps = con.preparestatement("select * from user");
4：执行语句
resultset rs = ps.executequery();
5：处理结果
while(rs.next()) {
rs.get.....（“”）；
}
6：关闭资源
finally {
if(con != null) {
try {
con.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
加载驱动-创建连接-创建语句-执行语句-处理结果-关闭资源
1.
hashmap是hashtable的轻量级实现（非线程安全的实现），他们都完成了map接口
2.主要区别在于hashmap允许空（null）键值（key）,由于非线程安全，效率上可能高hashtable
3.hashmap允许将null作为一个entry的key或者value，而hashtable不允许
4.最大的不同是，hashtable的方法是synchronize的，而hashmap不是
hashmap线程不安全。hashmap是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。hashmap允许包含空键和空值，而hashtable不允许空键值。
hashtable线程安全。hashmap是hashtable的轻量级实现（非线程安全的实现），他们都完成了map接口，主要区别在于hashmap允许空键值，由于非线程安全，所以效率上可能高于hashtable。
方式：继承thread、实现 runnable 接口
产生:
- 一个资源每次只能被一个进程使用
- 一个进程因请求发生阻塞时，依然对已获得的资源保持不放
- 进程已经获得资源使用权，但是一直未使用
- 同一个进程，频繁的获取资源的优先使用权，一直未释放
防止：
加锁顺序（线程按照一定的顺序加锁）
加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该
锁的请求，并释放自己占有的锁）
死锁检测（一般是将所有的锁存放于map对象中，检测map中的锁）
1.运行速度快慢为：stringbuilder > stringbuffer > string
- （string为字符串常量，而stringbuilder和stringbuffer均为字符串变量，即string对象一旦创建之后该对象是不可更改的）
2.stringbuilder是线程不安全的，而string、stringbuffer是线程安全的
tcp稳定性较高，但效率低。tcp三次握手协议。
udp通讯相反，效率较高，但稳定性较差
三个编译指令为：page、include、taglib
七个动作指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、
jsp:usebean、jsp:setproperty、jsp:getproperty
1：setter方法
2：构造器
3：接口注入 注解实现注入(常用)
1.mybatis 为我们提供了两种支持动态 sql 的语法：#{} 以及 ${}
2.#方式能够很大程度防止sql注入，$方式无法防止sql注入
3.$方式一般用于传入数据库对象，例如传入表名
4.＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
5.一般能用#的就别用$
cookie和session做状态管理
cookie存在客户端、session数据放在服务器上
cookie不是很安全，别人可以分析存放在本地的cookie并进行修改
session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器
的性能
单个cookie在客户端的限制是3k，就是说一个站点在客户端存放的cookie
不能大于3k
get：
1：从服务器上获取数据，一般不能使用在写操作接口
2：由url所限制，get方式传输的数据大小有所限制，传送的数据量不超过2kb
3：请求的数据会附加在url之后，以？分隔url和传输数据，多个参数用&连接
4：安全性差
post:
1：向服务器提交数据,一般处理写业务
2：post方式传送的数据量比较大，一般被默认为没有限制
3：安全性高
4：请的求的数据内容放置在html header中
1：效率上
转发（forward） > 重定向（redirect）
2：显示上
重定向（redirect）：显示新的url
转发（forward）：地址栏不变
3：数据上
转发（forward）：可以共享request里面的数据
重定向（redirect）：不能
4：请求次数
重定向（redirect）是两次
转发（forward）是一次
1：hibernate的扩展性和移植性比mybatis强
2：hibernate不需要写sql语句，会自动生成，而mybatis则需要写sql
语句
3：hibernate支持事务、一级缓存、二级缓存、查询缓存等
4：hibernate自己提供分页功能，mybatis需要配置分页插件
组件：
strutsparperandexecutefilter
action
result
interceptor
标签：
package
action
result
param
interceptor
返回值类型：
dispatcher
redirect
redirectaction
stream
json
2 << 3
@autowired--自动装配
@component--自动支持自动装配
@repository--dao层实现
@service--service层实现
@controller--web层实现
f5：进入方法内
f6：执行下一步
f7：跳出方法外
f8：执行到下一个断点
端口：server.xml
项目缓存：删除work文件夹下的文件
并发：150-200
final—修饰符（关键字）
如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
一个类不能既被声明为 abstract的，又被声明为final的，被声明为final的方法也同样只能使用，不能重载
finally—异常处理时提供 finally 块来执行操作
finally块则是无论异常是否发生，都会执行finally块的内容
finalize—方法名
finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的，它是在object类中定义的，所有的类都继承了它
两个字节，可以存储，前提是汉字必须是unicode编码
aop称为面向切面编程
用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存
等等实现aop功能关键是采用代理技术，主要分为静态代理(aspectj)和动态代
理，jdk中采用proxy类产生动态代理的方式为某个接口生成实现类，如果要
为某个类生成子类，则可以用cglib。
1：struts2
- 导包
- 加载struts.xml
- 配置web.xml
- filter
2：struts2+spring
- 导中间包、spring包
- 增加spring的配置文件applicationcontext.xml
- 配置web.xml
- context和监听
3：hibernate
- 导包
- 增加hibernate的配置文件hibernate.hbm.cfg和表的映射文件
- 配置数据库的方言和连接、加载映射文件
4：hibernate+spring
- 导中间包
- 在spring的配置文件中加载hibernate的配置信息
1: spring
- 导包
- 增加spring的配置文件applicationcontext.xml
- 配置web.xml
2：springmvc
- 导包
- 增加springmvc的配置文件context-dispatcher.xml
- 配置web.xml
3：mybatis
- 导包
- 增加mybatis的配置文件mybatis-config.xml
- 将mybatis的配置文件在spring和springmvc中进行引用和配置
thread的start才是正在开启线程;run只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码。start则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cup就可以运行该线程。
静态变量前面要加static，实例变量不用。实例变量属于对象的属性，必须创建了实例对象，才可以被使用，静态变量不属于某个实例对象，而是属于类，也叫类变量，不用创建任何实例对象就会被使用。
json、file、xml、jsonp等
字节流：按字节读写
字符流：按字符
通常在处理文本时优先使用字符流，其他的用字节流
字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符
流在操作时使用了缓冲区，通过缓冲区再操作文件
string、list、set、zset、hash
1. 导包
2. jedis jd = new jedis(ip);
3. jd.ping();//pong
key-value---redis
文档存储-----mongodb
文档(document)、集合(collection)、数据库(database)
redis：数据量较小的更性能操作和运算上
mongodb:主要解决海量数据的访问效率问题
导包
//建立连接
mongoclient mc = new mongoclient("192.168.168.220", 27017); mongodatabase
db = mc.getdatabase("db1");//数据库名称
alter table 表名 add 字段 类型 not null default 0;
==：比较两个数据内存地址是否相同
equals：比较两个数据值是否一样
++i:先赋值，后运算
i++：先运算，后赋值
list：
- 链表
- 有序
- 继承collection(set也是)
- 可以有重复的对象值，但是对象下标不能重复
map：
- key-value
- 无序
- 键不能有重复的 值可以用
int 是基本数据类型，初值为0。integer是int的包装类，初值为null
integer缓存：注意拆箱和装箱（-128-127之间）
原始类型：boolean，char，byte，short，int，long，float，double
包装类型：boolean，character，byte，short，integer，long，float，double
oracle：rownum关键词、row_number()函数
mysql：limit 0,5 / limit 5;
mvc：是一个框架设计模式，其中m（模型）、v（视图）、c（控制器）
视图：视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业
务逻辑处理。如：jsp、html等
模型：表示业务数据和业务处理。属于数据模型，如:entity、jdbc、
hibernate、mybatis等
控制器：接收、响应用户请求，servlet、action、controller等
不一定相同；一定
通过调用 init () 方法进行初始化；调用 service() 方法来处理客户端的请求；通过调用 destroy() 方法终止（结束）servlet 是由 jvm 的垃圾回收器进行垃圾回收的；
- 进程是资源的分配和调度的一个独立单元，而线程是cpu调度的基本单元
- 同一个进程中可以包括多个线程
- 进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束
- 线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程
- 进程的创建调用fork或者vfork，而线程的创建调用pthread_create
- 线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源
就绪状态：
当进程已分配到除cpu以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
运行状态：
当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为运行状态。
阻塞状态：
正在运行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待i/o完成、申请缓冲区不能满足、等待信件(信号)等。
状态转换：
就绪→运行：处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成运行状态。
运行→就绪：处于运行状态的进程在其运行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从运行状态转变成就绪状态。
运行→阻塞：正在运行的进程因等待某种事件发生而无法继续运行时，便从运行状态变成阻塞状态。
阻塞→就绪：处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。
jdk是java的开发工具，jdk包含jre。
jre只是java程序的运行环境，它最核心的内容就是jvm（java虚拟机）
及核心类库。
处理请求的controller
3.dispatcherservlet将请求提交到controller
4.controller调用业务逻辑处理后，返回modelandview
5.dispatcherservlet查询一个或多个viewresoler视图解析器，找到
modelandview指定的视图
6.视图负责将结果显示到客户端
dispatcherservlet是整个spring mvc的核心。它负责接收http请求
组织协调spring mvc的各个组成部分
1：域名解析
2：tcp三次握手
3：浏览器向服务器发送http请求
4：浏览器发送请求头信息
5：服务器处理请求
6：服务器做出应答
7：服务器发送应答头信息
8：服务器发送数据
9：tcp连接关闭
1**：信息性状态码
2**：成功状态码
200：请求正常成功
204：指示请求成功但没有返回新信息
206：指示服务器已完成对资源的部分 get 请求
3**：重定向状态码
301：永久性重定向
302：临时性重定向
304：服务器端允许请求访问资源，但未满足条件
4**：客户端错误状态码
400：请求报文中存在语法错误
401：发送的请求需要有通过http认证的认证信息
403：对请求资源的访问被服务器拒绝了
404：服务器上无法找到请求的资源
5**：服务器错误状态码
500：服务器端在执行请求时发生了错误
503：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求
对象关系映射（object relational mapping，简称orm）
为了解决面向对象与关系数据库存在的互不匹配的现象的技术，orm是通过使用描述对象和数据库之间映射的元数据(元数据一般采用xml格式)，将程序中的对象自动持久化到关系数据库中，java典型的orm中间件有:hibernate,ibatis,speedframework,mybatis
(inversion of control,简称ioc)，即控制反转，是一种设计模式，是spring的核心。可以解决代码耦合，由ioc容器来管理对象的生命周期、依赖关系等。
page：当前页面有效
request：一次会话请求有效
session：浏览器进程，只要浏览器不关闭，则一直有效
application：服务器只要运行，则有效
sleep：
1：属于thread类，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态
2：sleep方法没有释放锁
3：sleep必须捕获异常
wait：
1：属于object，一旦一个对象调用了wait方法，必须要采用notify()和notifyall()方法唤醒该进程
2：wait方法释放了锁
3：wait不需要捕获异常
1：修饰类：表示该类不能被继承
2：修饰方法：表示方法不能被重写
3：修饰变量：表示变量只能一次赋值以后值不能被修改（常量）
1:error表示系统级的错误和程序不必处理的异常,有可能恢复，但是恢复比较困难的严重问题。
2：exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况
异常处理的原则：
1：system.out.println是高代价的。调用system.out.println会降低系统吞吐量
2：在生产环境中别用异常的printstacktrace()方法。
3：如果你不能处理异常，不要捕获该异常
4：如果要捕获，应在离异常源近的地方捕获它
5：捕获的异常一定要做处理
6：可以自定义异常
7：就近原则
1：开启所有服务器的二进制文件
2：开启所有从服务的io和sql线程
3：配置主从连接的用户信息和主从信息
4：开启3306端口号
nio:是一种new io，其目的是为了实现高速io的代码，将io操作并转换为操作系统，属于非阻塞型，java.nio.*，是以块（缓冲区）的形式就行数据的传输。
io：是以流的方式就行数据的传输，属于阻塞型，影响程序的性能
传统阻塞io，如果你要read/write(
byte[10m])一个10m的文件，一旦调用了read/write(
byte[10m])这个方法，就得等10m全部read/write，方法底层才会返回。
非阻塞线程，调用read/write( byte[10m])方法立即返回，当然这并不能代表10m已经read/write完成，你需要检测这个byte[10m]的缓冲区。
单例模式（singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度
单例模式要素：
a.私有构造方法
b.私有静态引用指向自己实例
c.以自己实例为返回值的公有静态方法
饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法）
优点
1.线程安全
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快缺点
资源效率不高，可能getinstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forname)，那么这个实例仍然初始化
懒汉式：单例实例在第一次被使用时构建，延迟初始化。
应用场景：
- 需要频繁实例化然后销毁的对象
- 创建对象时耗时过多或者耗资源过多，但又经常用到的对象
- 有状态的工具类对象
- 频繁访问数据库或文件的对象
- 网站计数器，一般是采用单例模式实现
- 由于配置文件一般都是共享资源，即web应用的配置对象的读取，一般采用单例模式来实现。如：spring的配置文件的读取等
- 多线程的线程池的设计一般也是采用单例模式
- 数据库连接池的设计
public、final、abstract
8种基本数据类型：
byte 8位
取值范围 -2^7 ~ 2^7 -1
short 16位
取值范围 -2^15 ~ 2^15 - 1
char 16位
取值范围 0 ~ 2 ^16 - 1
boolean 位数不明确 取值范围 true false
int 32位
取值范围 -2^31 ~ 2^31 - 1
long 64位
取值范围 -2^63 ~ 2^ 63 - 1
float 32位
取值范围 1.4e-45 ~ 3.40e38
double 64位
取值范围 4.9e-324 ~ 1.79e308
注意：
需要注意的是，string不是基本数据类型，而是引用类型
在jdk1.5中引入了自动拆装箱的新特性，自动拆装箱，是指基本数据类型和引用数据类型之间的自动转换
基本类型转换成包装类型，称为装箱
integer intobjct = new integer(2); //装箱
//integer intobjct = 2 //自动装箱
//自动装箱，如果一个基本类型值出现在需要对象的环境中，会自动装箱
如integer 和 int 可以自动转换； float和float可以自动转换
round方法，他表示“四舍五入”，算法为math.floor(x+0.5),即将原来的数字加上0.5后再向下取整
12、-11
饿汉式单例：
public class singleton {
private singleton(){}
private static singleton instance = new singleton();
public static singleton getinstance(){
return instance;
}
}
懒汉式单例：
public class singleton {
private static singleton instance = null;
private singleton() {}
public static synchronized singleton getinstance(){
if (instance == null)
instance ＝ new singleton();
return instance;
}
}
构造器不能被继承，因此不能重写override，但可以被重载overload
- jsp本质就是servlet
- jsp应用于页面显示，servlet应用于逻辑控制
- setvlet中没有内置对象，jsp中的内置对象都是必须通过httpservletrequest对象，httpservletresponse对象及httpservlet对象得到
- lock能完成几乎所有synchronized的功能，并有一些后者不具备的功能，如锁投票、定时锁等候、可中断锁等候等
- synchronized 是java内置的关键字，lock
则是jdk 5中出现的一个包
- synchronized 同步的代码块可以由jvm自动释放；lock 需要程序员在finally块中手工释放
xml-dom4j
excel-poi、jxl
发布jar包、发布war包、部署到自动化容器中
概念：
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化（将对象转换成二进制）。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题
序列化：把java对象转换为字节序列的过程。
反序列化：把字节序列恢复为java对象的过程。
实现：
将需要被序列化的类实现serializable接口
注意：
被关键字static、transient修饰的变量不能被序列化。在被序列化后，transient修饰的变量会被设为初始值。如int型的是0、对象型的是null.
用break; return 方法。
- 抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
- 继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
- 封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
- 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
collection是集合类的上级接口
继承与他的接口主要有set 和list.
collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率
gc是垃圾收集的意思（gabage collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，
java提供的gc功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，java语言没有提供释放已分配内存的显示操作方法
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉interruptedexception异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由jvm确定唤醒哪个线程，而且不是按优先级。
allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
request表示httpservletrequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response表示httpservletresponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out对象是javax.jsp.jspwriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pagecontext表示一个javax.servlet.jsp.pagecontext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的api，并且包装了通用的servlet相关功能的方法。 session表示一个请求的javax.servlet.http.httpsession对象。
session可以存贮用户的状态信息 applicaton 表示一个javax.servle.servletcontext对象。这有助于查找有关servlet引擎和servlet环境的信息 config表示一个javax.servlet.servletconfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例
<%@ page isthreadsafe=”false”%>
request，session，application，cookie等
setattribute(string
name,object)：设置名字为name的request的参数值
getattribute(string name)：返回由name指定的属性值
getattributenames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
getcookies()：返回客户端的所有cookie对象，结果是一个cookie数组
getcharacterencoding()：返回请求中的字符编码方式
getcontentlength()：返回请求的body的长度
getheader(string name)：获得http协议定义的文件头信息
getheaders(string name)：返回指定名字的request header的所有值，结果是一个枚举的实例
getheadernames()：返回所以request header的名字，结果是一个枚举的实例
getinputstream()：返回请求的输入流，用于获得请求中的数据 getmethod()：获得客户端向服务器端传送数据的方法
getparameter(string name)：获得客户端传送给服务器端的有name指定的参数值
getparameternames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
getparametervalues(string name)：获得有name指定的参数的所有值
getprotocol()：获取客户端向服务器端传送数据所依据的协议名称
getquerystring()：获得查询字符串
getrequesturi()：获取发出请求字符串的客户端地址
getremoteaddr()：获取客户端的ip地址
getremotehost()：获取客户端的名字
getsession([boolean create])：返回和请求相关
session getservername()：获取服务器的名字
getservletpath()：获取客户端所请求的脚本文件的路径
getserverport()：获取服务器的端口号
removeattribute(string name)：删除请求中的一个属性
java中的23种设计模式：
factory（工厂模式）， builder（建造模式），
factory method（工厂方法模式）， prototype（原始模型模式），singleton（单例模式）， facade（门面模式），
adapter（适配器模式）， bridge（桥梁模式），
composite（合成模式）， decorator（装饰模式），
flyweight（享元模式）， proxy（代理模式），
command（命令模式）， interpreter（解释器模式），
visitor（访问者模式）， iterator（迭代子模式），
mediator（调停者模式）， memento（备忘录模式），
observer（观察者模式）， state（状态模式），
strategy（策略模式）， template method（模板方法模式），
chain of responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，
根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，
通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。
首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。
然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。
当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
list 以特定次序来持有元素，可有重复元素。
set 无法拥有重复元素,内部排序。
map 保存key-value值，value可多值。
1：数据库设计
数据库表：字段类型、字段长度、注释、字段命名规范
数据库索引：外键、关联字段、查询频率比较高的字段、
如果数据表字段>20，则最多支持16个索引
如果数据表字段<20，则根据查询频率字段来定
数据库视图：相当于一张临时表，业务中，尽量少使用
数据库引擎：根据业务，选择对应的表引擎技术
数据库存储过程：尽量少用
数据库字符：utf-8、或者和页面字符保持一致
数据库监听器/触发器：一般用于调度任务或者备份还原
2：业务调用的sql语句优化
xml：
尽量少关联表，效率最高关联4张表，如果多于4张表，则需要开启两个链接事务，但是这两个事务，必须在一个service当中。
如果是查询语句，则不建议使用*
如果是查询语句，where条件后面，最好使用索引字段进行关联
3：数据库服务器的搭建（集群）
主从配置：
读写分离：
自动化（容器）：
一：tomcat本身配置
1：登录成功之后，将session信息存放到redis中，利用拦截器来过滤查找session（推荐）
2：配置tomcat文件server.xml
<engine name="catalina" defaulthost="localhost"
jvmroute="8081">
<cluster classname="org.apache.catalina.ha.tcp.simpletcpcluster"/>
如果还没有session信息同步，则需要在项目的启动容器web.xml中，在display-name标签下面，添加<distributable/>
二：使用redis服务器
回车
1、 一级缓存是session独享，默认开启，无需配置
2、 二级缓存是session共享，需要在配置文件中开启，可以指定缓存区域块
hql语句查询、criteria查询、nativesql查询
a、java的数组可以随时改变大小
b、string字符串的长度和大小都是不可变的
c、boolean类型变量默认初始值为true（false）
d、java虚拟机是实现跨平台的基础
public static void main(string[] args){
int x = 1, y = 1, z = 1;
if(x--==1&&y++==1 ||z++= =1) {
system.out.println(“x=”+x+”,y=”+y+”,z=”+z;);
}
}
a: x=0,y=2,z=1 b: x=1,y=2,z=1
c: 没有输出 d:x=0,y=2,z=2
a. public static void main(string[] args){
byte b1 = 1;
byte b2 = 2;
byte b = b1+b2;
}
b. public static void main(string[] args){
int n = 100;
while(n>0){
system.out.println(n);
}
}
c. public static void main(string[] args){
int n;
for(int i = 0;i<10;i++){
n+= i ;
}
}
d. public static void main(string[] args){
int n = 100;
for(;;){
}
system.out.println(n);
}
public class test{
public static void main (string[] args){
int[] a = {1,2,3,4,5};
int[] b = change(a);
b[1] = 7;
system.out.println(a[1]);
}
public static int[] change(int[] a){
a[1] = 6;
return a ;
}
}
a、编译错误 b、运行出错 c、6 d、7
a、构造函数是类的特殊函数，他的方法名必须与类名相同
b、构造函数没有返回值类型
c、一个类可以有多个构造函数
d、构造函数在类加载时调用
class parent{
int i=2;
public parent() {
system.out.println("parent");
}
}
class child extends parent{
int i=5;
public child() {
system.out.println("child");
}
}
public class test {
public static void main(string[] args) {
parent p = new child();
system.out.println(p.i);
}
}
运行编译后，输出结果为( )
a. child 2 b. child 5 c.parent child 2 d.parent child 5
class classa{
int value;
}
public class testclassa{
public static void main(string[] args){
int value = 10;
changeint(value);
system.out.println(value);
classa ca = new classa();
ca.value = 10;
changeobject(ca);
system.out.println(ca.value);
}
public static void changeint(int value){
++value;
}
public static void changeobject(classa ca){
ca.value++;
}
}
a.编译不通过 b.10,11 c. 10,10 d. 11,11
public class test1 {
public static void main(string[] args) {
list<string> list = new arraylist<>();
list.add("aa");
list.add("java");
list.add("bb");
list.add("java");
list.add("java");
}
}
a、 for(int i=0;i<list.size();i++){
if("java".equals(list.get(i))){
list.remove(i);
}
}
b、for(int i=list.size()-1;i>=0;i--){
if("java".equals(list.get(i))){
list.remove(i);
}
}
c、list.remove(“java”);
d、list.removeall(“java”);
public class test {
public static string output="";
public static void foo(int i){
try {
if(i==1)
throw new exception();
output+="1";
} catch (exception e) {
output+="2";
return;
}finally{
output+="3";
}
output+="4";
}
public static void main(string[] args) {
foo(0);
system.out.println(output);
foo(1);
system.out.println(output);
}
}
a、134 13423 b、1 134 c、134 34 d、134 134134
class t1{
int i=0;
public void test1(){
system.out.println(i);
}
public void test2(){
system.out.println(i);
}
}
class t2 extends t1{
int i=2;
public void test2(){
system.out.println(i);
}
}
public class testcase {
public static void main(string[] args) {
t1 test = new t2();
test.test1();
test.test2();
system.out.println(test.i);
test = (t2)test;
system.out.println(test.i);
}
}
a、0 0 0 0 b、0 2 0 0 c、0 2 2 2 d、编译不能通过
如对本文有疑问， 点击进行留言回复！！
![[杭电多校2020]第一场 1004 Distinct Sub-palindromes](http://www.lhsxpumps.com/_images5/10qianwan/20200724/s_0_202007241733388592.png)
[杭电多校2020]第一场 1004 Distinct Sub-palindromes
Swift -- 将本地生成的UIImage进行持久化保存（存到文件中fileManager.createFile）
我要评论
网友评论