精华内容
下载资源
问答
  • java集合底层实现

    千次阅读 2014-06-08 20:33:00
    Set和Map的关系 Set代表无序,不能重复的集合;Map代表Key-Value组成的集合,是一种关联数组。Map的Key要求是不能重复,...HashMap底层是用数组链表存储的,元素是Entry。 向HashMap添加时,由key的hashcode决定E

    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()方法
    迭代器模式:系统为遍历集合提供标准的“迭代器接口”,用于访问集合里的数据,如何实现交给集合自己完成。






    展开全文
  • Java 继承底层实现原理

    千次阅读 2019-09-21 19:46:48
    不知道大家是否有这样的思考:在java面向对象的语言的开发过程中,子类是如何继承调用到父类的方法的? 1.示例 Animal 动物父类 package animal; import animal.Impl.Fly; import animal.Impl.Walk; /** * ${...


    序言:
    不知道大家是否有这样的思考:在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连接数据库。让自己来写,记忆中已无从搜索。特将之前使用的方法做一简单...

    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实现数组底层

    千次阅读 2019-05-16 15:08:24
    Java代码实现: public class Array<E> { private E[] data; private int size; public Array(int capacity) {//构造函数,传入数组的容量capacity构造Array data = (E[])new Object[capacity]; siz...

    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;
        }
    
    
    }
    
    
    展开全文
  • java LinkedList 底层实现和源码分析

    千次阅读 2018-08-01 18:37:30
    LinkedList作为List集合的一种实现类(如果需要了解集合的继承体系可以参考我另一篇文章《用几张图捋完集合的继承实现关系》),其中和ArrayList的底层实现方式的不同在于,ArrayList的底层是由数组来实现,那么这样的...
  • Java线程的底层实现

    千次阅读 2019-06-24 15:14:32
    是操作系统,尽管本文侧重于介绍 Java 线程的实现原理,但是请大家清楚一点,实际上实现线程的老大哥,是运行在内核态的操作系统。 Java 语言提供了不同硬件和操作系统平台下对线程操作的统一处理,每个已经执...
  • Java Map底层实现思路

    千次阅读 2015-04-30 17:16:30
    public class MyMap { MyEntry[] arr = new ... * 采用hash算法实现map,(每个对象都有一个地址, * 根据地址生成的一个hash码,由于每个对象的地址都不一样,所以 * 生成的hash码是唯一的) * @param ke
  • Java一些底层实现原理

    千次阅读 2019-03-14 11:59:59
    https://www.cnblogs.com/danbing/p/5023231.html 堆内存 https://www.cnblogs.com/panxuejun/p/5889418.html内存模型 https://blog.csdn.net/lxf512666/article/details/52819906数组 ...
  • java集合的底层实现

    千次阅读 2016-08-16 22:48:11
    (1)底层采用数组实现,若使用不带参数的构造方法,则生成长度为10的Object类型数组。 (2)若个数超过10,则生成一个新数组,长度为原数组的1.5倍+1,原数组的内容复制到新数组中。 (3)删除时,后续前移,代价...
  • 本章我们将深入底层一起探索下 Java 并发机制的底层实现原理。 一、volatile 的应用 在多线程并发编程中synchronized和volatile都扮演着重要的角色volatile是轻量级的synchronized,它在多处理器开发中保证了共享...
  • Java8 String的底层实现

    万次阅读 2017-08-28 00:50:37
    底层实现String,深入了解string的不可修改特性,并区分stringBuffer、StringBuilder和String的区别
  • java基础、底层实现、面试

    千次阅读 2018-08-23 11:16:07
    public final class String implements java.io.Serializable, Comparable, CharSequence { /** The value is used for character storage. */ private final char value[]; /** Omit resource code …… . */ } ...
  • JAVA底层

    千次阅读 2019-12-17 10:05:51
    谈谈你对java的理解 1:平台无关性 2: GC 3:语言特性 4:面向对象,封装继承多肽 5:类库 网络库 io nio 之类的 6:异常处理 1:平台无关性 java 分为编译时,运行时 java 源码会编译为字节码,再有不同...
  • Java 方法调用的底层实现

    千次阅读 2020-08-04 11:24:25
    方法调用的字节码指令 关于方法的调用,Java 字节码共提供了5个指令,来调用不同类型的方法: invokestatic 用来调用静态方法 invokespecial 用来调用私有实例方法、构造器及 super 关键字等 invokevirtual 用于...
  • Java锁--Lock实现原理(底层实现)

    万次阅读 多人点赞 2016-09-01 20:11:56
    关于java lock的底层实现原理,讲的有点深,转载学习!Lock完全用Java写成,在java这个层面是无关JVM实现的。在java.util.concurrent.locks包中有很多Lock的实现类,常用的有ReentrantLock、ReadWriteLock(实现类...
  • JAVA】HashMap底层实现原理浅谈

    万次阅读 多人点赞 2018-10-07 17:28:35
    HashMap底层实现原理浅谈 不论是实习还是正式工作,HashMap的底层实现原理一直是问地频率最高的一个内容,今天记录一下自己对HashMap的理解,如有不当之处,还请各位大佬指正。 一、前置名词解释 (1)哈希表 ...
  • java注解的底层实现

    千次阅读 2017-10-15 18:08:18
    https://www.zhihu.com/question/24401191 注解是什么,其实注解本质是一个接口interface 从反编译后的信息中可以看出,注解就是一个继承自`java.lang.annotation.Annotation`的接口
  • java集合之List底层实现原理

    千次阅读 2019-07-31 21:34:48
    我们今天主要是来讲一下ArrayList和LinkedList这两个集合的底层实现原理。 1.ArrayList ArrayList底层是由动态数组实现的。动态数组就是长度不固定,随着数据的增多而变长。当实例化ArrayList时(比如:List<...
  • Java集合 HashMap底层实现详解

    千次阅读 2019-05-20 16:22:34
    ,在Java 8之前,复制过程会导致链表倒置,这也是形成死锁的重要原因(Java 8中已经不会倒置)。 死锁会在这种情况产生:两个线程同时往HashMap里放Entry,同时HashMap正好需要扩容,如果一个线程已经完成了transfer...
  • Java枚举类的底层实现

    千次阅读 2018-08-06 22:46:33
    枚举类在后台实现时,实际上是转化为一个继承了java.lang.Enum类的实体类,原先的枚举类型变成对应的实体类型,上例中AccountType变成了个class AccountType,并且会生成一个新的构造函数,若原来有构造函数,则在此...
  • java底层学习

    万次阅读 多人点赞 2011-09-14 17:24:14
    额,马上就要面试了,java的底层肯定是需要了解的。...java底层主要是类的加载、连接和初始化。 本文主要分为四个方面: (1)java底层概述 (2)new和newInstance()方法的区别 (3)深入探讨java的加载机制
  • Java中HashMap底层实现原理(JDK1.8)源码分析

    万次阅读 多人点赞 2016-06-05 11:13:44
    这几天学习了HashMap的底层实现,但是发现好几个版本的,代码不一,而且看了Android包的HashMap和JDK中的HashMap的也不是一样,原来他们没有指定JDK版本,很多文章都是旧版本JDK1.6.JDK1.7的。现在我来分析一哈最新的...
  • JNI实现java调用C语言实现底层代码

    千次阅读 2014-05-29 17:50:15
    JNI实现java调用C语言实现底层代码  在java中,很多sun公司
  • Java底层机制

    千次阅读 多人点赞 2017-09-26 10:28:08
    JVM是一种解释执行class文件的规范技术。 本文知识点包括:JVM体系结构、编译和运行过程、类加载机制、类加载过程、Java垃圾回收机制等等。
  • Java集合系列之ArrayList底层实现原理

    万次阅读 2018-07-28 19:48:46
    ArrayList是我们开发中非常常用的数据存储容器之一,其底层是数组实现的,我们可以在集合中存储任意类型的数据,ArrayList是线程不安全的,非常适合用于对元素进行查找,效率非常高。 源码分析 创建了一个大小为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 532,014
精华内容 212,805
关键字:

java底层实现

java 订阅