Java基础总结4

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