⑴ 在java中将数据库里面的数据r如何封装到一个集合里面，菜鸟求大神指点迷津（集合的元素是对象 ）
while(rs.next()){
Subjectsubject=newSubject();
subject.setSubjectID(rs.getString("subjectID"));
subject.setSubjectTitle(rs.getString("subjectTitle"));
subject.setSubjectOptionA(rs.getString("subjectOptionA"));
subject.setSubjectOptionB(rs.getString("subjectOptionB"));
subject.setSubjectOptionC(rs.getString("subjectOptionC"));
subject.setSubjectOptionD(rs.getString("subjectOptionD"));
subject.setSubjectAnswer(rs.getString("subjectAnswer"));
subject.setSubjectParse(rs.getString("subjectParse"));
subjectList.add(subject);
}这样就可以了。你应该能明白吧。要每回new一个新的。
⑵ java中如何实现登录界面与数据库正确连接
使用JDBC进行数据库的增删改查操作1.下载Microsoft SQL Server 2005 JDBC 驱动包jar文件 将jar文件引入工程中2.封装数据库链接的获取和关闭操作import java.sql.*;public class BaseDao {x0dx0a /**x0dx0a * 数据库驱动类的字符串,完整的包名加类名 在工程中查看添加的jar文件 能看到这个类x0dx0a */x0dx0a private static final String DRIVE = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; /**x0dx0a * 数据库连接地址x0dx0a * x0dx0a * DataBaseName=数据库名称 其它固定x0dx0a */x0dx0a private static final String URL = "jdbc:sqlserver://localhost:1433;DataBaseName=bbs"; /**x0dx0a * 连接数据库的用户名x0dx0a */x0dx0a private static final String USER = "sa"; /**x0dx0a * 用户密码x0dx0a */x0dx0a private static final String PASSword = ""; /**x0dx0a * 获取连接 异常直接抛出 或者捕获后自定义异常信息再抛出x0dx0a */x0dx0a public static Connection getConnection() throws Exception {x0dx0a Class.forName(DRIVE);x0dx0a return DriverManager.getConnection(URL, USER, PASSWORD);x0dx0a } /**x0dx0a * 关闭与数据库的连接 释放资源x0dx0a */x0dx0a public static void closeAll(ResultSet resultSet, PreparedStatement pst,x0dx0a Connection connection) throws Exception {x0dx0a if (resultSet != null)x0dx0a resultSet.close();x0dx0a if (pst != null)x0dx0a pst.close();x0dx0a if (connection != null)x0dx0a connection.close();x0dx0a }}3.创建图书的实体类public class Book {x0dx0a /**x0dx0a * 数据库主键x0dx0a */x0dx0a private Long id; /**x0dx0a * 作者x0dx0a */x0dx0a private String author; /**x0dx0a * 书名x0dx0a */x0dx0a private String name;x0dx0a /**x0dx0a * 默认构造x0dx0a *x0dx0a */x0dx0a public Book() {x0dx0a }x0dx0a /**x0dx0a * 全字段构造x0dx0a * @param idx0dx0a * @param authorx0dx0a * @param namex0dx0a */x0dx0a public Book(Long id, String author, String name) {x0dx0a this.id = id;x0dx0a this.author = author;x0dx0a this.name = name;x0dx0a }x0dx0a /**x0dx0a * 以下为读写属性的方法x0dx0a * @returnx0dx0a */x0dx0a public String getAuthor() {x0dx0a return author;x0dx0a }x0dx0a public void setAuthor(String author) {x0dx0a this.author = author;x0dx0a }x0dx0a public Long getId() {x0dx0a return id;x0dx0a }x0dx0a public void setId(Long id) {x0dx0a this.id = id;x0dx0a }x0dx0a public String getName() {x0dx0a return name;x0dx0a }x0dx0a public void setName(String name) {x0dx0a this.name = name;x0dx0a }x0dx0a}x0dx0a4.创建与图书表交互的工具类import java.sql.Connection;x0dx0aimport java.sql.PreparedStatement;x0dx0aimport java.sql.ResultSet;x0dx0aimport java.util.ArrayList;x0dx0aimport java.util.List;public class BookDao {x0dx0a /**x0dx0a * 添加新书x0dx0a * x0dx0a * @param book 要添加入数据库的图书 作者 书名 必须给定x0dx0a */x0dx0a public void addBook(Book book) throws Exception {x0dx0a // 连接x0dx0a Connection connection = null;x0dx0a // 执行语句x0dx0a PreparedStatement pst = null;x0dx0a try {x0dx0a connection = BaseDao.getConnection();x0dx0a // 构造执行语句x0dx0a String sql = "insert into book values(" + book.getAuthor() + ","x0dx0a + book.getName() + ")";x0dx0a pst = connection.prepareStatement(sql);x0dx0a pst.executeUpdate(); } catch (Exception e) {x0dx0a // 抛出异常x0dx0a throw e;x0dx0a } finally {x0dx0a // 无论是否异常 均关闭数据库x0dx0a BaseDao.closeAll(null, pst, connection);x0dx0a }x0dx0a } /**x0dx0a * 查询所有书籍列表x0dx0a */x0dx0a public List
⑶ java对数据库操作的封装是怎么样的
java本身对数据库没有封装,对数据库封装好的有hibernate,ibatis(mybatis),hibernate封装的比较彻底,基本操作不用自己写SQL语句,ibatis的话还是要自己写SQL语句,比较灵活.
⑷ 数据库如何用java写超市购物程序
为了实现一个使用Java语言实现的超市购物程序，需要结合数据库的知识来设计实现。
首先，需要建立一个数据库，用来存储超市商品的信息，包括商品名称、单价、库存数量等信息。
然后，可以在Java代码中使用JDBC（Java Database Connectivity，Java数据库连接）技术来连接数据库，并使用SQL语句来操作数据库，包括查询商品信息、更新库存数量等操作。
在Java代码中，可以定义一个Proct类用来表示商品信息，包括商品名称、单价、库存数量等属性。可以定义一个Supermarket类表示超市，包括超市商品列表、用户购物车等属性，并实现商品查询、购买等功能。
最后，可以在主函数中创建超市对象，然后模拟用户购物过程，例如输入商品名称查询商品信
⑸ java数据库封装
package com.lc.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Datebase{
public Connection conn=null;
public Statement stmt=null;
public ResultSet rs=null;
public PreparedStatement preparedstmt=null;
private static String dbDriver="com.mysql.jdbc.Driver";
private static String dbUrl="jdbc:mysql://localhost/graatedmanager?useUnicode=true&characterEncoding=gb2312";
private static String dbUser="root";
private static String dbPwd="root";
//打开数据库连接
public Datebase(){}
public static Connection getConnection()
{
java.sql.Connection conn=null;
try
{
Class.forName(dbDriver);
conn=DriverManager.getConnection(dbUrl,dbUser,dbPwd);
}
catch(Exception e)
{
e.printStackTrace();
}
if(conn==null)
{
System.err.println("警告：数据库连接失败！");
}
return conn;
}
//读取结果集
public ResultSet doQuery(String sql)
{
try
{
conn=Datebase.getConnection();
stmt=((java.sql.Connection) conn).createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs=stmt.executeQuery(sql);
}
catch(SQLException e)
{
e.printStackTrace();
}
return rs;
}
//更新数据
public int Prepared_doUpdate(String sql,String parameters[])
{
int result=0;
try
{
conn=Datebase.getConnection();
preparedstmt=conn.prepareStatement(sql);
/* for(int i=0;i<parameters.length;i++)
{
System.out.println(parameters[i]);
}*/
if(parameters!=null)
{
for(int i=0;i<parameters.length;i++)
{
preparedstmt.setString(i+1,parameters[i]);
}
}
result=preparedstmt.executeUpdate();
}
catch(SQLException e)
{
e.printStackTrace();
System.out.println("操作失败");
result=0;
}
return result;
}
//更新数据
public int doUpdate(String sql)
{
int result=0;
try
{
conn=Datebase.getConnection();
stmt=((java.sql.Connection) conn).createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
result=stmt.executeUpdate(sql);
}
catch(SQLException e)
{
result=0;
}
return result;
}
//关闭数据库连接
public void closeConnection()
{
try
{
if(rs!=null)
rs.close();
}
catch(Exception e)
{
e.printStackTrace();
}
try
{
if(conn!=null)
((Statement) conn).close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
⑹ Java数据库连接封装类
try{
class.forName(driver);
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
错了，应该写在方法里面。。。
public Connection getConnection()
{
try{
class.forName(driver);
connection = DriverManager.getConnection(URL,username,password);
}
catch (SQLException e1)
{
e1.printStackTrace();
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
return connection;
}
或者把他放在构造方法里。专
当然是：
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
编译肯定不对。属
⑺ （JAVA）怎样将对数据库的增删查改方法封装起来便于以后调用
public class DBRecordSet {
static private Logger log = Logger.getLogger(DBRecordSet.class.getName());
ResultSetMetaData md = null;
Connection conInner = null;
private int firstElementOfThisList = 0; //当前缓冲池中保存的记录在整个结果集中的位置
private int countOfElementsInthisList = 0; //缓冲池中记录的数目
private List resultList = null; //保存结果的缓冲池
private Vector columnMap = null;
private int cacheSize = -1; //保存结果的缓冲池大小
private int maxRecords = 10; //执行结果集的时候得到的最多的记录数
private String strSQLStmt = null; //打开结果集的时候执行的SQL语句
private boolean isClosed = true; //结果集是否已经open
private int columnCount = -1; //结果集字段数目
private int columnTypeInt[] = null;
private String columnTypeString[] = null;
private int curRow = 0; // 当前光标所在行，基数为 1
private int maxRow = -1; // 执行查询语句得到的记录数，基数为 1
private int curPage = -1; // 分页显示时当前所在页，基数为 1
private int pageSize = -1; // 分页显示时每页记录数，基数为 1
private int pageCount = -1; // 分页显示时总页数，基数为 1
private int updateCount = -1;
private boolean cursorDir = true;
DBConnectionManager connMgr = null;
private DBConnectionManager getConnectionManager() {
if (connMgr == null) {
connMgr = DBConnectionManager.getInstance();
}
return connMgr;
}
private int getCacheSize() {
if (this.cacheSize == -1) {
cacheSize = getConnectionManager().getCacheSize();
if (cacheSize <= 0)
cacheSize = 50;
}
return this.cacheSize;
}
public void setCacheSize(int size) {
this.cacheSize = size;
}
/**
* 构造函数
*/
public DBRecordSet() {
close();
}
public int execute(Connection con, String sql) {
if (con == null || sql == null || sql.length() <= 0) {
return -1;
}
Statement stmt = null;
try {
if (con.isClosed()) return -1;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 设置 ResultSet 对象可包含的最多行数
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//执行语句，判断语句类型
log.debug("开始执行SQL语句: " + sql);
int resultCount = stmt.executeUpdate(sql);
log.debug("执行SQL语句成功: " + sql + "; 返回结果数目为" + resultCount);
return resultCount;
} catch (Exception e) {
log.error("执行SQL语句失败:" + e.getMessage());
} finally {
try {
if (stmt != null)
stmt.close();
} catch (Exception e) {
log.error("关闭Statement失败:" + e.getMessage());
return -1;
}
}
return -1;
}
public boolean openSelect(Connection con, String sql) {
Statement stmt = null;
ResultSet rs = null;
int n = 0, i = 0;
if (con == null) return false;
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
try {
if (con.isClosed()) return false;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 设置 ResultSet 对象可包含的最多行数
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//执行语句，判断语句类型
log.debug("开始执行SQL语句: " + sql);
if (stmt.execute(sql)) {
log.debug("执行查询语句成功");
rs = stmt.getResultSet();
md = rs.getMetaData();
columnCount = md.getColumnCount();
updateCount = -1;
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
if (columnMap != null) {
columnMap = null;
}
columnMap = new Vector(columnCount);
for (n = 1; n <= columnCount; ++n) {
String columnName = md.getColumnName(n).trim();
columnName = columnName.toLowerCase();
if (columnName == null || columnName.length() <= 0) {
columnName = "vcolumn_" + String.valueOf(n);
}
if (columnMap.contains(columnName)) {
columnName += "_" + String.valueOf(n);
}
columnMap.add(columnName);
}
/*
for (n = 1; n <= columnCount; ++n){
log.debug("查询语句结果集的列" + n + ":" + String.valueOf(columnMap.get(n - 1)));
}
*/
PropertyContainer property = null;
while (rs.next() && i < getCacheSize()) {
property = new PropertyContainerImpl();
for (n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
i++;
}
if (property != null)
log.debug("Open查询的最后一条记录是：" + property.valueToString());
if (i > 0) { //如果有记录取出
firstElementOfThisList = 1;
countOfElementsInthisList = resultList.size();
maxRow = i;
if (i >= getCacheSize()) { //记录没有取完
//注意：为了兼容以前代码，这里需要将结果集滚动到最后，用来获得记录数目
while (rs.next()) maxRow++;
maxRow++;
}
curRow = 0;
} else {//如果没有记录
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
curRow = -1;
maxRow = 0;
log.debug("没有记录返回：" + sql);
}
log.debug("open: 读取从第0条记录开始的" + getCacheSize() + "条记录, 返回记录" + countOfElementsInthisList + "条。总记录数为" + maxRow + "条");
} else {
// 执行更新语句后将查询结果集关闭并清除各项信息
int updatecount = stmt.getUpdateCount();
close();
updateCount = updatecount;
log.debug("成功执行更新语句");
} //保存执行的SQL语句
strSQLStmt = sql;
} catch (SQLException e) {
log.error(e.toString() + " : 执行SQL语句时出错：" + sql);
return false;
} catch (Exception e) {
log.error(e.toString() + " : 执行SQL语句时出错：" + sql);
return false;
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
//getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 结果集不能正确关闭");
//getConnectionManager().freeConnectionInner(con);
return false;
}
}
isClosed = false;
return true;
}
/**
* 执行SQL语句，可以为查询或更新语句。
* 执行更新语句后调用 getUpdateCount() 取得所更新的记录数
*
* @param sql 执行的SQL语句
*/
public boolean open(String sql) {
Statement stmt = null;
ResultSet rs = null;
int n = 0, i = 0;
Connection con = getConnectionManager().getConnectionInner();
if (con == null) return false;
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
try {
if (con.isClosed()) return false;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 设置 ResultSet 对象可包含的最多行数
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//执行语句，判断语句类型
log.debug("开始执行SQL语句: " + sql);
if (stmt.execute(sql)) {
log.debug("执行查询语句成功");
rs = stmt.getResultSet();
md = rs.getMetaData();
columnCount = md.getColumnCount();
updateCount = -1;
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
if (columnMap != null) {
columnMap = null;
}
columnMap = new Vector(columnCount);
for (n = 1; n <= columnCount; ++n) {
String columnName = md.getColumnName(n).trim();
columnName = columnName.toLowerCase();
if (columnName == null || columnName.length() <= 0) {
columnName = "vcolumn_" + String.valueOf(n);
}
if (columnMap.contains(columnName)) {
columnName += "_" + String.valueOf(n);
}
columnMap.add(columnName);
}
/*
for (n = 1; n <= columnCount; ++n){
log.debug("查询语句结果集的列" + n + ":" + String.valueOf(columnMap.get(n - 1)));
}
*/
PropertyContainer property = null;
while (rs.next() && i < getCacheSize()) {
property = new PropertyContainerImpl();
for (n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
i++;
}
if (property != null)
log.debug("Open查询的最后一条记录是：" + property.valueToString());
if (i > 0) { //如果有记录取出
firstElementOfThisList = 1;
countOfElementsInthisList = resultList.size();
maxRow = i;
if (i >= getCacheSize()) { //记录没有取完
//注意：为了兼容以前代码，这里需要将结果集滚动到最后，用来获得记录数目
while (rs.next()) maxRow++;
maxRow++;
}
curRow = 0;
} else {//如果没有记录
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
curRow = -1;
maxRow = 0;
log.debug("没有记录返回：" + sql);
}
log.debug("open: 读取从第0条记录开始的" + getCacheSize() + "条记录, 返回记录" + countOfElementsInthisList + "条。总记录数为" + maxRow + "条");
} else {
// 执行更新语句后将查询结果集关闭并清除各项信息
int updatecount = stmt.getUpdateCount();
close();
updateCount = updatecount;
log.debug("成功执行更新语句");
} //保存执行的SQL语句
strSQLStmt = sql;
} catch (SQLException e) {
log.error(e.toString() + " : 执行SQL语句时出错：" + sql);
return false;
} catch (Exception e) {
log.error(e.toString() + " : 执行SQL语句时出错：" + sql);
return false;
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 结果集不能正确关闭");
getConnectionManager().freeConnectionInner(con);
return false;
}
}
isClosed = false;
return true;
}
/**
* 根据语句，得到从startIndex开始的count条记录
*/
private void getResultAt(int start, int count) throws Exception {
if (isClosed) {
throw new Exception("还没有打开结果集");
}
Statement stmt = null;
ResultSet rs = null;
Connection con = getConnectionManager().getConnectionInner();
int readStart = start;
int readCount = count;
if (con == null) {
log.error("无法获得有效连接");
throw new Exception("getResultAt: 无法获得有效连接");
}
try {
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(strSQLStmt);
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
// skip initial rows as specified by the start parameter.
while (start-- > 1 && rs.next()) ;
//分别对每一个字段，取出数值，放到BaseBusinessObject的PropertyContainer中
while (count-- > 0 && rs.next()) {
PropertyContainer property = new PropertyContainerImpl();
for (int n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
}
log.debug("getResultAt: 读取从第" + readStart + "条记录开始的" + readCount + "条记录, 返回记录" + resultList.size() + "条");
} catch (SQLException e) {
throw new Exception(e.toString());
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 结果集不能正确关闭");
getConnectionManager().freeConnectionInner(con);
}
}
}
/**
* 执行SQL语句，可以为查询或更新语句。
* 执行更新语句后调用 getUpdateCount() 取得所更新的记录数
*
* @param sql 执行的SQL语句
*/
public boolean openGBK(String sql) {
return open(Convert.toGBK(sql));
}
/**
* 返回执行查询语句后表的列数
*/
public int getColumnCount() {
return columnCount;
}
/**
* 返回每列的类型，基数为 1
*
* @param schema 表模式名
* @param table 表名
*/
public int[] getColumnType(String schema, String table) {
Connection con = null;
ResultSet results = null;
List list = new ArrayList();
if (columnTypeInt == null) {
log.debug("getColumnType: getConnection");
con = getConnectionManager().getConnectionInner();
if (con == null) return null;
try {
DatabaseMetaData dmd;
dmd = con.getMetaData();
results = dmd.getColumns(null, null, table.toUpperCase(), null);
//
while (results.next()){
list.add(new Integer(results.getInt("DATA_TYPE")));
}
columnTypeInt = new int[list.size()];
for(int i = 0; i < list.size(); i++){
Integer type = (Integer)list.get(i);
columnTypeInt[i] = type.intValue();
}
} catch (Exception e) {
return null;
} finally {
try {
results.close();
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
getConnectionManager().freeConnectionInner(con);
log.error(e.toString() + " : 结果集不能正确关闭");
return null;
}
}
}
return columnTypeInt;
}
/**
* 返回每列的名称，基数为 1
*
* @param schema 表模式名
* @param table 表名
*/
public String[] getColumnName(String schema, String table) {
Connection con = null;
ResultSet results = null;
if (columnTypeString == null) {
log.debug("getColumnName: getConnection");
con = getConnectionManager().getConnectionInner();
if (con == null) return null;
try {
DatabaseMetaData dmd;
dmd = con.getMetaData();
results = dmd.getColumns(null, null, table.toUpperCase(), null);
//
int i = 1;
while (results.next()) i++;
columnTypeString = new String[i];
i = 1;
results.beforeFirst();
while (results.next()) columnTypeString[i++] = results.getString("COLUMN_NAME").trim();
} catch (Exception e) {
return null;
} finally {
try {
results.close();
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
getConnectionManager().freeConnectionInner(con);
log.error(e.toString() + " : 结果集不能正确关闭");
return null;
}
}
}
return columnTypeString;
}
/**
* 返回执行更新语句后实际更新的记录数
*/
public int getUpdateCount() {
return updateCount;
}
/**
* 设置查询语句执行完后取得的最大记录数
*
* @param maxrec 最大记录数
*/
public void setMaxRecords(int maxrec) {
maxRecords = maxrec;
}
/**
* 返回查询语句执行完后取得的最大记录数
*/
public int getMaxRecords() {
return maxRecords;
}
/**
* 关闭查询结果集并清除各项信息
*/
public void close() {
md = null;
firstElementOfThisList = 0; //当前缓冲池中保存的记录在整个结果集中的位置
countOfElementsInthisList = 0; //缓冲池中记录的数目
if (resultList != null) {
int size = resultList.size();
⑻ java中的封装学习难不难
java中的封装就是对某些逻辑进行再次重写。达到重用的状态，提高开发速度和能力。我们也可以从下面几个方面进行学。
第一：先学习Java的核心库（JavaSE）
JavaSE的内容包括：环境搭建、基础语法、面向对象、数组、集合、常用类、IO流、反射机制、网络编程……..
第二：MySQL数据库
搞定一门数据库相关的课程，例如：MySQL、Oracle，搞定一个就可以了，目前互联网公司，例如：京东、阿里等，他们都在使用MySQL，所以建议大家学习MySQL数据库，小巧轻盈，免费。
由于互联网公司的项目访问量比较大，所以一般会搭建数据库的集群，可以一个数据库不够，所以需要搭建数据库集群，为了应付高并发。（搭建的比较多的时候，免费就很重要了。）
第三：WEB前端
以后从事Java开发，从事JavaEE开发，主要开发的系统结构是B/S结构的，B指的是Browser，S指的是Server。要开发这种系统，B端要会，S端也要精通。WEB前端的学习就是学习B端技术。
包括：HTML 、CSS、JavaScript（js）、jQuery框架（底层对JS进行了封装）…
第四：JavaWEB
WEB后端其实可以是很多种不同的编程语言，例如：PHP、C、C++、Java，他们都可以进行WEB后端的开发，我们既然选择了比较火爆的Java，那么我们学习的后端一定是基于Java语言实现的。
包括：Servlet、Filter、Jsp、EL、JSTL、MVC架构模式、数据库连接池（阿里巴巴的Druid连接池）、代理模式（动态代理）。另外后端学习了之后，还要学习一个异步编程技术AJAX。（完成网页的局部刷新，AJAX其实不属于后端，是前端浏览器上的程序。）
学习到这里为止，表示Java基本/基础的技术已经学完了。但是这些最基层的技术在实际的开发中不会使用的，一般为了开发效率，都会使用大量的提前封装好的框架。
第五：最好能够停留下来，做一个项目。
这个项目最好能将之前所学全部串起来。（对以前的知识点进行巩固。）
这个项目最好是基于：Servlet + Jsp+AJAX+jQuery+MySQL….
在这个项目的开发过程中：大家一定要记住，目前比较好的项目自动构建工具：Maven是一定要精通的。还有一个就是团队协作开发：Git/SVN是一定要会用的。（目前使用Git比较多一些。）
第六：学习高级框架
Spring、SpringMVC、MyBatis（持久层框架，这个框架互联网公司使用比较多，因为互联网项目需要进行SQL优化，MyBatis的SQL优化很方便，所以大部分都是使用MyBatis）
Struts2（很少使用了，使用这个的肯定是很老的项目）、Hibernate（传统企业，还有政府等可能会使用Hibernate。）
SpringBoot（新项目大部分使用的都是boot了。所以在项目中遇到还在使用SSM的一般都是遗留项目。）
当你走到这里之后，基本上你可以出山了。（去找工作应该问题不大，但前提是你学得好。学习的深度够了，广度够了。）
第七：最好能有一个大型项目是使用框架来完成的。
SpringBoot做一个项目。
Spring SpringMVC MyBatis做一个项目。
这个项目最好是找几个人搭伙做一下。体验一下团队协作。（尤其是使用一些协作的工具。怎么沟通，怎么写日报，怎么开会，怎么使用Git，等等….）
第八：如果你的薪资想达到15K的话，你可能需要还要学习一些分布式相关的一些技术。
能够应付高并发的一些技术，例如：分布式框架Dubbo、SpringCloud、MQ、Nginx、Redis…..
最后在啰嗦一下，一定要形成自己的编程思想。
编程思想的形成很难。需要大量代码的堆积才可以。怎么形成编程思想呢？
千万别死抄代码。不要像行尸走肉般的抄代码，没有用。只能提高指法速度，无法形成编程思路。
1、打好基础是重中之重
基础部分可能很枯燥，但是一定要耐心坚持下去。因为打基础好比是在造轮子造汽车，没有打好基础在后面的学习就好比走路，可以说后面遇到的百分之七八十的问题都是基础没学好造成的。
2、多看官方文档多读源码
一定要看JDK相关类库、常用框架各种功能的源码，去了解其底层实现的原理。总的来说这个也是在打基础的部分，Java基础非常扎实才能看懂，在我们学习一个类的源码时，肯定会衍生出其他各种各样的问题，供我们来了解和学习，这也就是我们下一步学习的目标和方向。慢慢的，我们就会学习更多的知识，并积累更多的经验。
3、系统性学习，循序渐进
不要急于求成，每个知识点都要看，并且每个知识点都要勤加练习。有的同学在学习过程中觉得这个知识点简单，就跳着学习，其实这是个很大的问题，知识点细节必须要了解。我们学习Java需要循序渐进，一步一步来，不能操之过急。
4、遇到问题
遇到不会做的问题，当然不能置之不理。先在网上查，目前网络上针对很多问题都有完美的解决方案，如果网上没有类似的问题，那可能是你犯了什么小错误。也不要在这个问题上花费太多时间，这需要一定的学习技巧。Java中的知识有很强的相关性，有不懂的地方，可以用其他周边相关知识再回过头来理解，这样既不会耽误学习进度，又能理解自己不懂的地方
1）jvm有很多种，其实jvm是一个标准，sun做的那个叫hotspot，作者就是后来v8的作者lars bak，其他公司也做过jvm，其中做得比较好的有bea的jrockit，其他的包括ibm的r9，apple的jvm等在内，都做得不行，所以jvm主要是整合淘汰掉这些做得不好的jvm(s)，整合成一个统一的openjdk。
2）java是典型的oop语言，其执行效率的优化，最早就是lars bak等人从smalltalk等长期优化的经验中总结出来并apply到hotspot上去滴，而smalltalk在早期apple机上搞出了那种拖拖拽拽就开发出app的做法，后来vc，delphi之类的其实都是抄袭或者说借鉴apple的smalltalk的做法，jobs说微软从头到尾都在抄袭apple是空穴来风，这里空穴来风跟王垠使用的空穴来风是一个意思，有趣的是，java的gui并没有继承这种搞法，反而对这种拖拖拽拽就作出app的做法批判有加，到今天，其实java的gui都还不能真正做到拖拖拽拽就作出来，问题很多，个人建议对于纯java的gui开发，还是以写代码为主。
3）jee也是一个或者说是一堆标准，知乎上有些人把maven，jenkins都算做jee是不对滴，jee的标准核心是ejb，其实就是一个xml配置化的java文件，这个标准在4的时候，达到了顶峰状态，几乎所有的挨踢大厂都主动支持该标准，之后开始走下坡路，支持的厂越来越少。
4）java和javascript的关系比很多人认为的要密切，javascript里面的java这四个字母可不是白叫的，比如js的版权和商标都控制在oracle手里，oracle对于js的支持甚至超过其对java的支持，并且喜欢捆绑销售，比如jvm里面就有一个js引擎。
5）jvm里面除了js engine以外还有一个浏览器排版引擎webkit，就是apple safari和google chrome用的那个那个。
6）java支持绝大多数脚本语言，你能叫得上名字的脚本语言，几乎都可以在jvm上执行，比如常见的js，ruby，python，甚至php，lua，只不过除了js以外你需要找到相关的脚本引擎。
7）spring的版权被控制在vmware手里，其实spring的那一大堆东西，本质上是一个非标准的jee实现，比如在jee里面用的inject，在spring里面就是autowire，当然spring曾经深刻滴影响了jee，所以有些东西比如di标准，是spring影响下制定出来的，所以spring的做法会比较特例一点。
8）maven上的jars数量前两天突破800万，其他语言的类库，排名第二的是npm，大概数量是maven的十分之一，也就是几十万，不知道现在突破100万没有，然后是gem，也就是ruby那个，大概是十几万，下来是python的mole，大概数量级是几万，没突破十万。
9）java的标准是由一个叫做jcp的组织制定的，所有标准需要经过jcp的执行委员会通过方可执行，jcp几乎包括了你所知道的绝大多数知名挨踢公司和组织，比如google，apple，ibm，intel，arm，red hat，twitter等，还有一些教育机构，比如我国的北京大学，阿里最近一次申请jcp执行委员会成员资格，似乎投票不通过，最近一次执行委员会新增两个成员是arm和jetbrains。
10）微软也曾经是jcp甚至是java的主要贡献者，但是利益驱使下，想扩展java，从而破坏java跨平台的特性，所以跟sun闹翻，其本质原因就是想让客户写的java代码跟windows绑定，sun坚决不同意，闹翻，今天回头看这个结果，只能说：双输，sun挂了，微软的ria也离挂不太远了，silverlight已经放弃了，比起当年ie自带有jvm的支持来说，那完全就是两回事。
11）除了微软以外，jcp还缺少一个重要组织apache，因为apache跟oracle也闹翻了，oracle似乎并不在乎开源组织，而更在意商业公司的支持。
12）java曾经有一个内置的数据库，9之后被剥离。
13）j2me是j2se的子集。
14）vert.x作者tim fox最早在vmware做spring时候看到了node.js，萌生出了制作支持多核的node.x的想法，并在离开vmware后加入red hat将其实现，vmware看到后开始耍无赖，claim node.x后来改叫vert.x的版权，不惜跟red hat打官司，后来各方妥协，将其交给eclipse foundation。
15）oracle在收购bea之前，一开始的目标并不是bea和bea的weblogic，而是jboss，但是jboss表现出了极为有种的一面，在oracle收购成功之前，投入了red hat的怀抱，因为都是开源组织，从此jboss成了red hat的一个子部门，oracle收购jboss失败之后，转向bea，庄思浩气死了，但是没用，最后还是被恶意收购。
16）sun在玩不下去之前最早尝试接触的目标是ibm，ibm嫌太贵，放弃之后，被转手给了oracle。（Java学习交流QQ群：589809992 我们一起学Java！）
17）vert.x的作者tim fox在离开red hat之前曾经发过twitter抱怨，外人比如我们，猜测是因为red hat内部已经有了一个jboss，所以跟vert.x在应用上有了重叠，所以导致tim fox的出走，但是出走之后，red hat答应对vert.x做持续性的战略投入，所以vert.x core的几个developers，其实拿的是red hat的工资，但是vert.x的版权并不在red hat手里，而在eclipse foundation手里。
18）vert.x的几个核心开发人员都是google summer of code的导师，每年年初时候会招收在校大学生搞项目。
19）教育机构相关：scala的作者马丁是德国人，eth的博导，groovy的主要领导人是法国人，jruby背后是东京大学，jboss的作者是法国大学校x的校友，x就是伽罗瓦考不进去的那所大学，伽罗瓦进不了x，所以改读巴黎高师，tim fox毕业于帝国理工，主席去的那个，netty作者trustin lee是acm银牌，现在line工作，毕业于sky里面的延世大学，kotlin是毛子公司jetbrains的作品，看linkedin，很多人毕业自圣彼得堡大学，spring作者rod johnson是悉尼大学的音乐博士，hibernate作者gavin king是澳洲莫那什大学的数学本科毕业生，james gosling这种cmu和calgory的估计烂大街了，sun是斯坦福大学网络的意思，夹带两个私货，aspectj有一个维护小组在mcgill，hbase跟waterloo关系密切。
20）java早期被人认为慢，跟java坚持不用硬件加速渲染有关，死活就是不肯接入directx和opengl，7之后总算开窍，搞了一个图形引擎接入了directx／opengl。
21）casssandra是facebook做失败的项目，被贡献给了apache之后老树开花。
22）groovy被贡献给了apache，现在叫做apache groovy，ceylon被贡献给了eclipse，现在叫做eclipse ceylon。
23）netflix现在是java shop，之前是用.net的。
先想到这么多，有空再写。
⑼ java封装数据库连接,一般是写到servlet中还是javaBean中
一般是javaBean中 servlet只是处理业务方面的问题。
等项目变大的时候会有action 这是后封装数据的问题一样还是
交给javaBean 处理。这样的数据业务一般只能在数据访问层的。
⑽ jsp中封装数据库操作，例如数据库连接，条件查询等到javabean中，怎么做
封装到bean里面有点麻烦，等于自己实现简易orm了，况且多表查询时还不好操作，把结果集放到List里面还好