1、冒泡排序法
package jiangyi;
public class BubbleSort {
public static int[] sort(int[] array) {
//这里for循环表示总共需要比较多少轮
for (int i = 1; i < array.length; i++) {
//设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
boolean flag = true;
//这里for循环表示每轮比较参与的元素下标
//对当前无序区间array[0......length-i]进行排序
//j的范围很关键，这个范围是在逐步缩小的,因为每轮比较都会将最大的放在右边
for (int j = 0; j < array.length - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = false;
}
}
if (flag) {
break;
}
//第 i轮排序的结果为
System.out.print("第" + i + "轮排序后的结果为:");
display(array);
}
return array;
}
//遍历显示数组
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] array = {9, 2, 8, 4, 5, 7, 6, 1, 3};
//未排序数组顺序为
System.out.println("未排序数组顺序为：");
display(array);
System.out.println("-----------------------");
array = sort(array);
System.out.println("-----------------------");
System.out.println("经过冒泡排序后的数组顺序为：");
display(array);
}
}
2、Tomcat原理详解及请求过程 https://www.cnblogs.com/hggen/p/6264475.html
Tomcat的context.xml文件
<Context>
<WatchedResource>WEB-INF/web.xml</WatchedResource>此组件是为了定位项目中WEB-INF文件下的/web.xml配置文件，如需更改名称则两者都需更改。
<ResourceLink global="jdbc/mysql" name="jdbc/mysql" type="javax.sql.DataSource"/>配置全局JNDI数据源,应用到所有Tomcat下部署的应用。
</Context>
Tomcat的server.xml文件的一些重要配置
<Resource auth="Container" driverClassName="com.mysql.jdbc.Driver" factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory" maxActive="20" maxIdel="10" maxWait="1000" name="jdbc/mysql" username="用户名" password="用户密码" type="javax.sql.DataSource" url="jdbc:mysql://10.37.92.162:3306/xxx(数据库名)?autoreconnect=true&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull" />配置数据库连接
<Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>配置端口号等信息
<Context docBase="mypro(项目名)" path="/" reloadable="true" source="org.eclipse.jst.jee.server:mypro"/>配置访问路径
3、@Transactional
基于注解的声明式事务管理配置
<tx:annotation-driven/> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,readOnly=false,rollbackFor=RuntimeException.class)
propagation=Propagation.REQUIRED ：有事务就处于当前事务中，没事务就创建一个事务
isolation=Isolation.DEFAULT：事务数据库的默认隔离级别
readOnly=false：可写，针对增删改操作
rollbackFor=RuntimeException.class：遇运行时异常会回滚。
在类上声明的事务等于为其所有方法都声明了事务，在方法上声明的事务会覆盖类声明的事务。
4、HashMap https://blog.csdn.net/it_dx/article/details/73477647
https://www.cnblogs.com/dassmeta/p/5338955.html
ConcurrentHashMap https://yemengying.com/2015/11/06/【译】如何在java中使用ConcurrentHashMap/
5、四种多线程的实现方式 https://www.cnblogs.com/felixzh/p/6036074.html
6、group by having 语句 https://blog.csdn.net/bingogirl/article/details/52559302
7、该死的异常问题 https://blog.csdn.net/qq_32331073/article/details/76525372
https://blog.csdn.net/xialei199023/article/details/63251277
8、算法与数据结构 http://blog.jobbole.com/110835/
9、将byte数组按行读取：
BufferedReader in = new BufferedReader(new StringReader(new String(bytes, "utf-8")));
String readLine;
while ((readLine = in.readLine()) != null) {
// 进行数据处理
}
10、execution表达式
例如：定义切入点表达式@Pointcut("execution(public * com.sun.service.impl..*.*(..))")
execution()是最常用的切入点函数，其语法格式如下所示：
整个表达式可以分为5个部分：
1.execution()：表达式主体
2.public表示方法修饰符，可加可不加；第一个*号表示返回得类型，*号后表示所有的类型。
3.包名：表示需要拦截的包名，后面两个句点..表示当前包和当前包下的所有子包，com.sun.service.impl包，子孙包下所有类的方法。
4.第二个*号：表示类名，*表示所有类。
5.*(..):最后这个*号表示方法名，*号表示所有的方法，后面括号里面表示方法的参数，两个句点表示任何参数。
11、选择排序法
package jiangyi;
public class ChooseSort {
public static void main(String[] args) {
int[] array = {8, 3, 5, 1, 0, 7, 4, 9, 2, 6, 0};
chooseSort(array);
for (int i : array) {
System.out.print(i + " ");
}
}
private static void chooseSort(int[] array) {
// 遍历数组，从第一位开始处理
for (int i = 0; i < array.length - 1; i++) {
// 定义一个最小值索引
int minIndex = i;
// 遍历数组，将数组中所有位置的元素依次与array[minIndex]比较，
// 只要比array[minIndex]小就将索引赋值于minIndex，最终索引minIndex
// 处元素值最小
for (int j = i; j <= array.length - 1; j++) {
if (array[minIndex] > array[j]) {
minIndex = j;
}
}
// 排除相同索引处的比较，将索引i处元素与索引minIndex处元素相互替换
if (minIndex != i) {
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
}
}
12、ConcurrentHashMap的get操作
get操作的高效之处在于整个get过程不需要加锁，除非读到的值是空的才会加锁重读，我们知道HashTable容器的get方法是需要加锁的，那么ConcurrentHashMap的get操作是如何做到不加锁的呢？原因是它的get方法里将要使用的共享变量都定义成volatile，如用于统计当前Segement大小的count字段和用于存储值的HashEntry的value。定义成volatile的变量，能够在线程之间保持可见性，能够被多线程同时读，并且保证不会读到过期的值，但是只能被单线程写（有一种情况可以被多线程写，就是写入的值不依赖于原值），在get操作里只需要读不需要写共享变量count和value，所以可以不用加锁。之所以不会读到过期的值，是根据java内存模型的happen before原则，对volatile字段的写入操作先于读操作，即使两个线程同时修改和获取volatile变量，get操作也能拿到最新的值，这是用volatile替换锁的经典应用场景。
13、Lock和synchronized的选择
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
13、mybatis防sql注入
https://blog.csdn.net/yizhenn/article/details/52384601
14、mysql索引
https://www.cnblogs.com/chenshishuo/p/5030029.html
15、共享锁与排他锁
http://www.hollischuang.com/archives/923
16、悲观锁与乐观锁
http://www.cnblogs.com/wmyskxz/p/9067197.html
17、MySQL中exists与in的区别
https://www.cnblogs.com/beijingstruggle/p/5885137.html
18、springmvc常用注解
https://www.cnblogs.com/leskang/p/5445698.html
19、mybatis批量修改
https://www.jb51.net/article/124849.htm
20、mybatis中trim标签的使用