Set和Map的关系

Set代表无序，不能重复的集合；Map代表Key-Value组成的集合，是一种关联数组。Map的Key要求是不能重复，没有顺序。把Map的所有Key组合起来就是Set。Set<K> keySet();

HashMap和HashSet原理

HashMap底层是用数组链表存储的，元素是Entry。向HashMap添加<Key,Value>时，由key的hashcode决定Entry存储位置，当两个Entry对象的key的hashcode相同时，由key的equals()方法返回值决定采用覆盖行为（返回true），还是在链表头添加新的Entry（返回false）。Collection<V> values(),返回集合对象，但不能添加元素，主要是用来遍历。自定义类如果放入HashMap或HashSet中，需要重写equals和hashcode方法。

HashSet<Name> s = new HashSet<Name>

s.add(new Name("1"));

System.out.println(s.contains(new Name("1")));
如果不对Name类重写hashcode,equals，输出结果是false。因为默认的不能保证结果一样。


TreeMap和TreeSet原理

TreeMap底层是用红黑树来存储，每个Entry对应树的一个节点，TreeMap元素默认从小到大排序。V put(Key k, Value v)实质是二叉排序树的插入算法

ArrayList底层是数组

List是线性表的数据结构，ArrayList是顺序存储的线性表

LinkedList底层是链表

LinkedList是链式存储的线性表，实质是双向链表，实现了List和Deque接口。Deque代表双端队列，既可以当做队列也可以当作栈。

Vector和ArrayList区别

Vector提供synchronized修饰方法，是线程安全版本的ArrayList

Iterator迭代器

用于迭代Collection集合，包括Set和List。集合提供iterator()方法

迭代器模式：系统为遍历集合提供标准的“迭代器接口”，用于访问集合里的数据，如何实现交给集合自己完成。

文章目录
1.示例
2.类加载
3.方法调用


序言：

不知道大家是否有这样的思考：在java面向对象的语言的开发过程中，子类是如何继承调用到父类的方法的？

1.示例
Animal 动物父类
/**
 * @author 李娜
 * @version 0.0.1
 * @since 0.0.1  2019-09-19
 */
public abstract class Animal{
    protected String firstName;
    protected String lastName;
    protected Integer count=1;
    private String name;

    public void setCount(Integer count) {
        this.count = count;
        if(count<3){
            this.count=3;
        }
        if(count>5){
            this.count=5;
        }
    }

    public Integer getCount() {
        return count;
    }

    public Animal() {

    }

    public Animal(String name) {
        this.name = name;
        System.out.println(this.name);
    }

    public Animal(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public void animalShout(){
        for (Integer i = 0; i < count; i++) {
            System.out.println("我的名字叫："+firstName+lastName+ shout());
        }
    }

    public abstract String shout()；
   
}

Bird子类
package animal;

/**
 * @author 李娜
 * @version 0.0.1
 * @s extends Animalince 0.0.1  2019-09-20
 */
public class Bird extends Animal {
    public Bird() {
        super();
    }

    public Bird(String name) {
        super(name);
    }

    @Override
    public String shout() {
       return "布谷布谷";
    }

    public Bird(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

Test 测试类
/**
 * @author 李娜
 * @version 0.0.1
 * @since 0.0.1  2019-09-18
 */
public class Test {
    public static void main(String[] args) {  
        Animal animal=new Bird();
        animal.animalShout();
        animal.shout();
    }
}

具体想知道类的继承原理，我们需要从类的加载开始。
2.类加载
类加载过程包括：

加载：根据类名称获取二进制字节流，转化成方法区数据结构，并在堆中生成类class对象

验证：验证是否安全

准备：为静态变量在方法区分配内存

解析：把符号引用转化成直接引用

初始化：一般在new对象的时候会触发初始化，并为静态变量附上真实的值。
上面也说明了:类加载后会在方法区存放该类的信息，创建对象时，创建出一个对象存放到方法区，并在栈中有指向该对象的引用，堆中每个对象除了保存类的实例变量之外，还保存着实际类信息的引用，如下图所示：


3.方法调用
我们先来看animal.animalShout();这句代码的执行过程是：

查看animal的对象类型，找到Cat类型，在Cat类型中找animalShout方法，发现没有，到父类中寻找
在父类Base中找到了方法animalShout，开始执行animalShout方法
在animalShout方法中发现调用了shout方法，就从Cat类型开始寻找shout方法
在Child类型中找到了shout()方法，执行Cat中的shout()方法，执行完后返回animalShout方法
继续执行action方法，输出打印信息

寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候，再查找父类类型信息。
如果继承的层次比较深，那么如果调用的存在最底层的父类，则调用的效率是比较低的，所以系统使用一种称为虚方法表的方法来优化调动的效率。

所谓虚方法表，就是在类加载的时候，为每个类创建一个表，这个表包括该类的对象所有动态绑定的方法及其地址，包括父类的方法，但一个方法只有一条记录，子类重写了父类方法后只会保留子类的。
参考：

继承实现的基本原理

java类的加载机制

Java进阶(二十五)Java连接mysql数据库(底层实现)

前言

      很长时间没有系统的使用java做项目了。现在需要使用java完成一个实验，其中涉及到java连接数据库。让自己来写，记忆中已无从搜索。特将之前使用的方法做一简单的总结。也能够在底层理解一下连接数据库的具体步骤。

实现

      首先需要导入相关的jar包，我使用的为:mysql-connector-java-5.1.7-bin.jar。

      下面来看一下我所使用的数据库连接方法类:

MysqlUtil.java

 

package cn.edu.ujn.util;
 
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import cn.edu.ujn.base.Const;
import cn.edu.ujn.dao.UserDao;
import cn.edu.ujn.model.User;
 
public class MysqlUtil {
// 定义数据库的用户名
private final static String USERNAME = Const.USERNAME;
// 定义数据库的密码
private final static String PASSWORD = Const.PASSWORD;
// 定义数据库的驱动信息
private final String DRIVER = Const.DRIVER;
// 定义访问数据库的地址
private final static String URL = Const.URL;
// 定义数据库的链接
private static Connection connection;
// 定义sql语句的执行对象
private static PreparedStatement pstmt;// 只有在获得了Statement之后才可执行SQL语句
// 定义查询返回的结果集合
private static ResultSet resultset;
 
public MysqlUtil() {
 
try {
Class.forName(DRIVER);// 显式地加载 JDBC 驱动程序
System.out.println("注册驱动成功！");
} catch (Exception e) {
System.out.println("注册驱动失败！");
}
}
 
/**
 * 定义获得数据库的链接,试图建立到给定数据库 URL 的连接
 * 
 * @return connection
 */
public static Connection GetConnection() {
 
try {
connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
System.out.println("数据库连接成功!");
} catch (Exception e) {
System.out.println("数据库连接失败!");
}
return connection;
}
 
/**
 * 完成对数据库表的增加、删除、更新操作
 * 
 * @param sql
 * @param params
 * @return flag
 * @throws SQLException
 */
public static boolean updateByPreparedStatement(String sql, List<Object> params)// 第二个参数为传输的占位符
throws SQLException {
 
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
boolean flag = false;
 
// 表示当用户执行添加、删除、修改时所影响数据库的行数
int result = -1;
try {
pstmt = connection.prepareStatement(sql);
} catch (Exception e) {
System.out.println("Error in updateByPreparedStatement!");
}
 
// 表示占位符的第一个位置
int index = 1;
 
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
// System.out.println(i+"    "+params.get(i));
// 使用给定对象设置指定参数的值。第二个参数必须是Object类型
pstmt.setObject(index++, params.get(i));
}
}
result = pstmt.executeUpdate();// 用于执行DML语句-返回一个整数，代表被SQL语句影响的记录条数
flag = result > 0 ? true : false;
System.out.println("执行SQL语句影响的记录条数为：" + result);
//关闭数据库
MysqlUtil.releaseConn();
return flag;
}
/**
 * 查询返回单条记录
 * 
 * @param sql
 * @param params
 * @return map
 * @throws SQLException
 */
public static Map<String, Object> findSimpleResult(String sql, List<Object> params)
throws SQLException {
 
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
// 菱形语法在Java7及以后可用
Map<String, Object> map = new HashMap<String, Object>();
 
// 表示占位符的第一个位置
int index = 1;
 
// 此句很重要，需要进行预编译
pstmt = connection.prepareStatement(sql);
 
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
 
// 第一个是指你SQL语句中的第几个参数，第二个是要设置的值
pstmt.setObject(index++, params.get(i));
}
}
 
// 返回查询结果
resultset = pstmt.executeQuery();
 
// 获取此 ResultSet 对象的列的编号、类型和属性。
java.sql.ResultSetMetaData metdata = resultset.getMetaData();
 
// 获取列数
int col_lenth = metdata.getColumnCount();
boolean flag = resultset.next();
if (!flag) {
System.out.println("Found nothing！");
}
while (resultset.next()) {
for (int i = 0; i < col_lenth; i++) {
 
// 获取指定列的名称
String cols_name = metdata.getColumnName(i + 1);
 
// 通过列名获得指定列的属性值
Object cols_value = resultset.getObject(cols_name);
if (cols_value == null) {
 
// 由此可见，数据表中字段值不能为空
cols_value = "";
}
 
// 将指定的值与此映射中的指定键关联（可选操作）。
map.put(cols_name, cols_value);
}
}
//关闭数据库
MysqlUtil.releaseConn();
return map;
}
 
/**
 * 通过反射机制访问数据库,查询前几页的内容
 * 
 * @param sql
 * @param params
 * @param cls
 * @return
 * @throws Exception
 */
public static <T> List<T> queryEvamall(String sql, List<Object> params,
Class<T> cls) throws Exception {
 
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
// 构造一个初始容量为 10 的空列表。
List<T> list = new ArrayList<T>();
 
// 表示占位符的第一个位置
int index = 1;
 
pstmt = connection.prepareStatement(sql);
 
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
 
// 使用给定对象设置指定参数的值。第二个参数必须是Object类型
pstmt.setObject(index++, params.get(i));
 
}
}
 
// 返回查询结果
resultset = pstmt.executeQuery();
 
// 获取列的相关信息
java.sql.ResultSetMetaData metdata = resultset.getMetaData();
 
// 获取列数
int col_lenth = metdata.getColumnCount();
while (resultset.next()) {
 
// 通过反射机制创建一个实例
T resultObject = cls.newInstance();
for (int i = 0; i < col_lenth; i++) {
String cols_name = metdata.getColumnName(i + 1);
Object cols_value = resultset.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
 
// 通过列名获得反射
Field field = cls.getDeclaredField(cols_name);
 
// 打开javabean的私有访问权限
field.setAccessible(true);
field.set(resultObject, cols_value);
}
list.add(resultObject);
}
//关闭数据库
MysqlUtil.releaseConn();
return list;
}
/**
 * 查询返回多条查询记录
 * 
 * @param sql
 * @param params
 * @return
 * @throws SQLException
 */
public static List<Map<String, Object>> findMoreResult(String sql,
List<Object> params) throws SQLException {
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
System.out.println("JJ");
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
// 表示占位符的第一个位置
int index = 1;
pstmt = connection.prepareStatement(sql);
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
pstmt.setObject(index++, params.get(i));// 使用给定对象设置指定参数的值。第二个参数必须是
// Object类型
}
}
try {
resultset = pstmt.executeQuery();// 返回查询结果
} catch (Exception e) {
System.out.println("Error1!");// 调试用
}
ResultSetMetaData metdata = resultset.getMetaData();// 获取列的相关信息
int col_lenth = metdata.getColumnCount();// 获取列数
System.out.println("数据表列数为：" + col_lenth);// 调试用
while (resultset.next()) {
Map<String, Object> map = new HashMap<String, Object>();
for (int i = 0; i < col_lenth; i++) {
String cols_name = metdata.getColumnName(i + 1);// 获取列的名称，列从1开始
Object cols_value = resultset.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
map.put(cols_name, cols_value);
}
list.add(map);
}
//关闭数据库
MysqlUtil.releaseConn();
return list;
}
 
/**
 * jdbc的封装可以使用反射机制来封装 使用泛型方法
 * 
 * @param sql
 * @param params
 * @param cls
 * @return
 * @throws Exception
 */
public static <T> T findSimpleRefResult(String sql, List<Object> params,
Class<T> cls) throws Exception {
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
T resultObject = null;
 
// 表示占位符的第一个位置
int index = 1;
pstmt = connection.prepareStatement(sql);
 
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
 
// 第一个是指你SQL语句中的第几个参数，第二个是要设置的值
pstmt.setObject(index++, params.get(i));
}
}
 
// 返回查询结果
resultset = pstmt.executeQuery();
 
// 获取列的相关信息
java.sql.ResultSetMetaData metdata = resultset.getMetaData();
 
// 获取列数
int col_lenth = metdata.getColumnCount();
while (resultset.next()) {
 
// 通过反射机制创建一个实例
resultObject = cls.newInstance();
 
for (int i = 0; i < col_lenth; i++) {
String cols_name = metdata.getColumnName(i + 1);
Object cols_value = resultset.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
 
// 打开javabean的私有访问权限
field.setAccessible(true);
field.set(resultObject, cols_value);
}
 
}
//关闭数据库
MysqlUtil.releaseConn();
return resultObject;
}
 
/**
 * 通过反射机制访问数据库
 * 
 * @param sql
 * @param params
 * @param cls
 * @return
 * @throws Exception
 */
public static <T> List<T> findMoreRefResult(String sql, List<Object> params, Class<T> cls) throws Exception {
 
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
// 构造一个初始容量为 10 的空列表。
List<T> list = new ArrayList<T>();
 
// 表示占位符的第一个位置
int index = 1;
 
pstmt = connection.prepareStatement(sql);
 
System.out.println("MysqlUtil:" + params);
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
 
// 使用给定对象设置指定参数的值。第二个参数必须是Object类型
pstmt.setObject(index++, params.get(i));
 
}
}
 
// 返回查询结果
System.out.println("SHQ");
resultset = pstmt.executeQuery();
// 获取列的相关信息
java.sql.ResultSetMetaData metdata = resultset.getMetaData();
 
// 获取列数
int col_lenth = metdata.getColumnCount();
while (resultset.next()) {
 
// 通过反射机制创建一个实例
T resultObject = cls.newInstance();
for (int i = 0; i < col_lenth; i++) {
String cols_name = metdata.getColumnName(i + 1);
Object cols_value = resultset.getObject(cols_name);
if (cols_value == null) {
cols_value = "";
}
 
// 通过列名获得反射
Field field = cls.getDeclaredField(cols_name);
 
// 打开javabean的私有访问权限
field.setAccessible(true);
field.set(resultObject, cols_value);
}
list.add(resultObject);
}
//关闭数据库
MysqlUtil.releaseConn();
return list;
}
 
/**
 * 关闭数据库的链接
 * 
 */
public static void releaseConn() {
 
if (resultset != null) {
try {
resultset.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
 
/**
 * 查询返回总页数
 * 
 * @param sql
 * @param params
 * @return int
 * @throws SQLException
 */
public static int cluPage(String sql, List<Object> params)
throws SQLException {
 
//存储总页数 
int countPage = 0;
//设置每页显示的记录数
int size = 10;
//加载数据库驱动
new MysqlUtil();
//连接数据库
MysqlUtil.GetConnection();
// 表示占位符的第一个位置
int index = 1;
// 此句很重要，需要进行预编译
pstmt = connection.prepareStatement(sql);
// 判断所填充的占位符是否有值；判断集合的标准方式
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++) {
 
// 第一个是指你SQL语句中的第几个参数，第二个是要设置的值
pstmt.setObject(index++, params.get(i));
}
}
 
// 返回查询结果
resultset = pstmt.executeQuery();
if (resultset.next()) {
int total = resultset.getInt("total");
countPage = (total%size  == 0 ? total/size : total/size + 1);
}
//关闭数据库
MysqlUtil.releaseConn();
System.out.println("总页数为:" + countPage);
return countPage;
}
/**
 * 测试模块
 * 
 * @param args
 */
public static void main(String[] args) {
User user = new User();
user.setUid("18353102068");
user.setLogin_time("1");
user.setOut_time("1");
user.setLast_time(10);
System.out.println(new UserDao().add(user));
}
}

 

      以上介绍了数据库的连接方法及常用的查询操作。

      其中的常量如下定义:

Const.java

 

package cn.edu.ujn.base;
 
public class Const {
// 定义数据库的IP
public final static String IP = "localhost";
// 定义数据库的端口
public final static String DBPORT = "3308";
// 定义数据库的名称
public final static String DBNAME = "lab";
// 定义数据库的用户名
public final static String USERNAME = "lmapp";
// 定义数据库的密码
public final static String PASSWORD = "lmapp";
// 定义数据库的驱动信息
public final static String DRIVER = "com.mysql.jdbc.Driver";
// 定义访问数据库的地址
public final static String URL = "jdbc:mysql://" + IP + ":" + DBPORT + "/" + DBNAME;
}

 

      以上只是实现了java连接到数据库，要实现数据的插入等操作，还需要以下方法:

UserDao.java

 

package cn.edu.ujn.dao;
 
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
import cn.edu.ujn.model.User;
import cn.edu.ujn.util.MysqlUtil;
 
public class UserDao {
 
MysqlUtil mysqlUtil = new MysqlUtil();
 
/**
 * 添加用户信息
 * 
 * @param user
 * @return
 */
public int add(User user) {
try {
String sql = "insert into lab_static_attribute(uid,login_time,out_time,last_time) values(?,?,?,?)";
List<Object> params = new ArrayList<Object>();
params.add(user.getUid());
params.add(user.getLogin_time());
params.add(user.getOut_time());
params.add(user.getLast_time());
return MysqlUtil.updateByPreparedStatement(sql, params) ? 1 : 0;
}catch (SQLException e) {
return 0;
} 
}
}

 

      这里只是介绍了数据的增加方法，数据库的CRUD其它三种操作方法，请读者自行练习。

总结

      相比于框架实现数据库的操作，这里介绍的方法确实需要完成更多的代码。但是对于初学者来说，还是建议通过这种方法来完成数据库的操作。这样可以更多的了解数据库操作的底层操作行为。学知识讲究“知其然，更要知其所以然”。

美文美图

 

Java代码实现：
public class Array<E> {
    private E[] data;
    private int size;

    public Array(int capacity) {//构造函数，传入数组的容量capacity构造Array
        data = (E[])new Object[capacity];
        size = 0;
    }

    public Array() {//无参数的构造函数，默认数组的容量capacity=10
        this(10);
    }

    public int getSize() {//获取数组中的元素个数
        return size;
    }

    public int getCapacity() {//获取数组的容量
        return data.length;
    }

    public boolean isEmpty() {//返回数组是否为空
        return size == 0;
    }

    public void addLast(E e) {//向所有元素后添加一个新元素e
        add(size, e);
    }

    public void addFirst(E e) {//向所有元素头添加一个新元素e
        add(0, e);
    }

    public void add(int index, E e) {//在第index位置处插入一个新元素e
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("AddLast failed. Require index >= 0 and index <= size");
        }
        if(size == data.length) {
            resize(2 * data.length);
        }
        for(int i = size -1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d, capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0; i < size; i++) {
            res.append(data[i]);
            if(i != size - 1) {
                res.append(", ");
            }
        }
        res.append(']');
        return res.toString();
    }

    public E get(int index) {//获取index索引位置的元素
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return data[index];
    }

    void set(int index, E e) {//修改index索引位置的元素
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        }
        data[index] = e;
    }

    public boolean contains(E e) {//查找数组中是否有元素e
        for(int i = 0; i < size; i++) {
            if(data[i] == e) {
                return true;
            }
        }
        return false;
    }

    public int find(E e) {//查找数组中元素e所在的索引，如果不存在元素e，返回-1
        for(int i = 0; i < size; i++) {
            if(data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    public E remove(int index) {//从数组中删除index位置的元素，返回删除的元素
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        E ret = data[index];
        for(int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        data[size] = null;//loitering objects != memory leak
        if(size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return ret;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size - 1);
    }

    public void removeElement(E e) {//从数组中删除元素e
        int index = find(e);
        if(index != -1) {
            remove(index);
        }
    }

    private void resize(int newCapacity) {//动态数组
        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }


}