一、Struts2
过滤器：
StrutsPrepareAndExcuteFilter：可以在执行action前后添加自定义过滤器
工作原理：
用户请求HttpServletRequest
经过Filter过滤器
到ActionMapper——到ActionProxy——通过ConfigurationManager——查找struts.xml中具体的action类
通过ActionProxy代理创建反向实例
再经过拦截器Interceptor
到具体的Action
返回Result
经过视图（JSP）
再经过拦截器Interceptor
通过HttpServletResponse返回一个用户实例显示
核心文件：
web.xml
struts.xml:
1）全局属性；
2）用户请求和响应Action之间的对应关系；
3）Action可能用到的参数和返回结果；
4）拦截器的配置
八个要点：
1）访问Servlet API
三种方式访问：
1、ActionContext；
2、实现***Aware接口；
3、ServletActionContext;
2）Action搜索顺序
1、判断package存在：直接找action，如果action不存在则去默认namespace的package中去找。都找不到Action则报错。
2、判断package不存在：检查上一级路径，重复上一步骤。
3）动态方法调用
1、指定method，不建议使用：
<action name="user" method="addUser" class="com.action.UserAction">
<action name="user" method="updateUser" class="com.action.UserAction">
2、感叹号方式，不建议使用：
<!-- 感叹号方式查找action中对应的方法，不建议使用 -->
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
3、通配符方式：
<action name="user_*" method="{1}" class="com.action.UserAction">
<result name="addUser">/user/{1}.jsp</result><!-- {1}代表addUser -->
//<result name="addUser">/user/addUser.jsp</result><!-- 建议这里不要用通配符 -->
<result name="delUser">/user/{1}.jsp</result><!-- {1}代表delUser -->
访问方式：
http:localhost:8080/YanJiu/user_addUser.action
http:localhost:8080/YanJiu/user_delUser.action
也可以这样写：<action name="user_*_*" method="{1}{11}" class="com.action.UserAction">
4）指定多个配置文件
<include file="struts_user.xml"></include>
5）默认Action
"index"名称要对应
<default-action-ref name="index"></default-action-ref>
<action name="index">
<result>/index.jsp</result>
</action>
6）Struts2后缀
<!-- 指定后缀为.action形式的请求可被Struts2处理，可以配置多个请求后缀 -->
<constant name="struts.action.extension" value="action,do" />
7）接受参数
1、使用Action的属性接受
2、使用DomainModel的属性接受
3、使用ModelDriven接受
4、request
8）处理结果类型
二、Bean
生命周期：
1）Bean的建立
容器寻找Bean的定义信息并将其实例化。
2）属性注入
使用依赖注入，Spring按照Bean定义信息配置Bean所有属性
3）BeanNameAware的setBeanName()
如果Bean类有实现org.springframework.beans.BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。
4）BeanFactoryAware的setBeanFactory()
如果Bean类有实现org.springframework.beans.factory.BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身。
5）BeanPostProcessors的ProcessBeforeInitialization()
如果有org.springframework.beans.factory.config.BeanPostProcessors和Bean关联，那么其postProcessBeforeInitialization()方法将被将被调用。
6）initializingBean的afterPropertiesSet()
如果Bean类已实现org.springframework.beans.factory.InitializingBean接口，则执行他的afterProPertiesSet()方法
7）Bean定义文件中定义init-method
可以在Bean定义文件中使用"init-method"属性设定方法名称例如：
如果有以上设置的话，则执行到这个阶段，就会执行initBean()方法
8）BeanPostProcessors的ProcessaAfterInitialization()
如果有任何的BeanPostProcessors实例与Bean实例关联，则执行BeanPostProcessors实例的ProcessaAfterInitialization()方法
三、常用注解
1）@Controller对应表现层的Bean，也就是Action，例如：
@Controller
@Scope("prototype")
public class UserAction extends BaseAction<User>{
……
}
@Scope("prototype")表示将Action的范围声明为原型，可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。
2）@Service对应的是业务层Bean，例如：
@Service("userService")
public class UserServiceImpl implements UserService {
………
}
@Service("userService")注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,
就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫“userService”的变量来接收由Spring注入的"userService"即可，具体代码如下：
// 注入userService
@Resource(name = "userService")
private UserService userService;
private UserService userService;
注意：在Action声明的“userService”变量的类型必须是“UserServiceImpl”或者是其父类“UserService”，否则由于类型不一致而无法注入，由于Action中的声明的“userService”变量
使用了@Resource注解去标注，并且指明了其name = "userService"，这就等于告诉Spring，说我Action要实例化一个“userService”，你Spring快点帮我实例化好，然后给我，
当Spring看到userService变量上的@Resource的注解时，根据其指明的name属性可以知道，Action中需要用到一个UserServiceImpl的实例，此时Spring就会把自己创建好的名字叫做
"userService"的UserServiceImpl的实例注入给Action中的“userService”变量，帮助Action完成userService的实例化。
3）@Repository对应数据访问层Bean ，例如：
@Repository(value="userDao")
public class UserDaoImpl extends BaseDaoImpl<User> {
………
}
@Repository(value="userDao")注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。
当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即可。
// 注入userDao，从数据库中根据用户Id取出指定用户时需要用到
@Resource(name = "userDao")
private BaseDao<User> userDao;
4）@value
在db.properties中配置的db.driverclass=com.mysql.jdbc.Driver，则在我们的bean的某个set方法上可以用@Value("${db.driverclass}")来完成注入,
5）@Transactional，spring 事务注解
默认遇到throw new RuntimeException("...");会回滚
需要捕获的throw new Exception("...");不会回滚
// 指定回滚
@Transactional(rollbackFor=Exception.class)
public void methodName() {
// 不会回滚
throw new Exception("...");
}
//指定不回滚
@Transactional(noRollbackFor=Exception.class)
public ItimDaoImpl getItemDaoImpl() {
// 会回滚
throw new RuntimeException("注释");
}
@Transactional(propagation=Propagation.REQUIRED) //如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED)//容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW) //不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY)//必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER) //必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS) //如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
/*
public void methodName(){
// 本类的修改方法 1
update();
// 调用其他类的修改方法
otherBean.update();
// 本类的修改方法 2
update();
}
other失败了不会影响 本类的修改提交成功
本类update的失败,other也失败
*/
@Transactional(propagation=Propagation.NESTED)
@Transactional (propagation = Propagation.REQUIRED,readOnly=true) // readOnly=true只读,不能更新,删除
@Transactional (propagation = Propagation.REQUIRED,timeout=30)// 设置超时时间
@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)// 设置数据库隔离级别
四、事务管理
事务的传播行为类型：
1）PROPAGATION_REQUIRED
如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
2）PROPAGATION_SUPPORTS
支持当前事务，如果当前没有事务，就以非事务方式执行。
3）PROPAGATION_MANDATORY
使用当前的事务，如果当前没有事务，就抛出异常。
4）PROPAGATION_REQUIRES_NEW
新建事务，如果当前存在事务，把当前事务挂起。
5）PROPAGATION_NOT_SUPPORTED
以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
6）PROPAGATION_NEVER
以非事务方式执行，如果当前存在事务，则抛出异常。
7）PROPAGATION_NESTED
如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类 似的操作。
PROPAGATION_REQUIRES_NEW和PROPAGATION_NESTED区别：
PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务,
它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.
另一方面, PROPAGATION_NESTED 开始一个 "嵌套的" 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint.
如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.
由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务,
而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit, 这个规则同样适用于 roll back.
事务的隔离级别：
1）ISOLATION_DEFAULT： 这是一个PlatfromTr ansactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
另外四个与JDBC的隔离级别相对应
2）ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
这种隔离级别会产生脏读，不可重复读和幻像读。
3）ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。SQLserver默认。
4）ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
5）ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
除了防止脏读，不可重复读外，还避免了幻像读。
事物属性：
原子性（atomicity）：事务中的所有动作要么都发生，要么都不发生。
一致性（consistency）：事务将数据库从一种一致状态转变为下一种一致状态。
隔离性（isolation）：一个事务的影响在该事务提交前对其他事务都不可见。
持久性（durability）：事务一旦提交，其结果就是永久性的。
五、悲观锁和乐观锁
1）悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，
这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，
都是在做操作之前先上锁。
2）乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断
一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。
六、接口、抽象类
区别：
1）接口表示这个对象能做什么，抽象类表示这个对象是什么。
2）接口定义方法，抽象类可以实现方法。
3）接口基本数据类型是static和final，抽象类不是。
4）接口可以多继承，抽象类不行。
5）一个类只能继承一个类，但可以实现多个接口实现多继承。
6）实现接口的一定要实现接口里定义的所有方法，实现抽象类可以有选择的重写需要用到的方法。
7）接口是公开的，里面不能有私有的变量和方法，抽象类可以有。
七、ArrayList、LinkedList
区别：
1）ArrayList采用数组形式存放对象是物理顺序；LinkedList存放对象是单独的，存放指向下一个对象的索引。
2）get()和set()方法，ArrayList速度快，查询快。
3）add()和remove()方法，LinkedList速度快，插入删除快。单条插入删除ArrayList速度快。
4）栈先进后出；队列先进先出。
八、Hashtable和HashMap
区别：
1）都实现了Map接口，HashMap是Hashtable的轻量级实现。
2）HashMap允许一条空的key，一条以上空的value，Hastable不允许。
3）HashMap非线程安全，效率高。
4）HashMap方法是synchronize的，多个线程访问时
总结：
1）如果线程要求安全，使用Vector，Hashtable
2）如果不要求线程安全，应使用ArrayList，LinkedList，HashMap
3）如果要求键值对，则使用HashMap、Hashtable
4）如果数据很大，又要线程安全考虑Vector
关系图：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMa
九、mybatis
MyBatis主配置文件
MyBatis配置文件中大标签configuration下子标签包括：
configuration
|--- properties
|--- settings
|--- typeAliases
|--- typeHandlers
|--- objectFactory
|--- plugins
|--- environments
|--- |--- environment
|--- |--- |--- transactionManager
|--- |--- |__ dataSource
|__ mappers
十、SQL
1）查询前十：
1、ORACLE
SELECT * FROM TABLE1 WHERE ROWNUM<=10
2、SQL SERVER
SELECT TOP 10 * FROM TABLE1
3、 MYSQL
SELECT * FROM TABLE1 LIMIT 10
2）查询重复数据
1、查找表中多余的重复记录，重复记录是根据单个字段（peopleId）来判断
select * from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1)
2、删除表中多余的重复记录，重复记录是根据单个字段（peopleId）来判断，只留有rowid最小的记录
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1)
and rowid not in (select min(rowid) from people group by peopleId having count(peopleId )>1)
3、查找表中多余的重复记录（多个字段）
select * from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
4、删除表中多余的重复记录（多个字段），只留有rowid最小的记录
delete from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)
5、查找表中多余的重复记录（多个字段），不包含rowid最小的记录
select * from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)
补充：
有两个以上的重复记录，一是完全重复的记录，也即所有字段均重复的记录，二是部分关键字段重复的记录，比如Name字段重复，而其他字段不一定重复或都重复可以忽略。
1、对于第一种重复，比较容易解决，使用
select distinct * from tableName
就可以得到无重复记录的结果集。
如果该表需要删除重复的记录（重复记录保留1条），可以按以下方法删除
select distinct * into #Tmp from tableName
drop table tableName
select * into tableName from #Tmp
drop table #Tmp
发生这种重复的原因是表设计不周产生的，增加唯一索引列即可解决。
2、这类重复问题通常要求保留重复记录中的第一条记录，操作方法如下
假设有重复的字段为Name,Address，要求得到这两个字段唯一的结果集
select identity(int,1,1) as autoID, * into #Tmp from tableName
select min(autoID) as autoID into #Tmp2 from #Tmp group by Name,autoID
select * from #Tmp where autoID in(select autoID from #tmp2)
最后一个select即得到了Name，Address不重复的结果集（但多了一个autoID字段，实际写时可以写在select子句中省去此列）
十一、多线程
Java中sleep和wait的区别：
① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。
sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。
② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，
要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间
不到只能调用interrupt()强行打断。
Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。
③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。
synchronized(x){
x.notify()
//或者wait()
}
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
十二、String，StringBuffer 和 StringBuilder
区别：
1、在执行速度方面的比较：StringBuilder > StringBuffer > String
2、StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度快。
3、StringBuilder：线程非安全的
StringBuffer：线程安全的
当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在
单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。
总结：
1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
十三、ajax
使用Struts2的插件机制：
首先是前台发送Ajax请求:（我这里使用JQuery的post方式）
$("#btnClick").click(function() {
$.post("hello", {name: "tanzhenyu"}, function(data) {
alert(data.greeting + ", " + data.name + "!");
}, "json");
});
Action这样写：
public HelloAction extends ActionSupport {
private String name;//这里的nam用来接收Ajax的请求数据
private Map<String, String> resultMap;//这里的Map用来返回结果JSON数据
public getName() {
return name;
}
public setName(String name) {
this.name = name;
}
public getResultMap() {
return resultMap;
}
public setResultMap(Map<String, String> resultMap) {
this.resultMap = resultMap;
}
public String execute() {
resultMap = new Map<>();
resultMap.put("greeting", "Hello");
resultMap.put("name", name);
return Action.SUCCESS;
}
}
这里注意的是：我们的Map对象不需要手动转成JSON对象，Struts2的JSON插件会帮我们转。
配置文件可以这样写：
<package name="default" namespace="/" extends="json-default">
<action name="hello" class="cn.tzy..hello.action.HelloAction">
<result type="json">
<param name="root">resultMap</param>
</result>
</action>
</package>
这里注意的是：extends必须是“json-default”，name为root的param是说明返回时被序列化的对象，值为一个OGNL表达式。
十四、webservice
Axis2
WEB Service 下实现大数据量的传输:
1. 服务器上面取数据,填充数据集,转换为二进制格式.
public byte[] BinaryUserSelect(ref string err){
ClearCommand();
m_commandStringBuilder.Append("SELECT * FROM t_Users ;");
DataSet dsResult = new DataSet();
byte[] bArrayResult = null;
try
{
dsResult = SqlHelper.ExecuteDataset(m_currentConnectionString, CommandType.Text, m_commandStringBuilder.ToString());
// 上面都是取数据的,无需关心.二进制压缩数据集是下面一小段
dsResult.RemotingFormat = SerializationFormat.Binary;
MemoryStream ms = new MemoryStream();
IFormatter bf = new BinaryFormatter();
bf.Serialize(ms, dsResult);
bArrayResult = ms.ToArray();
ms.Close();
}
catch (Exception ee)
{
err = ee.ToString();
}
return bArrayResult;
}
2. 通过WebService把byte[]格式的数据发送到客户端,这里就是WebService自己的事情了,我们无需关心
3.客户端接收到byte[]格式的数据,对其进行反序列化,得到数据集,进行客户端操作.
public DataSet GetBinaryUserData(){
string err = "";
byte[] bUserData = svc.ByteArrayUserSelect(ref err);
if (err != "")
{
MessageBox.Show(err);
err = "";
return null;
}
// 反序列化的过程
MemoryStream ms = new MemoryStream(bUserData);
IFormatter bf = new BinaryFormatter();
object obj = bf.Deserialize(ms);
DataSet dsResult = (DataSet)obj;
//
ms.Close();
return dsResult;
}
十五、设计模式
1.单例模式
该模式主要目的是使内存中保持1个对象。看下面的例子：
public class Singleton {
//将自身的实例对象设置为一个属性,并加上Static和final修饰符
private static final Singleton instance = new Singleton();
//将构造方法设置成私有形式
private Singleton() {
}
//通过一个静态方法向外界提供这个类的实例
public static Singleton getInstance() {
return instance;
}
}
2.工厂模式
该模式主要功能是统一提供实例对象的引用。接口。
十六、大数据
查询大数据：
1.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num is null
可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：
select id from t where num=0
3.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。
4.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num=10 or num=20
可以这样查询：
select id from t where num=10
union all
select id from t where num=20
5.in 和 not in 也要慎用，否则会导致全表扫描，如：
select id from t where num in(1,2,3)
对于连续的数值，能用 between 就不要用 in 了：
select id from t where num between 1 and 3
6.在经常进行连接，但是没有指定为外键的列上建立索引，而不经常连接的字段则由优化器自动生成索引。
7.在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要建立索引。
更新大数据：
数据库分页：
只查询当前页
十七、防SQL注入
ORDER BY $sortFieldName$ $sortType$，这些参数一定不能是用户输入的。
select * from t_user where name like '%'+#name #+'%
十八、js和jQuery
执行顺序：
head标签中的js,页面中的js(将此段Js放置在body标签之外亦为此顺序),body标签onload事件中的js。
区别：
1、js取的是DOM对象，jQuery取的是封装DOM对象后的jQuery对象。
2、Query对象转成DOM对象：
两种转换方式将一个jQuery对象转换成DOM对象：[index]和.get(index);
(1)jQuery对象是一个数据对象，可以通过[index]的方法，来得到相应的DOM对象。
如：var $v =$("#v") ; //jQuery对象
var v=$v[0]; //DOM对象
alert(v.checked) //检测这个checkbox是否被选中
(2)jQuery本身提供，通过.get(index)方法，得到相应的DOM对象
如：var $v=$("#v"); //jQuery对象
var v=$v.get(0); //DOM对象
alert(v.checked) //检测这个checkbox是否被选中
3、DOM对象转成jQuery对象:
对于已经是一个DOM对象，只需要用$()把DOM对象包装起来，就可以获得一个jQuery对象了。$(DOM对象)
如：var v=document.getElementById("v"); //DOM对象
var $v=$(v); //jQuery对象
转换后，就可以任意使用jQuery的方法了。
十九、数组合并排序
public static void main(String[]args)
{
//创建数组
String[] a = { "0", "3", "2", "1" };
String[] b = { "8", "7", "6", "5", "4" };
String[] c = new String[a.length + b.length];
//复制数据
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
//利用 Arrays排序
Arrays.sort(c);
//遍历展示数据
for(String _var : c)
{
System.out.println(_var);
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
