容器是指对对象的容纳，java中主要有这几个容器：list(列表)、set(集合)、map(映射)。所有容器都无法保存基本数据类型，需要先把基本数据类型变为封装类，用容器保存封装结果。
一.List(列表)
1.ArrayList，线性表，容量大小可变的数组　　<===>tArrayLisk()
2.LinkedList，链表，没有使用顺序存储机制，无法根据索引快速存取　　<===>tLinkedList()
3.迭代器遍历LIst　　<===>demo2()
1 public static voidtArrayList(){2         /*
3 ArrayList的构造方法：4 ArrayList a1=new ArrayList();   //构造一个空的线性表5 ArrayList a1=new ArrayList(b);   //根据已有类集构造线性表6 ArrayList a1=new ArrayList(20);   //构造指定初始容量的线性表7          */
8         ArrayList a1=newArrayList();9         a1.add("a");10         a1.add("z");11         a1.add("x");    //add(value)，插入元素
12         a1.remove(0);   //remove(index)，根据数组索引删除元素
13         a1.set(0,"z1");     //set(index,value)，重设指定索引处的值
14         System.out.println(a1.indexOf("z1"));   //indexOf(value)，获取指定元素的索引
15         a1.add("z1");16         System.out.println(a1.lastIndexOf("z1"));   //latIndexOf()value，获取指定元素最后一次出现的位置17         //subList()，获取列表的子列表，需要给出起止位置  listIterator()，生成一个列表迭代器，此迭代器功能强大
18
19         for(int i=0;i
20             System.out.print(a1.get(i)+",");21 }22
23 }24     public static voidtLinkedList(){25         LinkedList l=newLinkedList();26         l.addFirst(1);  //addFirest()，向链表头添加元素
27         l.addLast(10);  //addLast()，向链表尾添加元素
28         l.removeLast();     //removeLast()，移除链表尾部元素
29         System.out.println(l.getFirst());   //getFirst()，获取链表头元素
30 }31     public static voiddemo2(){32         //使用迭代器遍历List
33         List l1=new ArrayList();34         l1.add("a1");35         l1.add("a2");36         l1.add("a3");37         for(Iterator it=l1.iterator();it.hasNext();){   //使用hasNext()判断序列中是否还有元素
38             String s=it.next();     //使用Next()获取序列中下一个元素
39 System.out.println(s);40 }41     }
二.Set(集合)
Set和List的区别：Set没有顺序，不允许保存相同值的元素。
1.Iterator，迭代器，单向移动，实现遍历　　<===>demo1()
2.for-each遍历　　<===>demo2()
3.HashSet散列集，避免Set的元素重复　　<===>demo3()
4.TreeSet，实现红黑树数据结构后的set
5.比较HashSet、TressSet、LinkedHashSet的区别　　<===>demo4()
public static voiddemo1(){
Set s1=new HashSet();
s1.add("a1");
s1.add("a2");
s1.add("a3");for(Iterator it=s1.iterator();it.hasNext();){
String s=it.next();
System.out.println(s);
}
}public static voiddemo2(){
Set s1=new HashSet();
s1.add("a1");
s1.add("a2");
s1.add("a3");for(String s:s1){   //for-each遍历set，将每一次的值存在s中
System.out.println(s);
}
}public static voiddemo3(){
Set s1=new HashSet();     //new一个HashSet，通过下边的for循环为该set填充值
for(int i=1;i<100;i++){
Integer temp=new Integer(i%6);
s1.add(temp);
}for(Iterator it=s1.iterator();it.hasNext();){      //通过Iterator遍历set
System.out.println(it.next());
}
}public static voiddemo4(){//比较HashSet、TreeSet、LinkedHashSet的区别
Set s1=new HashSet();
Set s2=new TreeSet();
Set s3=new LinkedHashSet();for(int i=0;i<5;i++){int s=(int)(Math.random()*100);
Integer temp=newInteger(s);
s1.add(temp);
s2.add(temp);
s3.add(temp);
System.out.println("第"+i+"次产生的随机数为："+s);
}
System.out.println("HashSet:"+s1);  //元素存放顺序和添加时的顺序无关
System.out.println("TreeSet:"+s2);  //对set中的元素按照值进行排序存放
System.out.println("LinkedHashSet:"+s3);    //元素存放顺序按照添加时的顺序
}
三.Map(映射)
Map维护键值对，一个Map中不能有重复的键，每个键只能映射一个值，键与值都视为对象，Map允许null值，基于哈希表的Map接口实现，哈希表的作用是保证键的唯一性。
1.Map遍历的三种方法
1 public static void byValue(Mapmap){2         String value=null;3         Iterator it= map.values().iterator();   //通过HashMap.values()得到“值”的集合，再去遍历值的集合
4         while(it.hasNext()){5             value=(String)it.next();6 System.out.println(value);7 }8 }9     public static void byKey(Mapmap){10         String key=null;11         String value=null;12         Iterator it=map.keySet().iterator();    //通过map.KeySet()得到key的集合
13         while(it.hasNext()){14             key=(String)it.next();15             value=(String)map.get(key);16             System.out.println("key:"+key+",value:"+value);17 }18 }19     public static void byEntry(Mapmap){20         String key=null;21         String value=null;22         Iterator it=map.entrySet().iterator();  //通过entrySet()实现
23         while(it.hasNext()){24             Map.Entry entry=(Map.Entry) it.next();25             key=(String)entry.getKey();26             value=(String)entry.getValue();27             System.out.println("key:"+key+",value:"+value);28 }29     }
2.HashMap散列映射
3.其他Map

概述：
Jython 是一种可以把两种不同的编程语言结合在一起的工具。首先，它使Python 程序员介入到Java 开发环境并让他们能快速开发方案原型，以便无缝地集成到现有的Java 平台上。其次，它能在Java 中加入脚本语言，并以此来简化数计百万计的Java 程序员的工作。Java 程序员们，再也不用为他们刚写的一个类写一大堆的测试用例或驱动程序。Jython
提供了Python 的大部分功能，以及实例化Java 类并与Java 类交互的功能。Jython 代码被动态地编译成Java 字节码，因此，你可以用Jython 扩展Java 类。也可以用Java 来扩展Python。在Python 中写一个类，像使用Java 类一样使用这个类是很容易的事情。你甚至可以把Jython 脚本静态地编译为Java 字节码。
——《Python核心编程》
本人环境：
系统：CentOS release 6.5 (Final)
JDK：java version "1.7.0_75"
Python：Python 2.6.6
Jython：2.7-b1
安装：
jython安装包地址(jython-installer-2.7-b1.jar)：
http://download.csdn.net/detail/u013761665/8590143
安装步骤：
1.切换工作目录到下载的jython-installer-2.7-b1.jar所在目录下（当然，如果你使用一些相对或是绝对路径也是可以的）；
2.使用java -jar jython-installer-2.7-b1.jar命令进行安装（此步操作的前提是你的系统中已经成功安装了jdk）；
3.进入jython安装目录，输入./jython。注意，这里不能使用jython，除非你有配置你的PATH
java代码编写：
package com.w.shell.jar.main;
public class Main {
public Main() {
System.out.println("Hello, Welcome this shell.");
}
/**
* @author Q-WHai
* 2015-4-13
*/
public static void main(String[] args) {
new Main();
}
public static void printLog() {
System.out.println("This is a shell log show 2 you. And you will get nothing whit this function return.");
}
public static String getLog() {
String toReturn = "Custom log";
System.out.println("This is another shell log show 2 you. And you will get a return String.");
return toReturn;
}
}
jar包制作：
通过上面的Java代码操作jar.不过这里不再对jar包的操作进行过多地叙述，因为在本人早期的博客有详细地说明（在cmd中使用指令来执行jar包）.
jython代码编写：
而对于jython的代码则十分简单，如下：
import sys
sys.path += ["/root/study/coding/java/shell.jar"]
from com.w.shell.jar.main import Main
Main.printLog()
result = Main.getLog()
print result
运行示例：
1.将工作目录切换至jython的安装目录下（当然，如果你使用一些相对或是绝对路径也是可以的）；
2.运行../../splace/jython/jython jython_test.py（即：your_jython_path your_jython.py）
3.运行效果：

MyBatis是一个优秀的持久层框架，它对JDBC操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等JDBC繁杂的过程代码。
对JDBC进行封装的框架有哪些
Mybatis，Hibernate，dbutils，Spring中的jdbcTemplate。
MyBatis基本原理
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由Mybatis框架执行sql并将结果映射成java对象并返回。
使用JDBC操作数据库存在的问题
数据库连接频繁开启和关闭，会严重影响数据库的性能。代码中存在硬编码，分别是数据库部分的硬编码和SQL执行部分的硬编码。
一、准备工作
我们先要下载MyBatis + Mysql驱动包
Mybaits下载：传送门~ 
Mysql驱动下载：传送门~
准备项目：
打开IDEA，新建一个简单的Java项目，项目就叫Mybaits吧，在项目Mybaits目录下创建一个libs目录（用于存放项目所要依赖的jar包），那要放哪些jar包呢？
需要的jar包有这些： 
 把jar包拷贝到libs目录下，别忘了libs → 右键 → Add as Library（这才是真正导入jar包）
目录结构： 
准备数据库：
Mysql数据库，数据库名sys，表名Student（可以使用开发工具Navicat来创建数据库）
Student表： 
二、 MyBatis快速入门
主要步骤：
1、  创建PO（model）类（根据需求创建） 
2、  创建全局配置文件SqlMapConfig.xml（文件名任意） 
3、  编写映射文件 
4、  加载映射文件，在全局配置文件SqlMapConfig.xml中进行加载
 5、  编写一个测试程序，即编写Java代码，连接并操作数据库
编写测试程序的步骤：
a)  读取配置文件。 
b)  通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。 
c)  通过SqlSessionFactory创建SqlSession。 
d)  调用SqlSession的操作数据库方法。 
e)  关闭SqlSession。
注意： Mybatis使用的日志包是log4j的，所以需要添加log4j.properties（文件内容可以从mybatis-3.5.5.pdf中拷贝，mybatis-3.5.5.pdf就在下载后的Mybatis的目录里）
最终的目录结构： 
全局配置文件SqlMapConfig.xml中的代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd"> 
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/sys"/>
                <property name="username" value="root"/>
                <property name="password" value="123456789"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="cn/kkdy/map/StudentMap.xml"/>
    </mappers>
</configuration>
全局配置文件简单说明： 
dataSource标签里有4个property，分别表示注册驱动、数据库连接的路径、用户名、密码。mappers标签的子标签mapper用于加载映射文件StudentMap.xml。
映射文件StudentMap.xml中的代码：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mybatis.kkdy">
    <select id="StudentById" parameterType="String" resultType="cn.kkdy.model.Student">
        select * from Student where id = #{id}
    </select>
</mapper>
映射文件简单说明：
命名空间（namespace）用于区分不同的mapper，select标签中的id，通过id可以知道要执行的是哪一个sql语句，parameterType用于表示传进来的参数类型，即#{id}中的参数id的类型，resultType指返回的结果类型。
log4j.properties中的代码：
# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
提示： 以上三个配置文件的代码都可以从文件mybatis-3.5.5.pdf中找到（这个文件就在下载后的Mybatis的目录里），我们只需要拷贝过来修改即可。
Student类（model）：
package cn.kkdy.model;

public class Student {

    private String id;
    private String name;
    private int age;
    private String sex;
    private int score;

    public Student() {
    }

    public Student(String id, String name, int age, String sex, int score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.score = score;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + ''' +
                ", name='" + name + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                ", score=" + score +
                '}';
    }
}
TestStu类（测试类）：
package cn.kkdy.test;

import cn.kkdy.model.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class TestStu {

    @Test
    public void test() throws IOException {

        //1、读取配置文件
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);

        //2、通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂
        SqlSessionFactory sqlSession = new SqlSessionFactoryBuilder().build(inputStream);

        //3、通过SqlSessionFactory创建SqlSession
        SqlSession session = sqlSession.openSession();

        //4、调用SqlSession的操作数据库方法
        Student s = session.selectOne("mybatis.kkdy.StudentById", "202004");

        System.out.println(s);
        session.commit();
        session.close(); //关闭SqlSession对象
    }
}
运行结果：
Student{id='202004', name='酷酷的猿', age=20, sex='男', score=100}
代码分析：
重点讲解selectOne("mybatis.kkdy.StudentById", "202004")方法中的参数。
第一个参数，mybatis.kkdy就是映射文件中mapper标签中命名空间（namespace）的值，StudentById指的是映射文件中select标签中id的值，总的来说，这个参数就是相当于一个sql语句。
第二个参数，这个参数的值会传递给映射文件中的sql语句中的变量id。
特别说明：
本文仅演示了查询数据库记录，其他数据库操作例如增、删、改都是类似的，只不过是调用了不同的方法而已。
如果要对数据库进行多种操作，可能会出现重复的代码，我们可以通过创建新的方法，并使用注解@Bufore、@After来抽取重复代码。
最后，我为了演示方便，都是直接抛出异常（不建议这样），建议处理异常。
三、总结
MyBatis快速入门，就是这么简单。如果觉得还不错的话，就送我一个赞同吧！如果本文对你有用的话，也欢迎收藏哦！

现在都是用框架去开发，既简单又快速，给我们提供了很多便利；有利便有弊，坏处就是依赖框架，忘记了Java基础，不在关注底层是怎么实现的，这里大家一起回顾一下最原始的jdbc写法：
第一步：导入jar包，这里不多说了，百度都有；
第二步：创建BaseDao（偷下懒，把所有方法都写在一个类里面了），上代码：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 公共dao类
 */
@Component
public class BaseDao<T> {

    private final Logger logger = LoggerFactory.getLogger(BaseDao.class);
    private Connection conn = null;
    private PreparedStatement ps = null;
    private ResultSet rs = null;


    /**
     * 建立数据库连接
     * @return
     */
    private Connection getConnection() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");

            if (!conn.isClosed()) {
                logger.info("################# 数据库连接成功 #################");
            }
        } catch (ClassNotFoundException e) {
            logger.error("加载jdbc.Driver异常", e);
            throw new RuntimeException("加载jdbc.Driver异常", e);
        } catch (SQLException e) {
            logger.error("建立数据库连接异常", e);
            throw new RuntimeException("建立数据库连接异常", e);
        }
        return conn;
    }

    /**
     * 方法用途: 公共查询方法，返回List集合<br/>
     * 操作步骤: TODO<br/>
     * ${tags}
     */
    public <T> List<?> queryList(Class<T> clazz, String sql, Object... params) {
        T t;
        List<T> list = new ArrayList<>();
        logger.info(sql);
        logger.info(null == params? "" : params.toString());

        try {
            Field[] fields = getAllFields(clazz);
            conn = getConnection();
            ps = conn.prepareStatement(sql);
            initParams(ps, params);
            rs = ps.executeQuery();
            // 返回结果集
            while (rs.next()) {
                t = getObjResult(fields, rs, clazz);
                list.add(t);
            }
            logger.info(String.format("################# 查询成功，共%s条记录 #################", list.size()));
        } catch (SQLException e) {
            logger.error("执行查询异常", e);
            throw new RuntimeException("执行查询异常", e);
        } finally {
            // 关闭数据库连接
            closeDb(rs, ps, conn);
        }
        return list;
    }

    /**
     * 将每行结果存入map集合，对象属性名为key，查询出的结果为value
     * @param fields
     * @param rs
     * @return
     */
    private <T> T getObjResult(Field[] fields, ResultSet rs, Class<T> clazz) {
        T t = null;
        Field field;
        Method method;
        String fieldName;
        String fieldType;

        try {
            t = clazz.newInstance();
            for (int i = 0; i < fields.length; i++) {
                field = fields[i];
                field.setAccessible(true);
                fieldName = field.getName();
                if (fieldName.equals("serialVersionUID")) {
                    continue;
                }
                fieldType = field.getType().getName();
                method = getMethod(clazz, field, fieldName, fieldType);
                Object value = rs.getObject(initField(fieldName));
                if (fieldType.equals("java.lang.String")) {
                    method.invoke(t, value);
                } else if (fieldType.equals("java.lang.Integer")) {
                    method.invoke(t, Integer.valueOf(value.toString()));
                }
            }
        } catch (SQLException e) {
            logger.error("rs获取结果异常", e);
            throw new RuntimeException("rs获取结果异常", e);
        } catch (InvocationTargetException e) {
            logger.error("method.invoke方法执行异常", e);
            throw new RuntimeException("method.invoke方法执行异常", e);
        } catch (IllegalAccessException e) {
            logger.error("method.invoke方法执行异常", e);
            throw new RuntimeException("method.invoke方法执行异常", e);
        } catch (InstantiationException e) {
            logger.error("建立T对象异常", e);
            throw new RuntimeException("建立T对象异常", e);
        }
        return t;
    }

    /**
     * 对象属性的set方法
     * @param clazz
     * @param field
     * @param fieldName
     * @param fieldType
     * @return
     */
    private Method getMethod(Class clazz, Field field, String fieldName, String fieldType){
        Method method = null;
        try {
            if (fieldType.equals("java.lang.Boolean")) {
                method = clazz.getDeclaredMethod("is" + getMethodName(fieldName), field.getType());
            } else {
                method = clazz.getDeclaredMethod("set" + getMethodName(fieldName), field.getType());
            }
        } catch (NoSuchMethodException e) {
            Class superClazz = clazz.getSuperclass();
            method = getMethod(superClazz, field, fieldName, fieldType);
        }
        return method;
    }

    /**
     * 获取所有属性（getSuperclass：获取父类属性）
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> Field[] getAllFields(Class<T> clazz) {
        Class superClazz = clazz;
        List<Field> fieldList = new ArrayList<>();
        while (null != superClazz) {
            fieldList.addAll(new ArrayList<>(Arrays.asList(superClazz.getDeclaredFields())));
            superClazz = superClazz.getSuperclass();
        }
        Field[] fields = new Field[fieldList.size()];
        fieldList.toArray(fields);
        return fields;
    }

    /**
     * 将驼峰属性名转换为带下划线字段（xx_xx）
     * @param field
     * @return
     */
    private String initField(String field) {
        StringBuilder newField = new StringBuilder();
        for (int i = 0; i < field.length(); i++) {
            char c = field.charAt(i);
            if (Character.isUpperCase(c)) {
                newField.append("_").append(Character.toLowerCase(c));
            } else {
                newField.append(c);
            }
        }
        return newField.toString();
    }

    /**
     * 组装参数
     * @param ps
     * @param params
     */
    private void initParams(PreparedStatement ps, Object... params) {
        if (null != params && params.length > 0) {
            try {
                for (int i = 0; i < params.length; i++) {
                    ps.setString(i, params[i].toString());
                }
            } catch (SQLException e) {
                logger.error("ps设置参数异常", e);
                throw new RuntimeException("ps设置参数异常", e);
            }
        }
    }

    /**
     * 方法用途: 把一个字符串的第一个字母大写、效率是最高的<br/>
     * 操作步骤: TODO<br/>
     * ${tags}
     */
    private static String getMethodName(String fildeName) {
        byte[] items = fildeName.getBytes();
        items[0] = (byte) ((char) items[0] - 'a' + 'A');
        return new String(items);
    }

    /**
     * 关闭数据库连接
     * @param rs
     * @param ps
     * @param conn
     */
    private void closeDb(ResultSet rs, PreparedStatement ps, Connection conn) {
        try {
            if (null != rs) {
                rs.close();
            }

            if (null != ps) {
                ps.close();
            }

            if (null != conn) {
                conn.close();
            }

            logger.info("################# 连接关闭成功 #################");
        } catch (SQLException e) {
            logger.error("关闭连接异常", e);
            throw new RuntimeException("关闭连接异常", e);
        }
    }
}


好了，都是我手敲出来的代码，注释也都加上了，不懂的多读几遍代码吧，实在看不明白先回顾下Java反射的基础（Java反射基础案例）