精华内容
下载资源
问答
  • Java增删查改

    2019-07-05 20:55:07
    Java增删查改 开发工具与关键技术:MyEclipse 10/Java 作者:陈希雄 撰写时间:2019年07月05日 新增 //新增用户 @Override public int userRegDao(User u) { // 声明变量 int index = 0; ...

    Java之增删查改

    开发工具与关键技术:MyEclipse 10/Java
    作者:陈希雄 
    撰写时间:2019年07月05日
    
    新增
    //新增用户
    	@Override
    	public int userRegDao(User u) {
    		// 声明变量
    		int index = 0; 
           Connection conn=null;
    		// 加载驱动
    		Class.forName(driver);
    		// 获取连接对象 jdbc:mysql://localhost:3306/test
    		conn = DriverManager.getConnection(url, name, password);		// 创建sql命令
    		String sql = "insert into u_user value(default,?,?,?,?,?)";
    		try {
    			// 创建 sql命令对象
    			ps = conn.prepareStatement(sql);
    			ps.setString(1, u.getUname());
    			ps.setString(2, u.getPwd());
    			ps.setInt(3,u.getAge());
    			ps.setString(4, u.getSex());
    			ps.setString(5, u.getBirth());
    			index = ps.executeUpdate();
    			
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return index;
    	}
    查询
    //查询所有用户
    	@Override
    	public List<User> userShowDao() {
    		//声明数据储存对象
    		List<User> list=null;
    		User u=null;
    		Connection conn=null;
    		// 加载驱动
    		Class.forName(driver);
    		// 获取连接对象 jdbc:mysql://localhost:3306/test
    		conn = DriverManager.getConnection(url, name, password);	    //创建命令
    		String sql="select * from u_user";
    		try {
    			//创建 sql命令对象
    			ps=conn.prepareStatement(sql);
    			rs=ps.executeQuery();
    			//给集合赋值
    			list=new ArrayList<User>();
    			//遍历执行结果
    			while(rs.next()){
    				//给变量赋值
    				u=new User();
    				u.setUid(rs.getInt("uid"));
    				u.setUname(rs.getString("uname"));
    				u.setPwd(rs.getString("pwd"));
    				u.setSex(rs.getString("sex"));
    				u.setAge(rs.getInt("age"));
    				u.setBirth(rs.getString("birth"));
    				list.add(u);
    			}
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return list;
    	}
    修改
    //根据用户ID修改用户密码
    	@Override
    	public int userChangePwdDao(String newPwd, int uid) {
    		//声明变量
    		int index=0;
    		Connection conn=null;
    		// 加载驱动
    		Class.forName(driver);
    		// 获取连接对象 jdbc:mysql://localhost:3306/test
    		conn = DriverManager.getConnection(url, name, password);		//创建sql命令
    		String sql="update u_user set pwd=? where uid=?";
    		try {
    			//创建 sql命令对象
    			ps=conn.prepareStatement(sql);
    			//给占位符赋值
    			ps.setString(1, newPwd);
    			ps.setInt(2, uid);
    			//执行
    			index=ps.executeUpdate();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			//关闭资源
    			Jdbc.close(conn, ps, rs);
    		}
    		
    		return index;
    	}
    删除
    //删除
    	public static Integer detele(String sql, String newPwd, int uid){
    		//返回值
    		int index=0;
    		Connection conn=null;
    		// 加载驱动
    		Class.forName(driver);
    		// 获取连接对象 jdbc:mysql://localhost:3306/test
    		conn = DriverManager.getConnection(url, name, password);		try {
    			ps=con.prepareStatement(sql);
    			//给占位符赋值
    			ps.setString(1, newPwd);
    			ps.setInt(2, uid);
    			//执行
    			index=ps.executeUpdate();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			DbUilt.close(con, ps, rs);
    		}
    		return index;
    	}
    总结:executeUpdate() 对于增删改的操作,executeQuery() 对于查询操作
    
    展开全文
  • 毕业以后开始学Java,接手的第一份分作内容,搭建SSM框架并实现小模块的增删查改。因为拿到的项目就开始学习,项目都已经部署好了,整合都已经完整,今天将一下,我自己学到的东西。 模块的整...

    SSM框架:Spring+SpringMvc+Maven
    环境搭建:环境变量的设置path,classpath路径设置,然后dos命令看是否成功
    工具:maven的环境搭建和tomcat的部署,idea项目的建立
    毕业以后开始学Java,接手的第一份工作内容,搭建SSM框架并实现小模块的增删查改。因为拿到的项目就开始学习,项目都已经部署好了,整合都已经完整,今天总结一下,我自己学到的东西。
    模块的整体编写过程:
    1、构造Java实体类
    2、逆向生成dao和mapper
    3、编写web前端要用的jsp页面,需要掌握html+css+javascript
    4、controller层操作jsp,然后调用service层的方法
    5、serviceImpl层是service方法的具体实现,然后再调用dao层的增删查改方法,最后到mapper层操作数据库 mysql

    我的学习重点在:controller层调用方法以后,拿到的数据返回放在List集合(有序集合),然后再遍历传到jsp的页面table里面,所以要用list集合的有序性输出,注意这里可以用多个list集合进行填充需要的数据。

    细节:
    1、方法的具体实现,要合理合适
    2、对数据的处理,List集合的三种遍历方式,此处重点

    List<String> list = new ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    方法一:
    超级for循环遍历
    for(String attribute : list) {
      System.out.println(attribute);
    }
    方法二:
    对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
    for(int i = 0 ; i < list.size() ; i++) {
      system.out.println(list.get(i));
    }
    方法三:
    集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
    Iterator it = list.iterator();
    while(it.hasNext()) {
      System.ou.println(it.next);
    }
    

    3、List集合和Set集合的转化(Set集合的无序性)
    4、List集合和数组的互相转化
    5、填充jsp的table,需要对table格式处理,td或者tr的单元格合并,有rowspan和colspan两个属性的简单操作,还有外部js的控制合并,要在table填充完数据后才执行script的合并代码`

    <SCRIPT type="text/javascript" LANGUAGE="JavaScript">
        function autoRowSpan1(tb,row,col) {
            var nextValue = "";
            var value = "";
            for (var i = row; i < tb.rows.length; i++) {
                value = tb.rows[i].cells[col].innerText;
                nextValue = tb.rows[i + 1].cells[col].innerText;
                   if (nextValue == value) {
                            tb.rows[i + 1].deleteCell(col);
                            tb.rows[i].cells[col].rowSpan = tb.rows[i].cells[col].rowSpan + 1;
                        } else {
                            value = nextValue;
                        }
                    }
        }
            autoRowSpan1(tb,0,0);
    </SCRIPT> `
    

    6、掌握sql指令的编写简单的增删查改,包括比较复杂的指令

    展开全文
  • Java单链表增删查改操作声明链表描述 - 百度百科描述总结单向链表实现单向链表结构单向链表的增删查改操作Linked 类准备新增操作addHead(T data) 新增为头节点add(int index, T data) 在指定的位置新增节点addLast(T...

    声明

    此文章为个人笔记文,写的都是个人理解,如有哪里有误,还望大佬们指正

    链表描述 - 百度百科

    链表是一种物理 存储单元上非连续、非顺序的存储结构数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构,操作复杂。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)O(1)

    使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。链表有很多种不同的类型:单向链表双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言,如C,C++和Java依靠易变工具来生成链表。

    描述总结

    1. 结构

      链表是一种物理 存储单元上非连续、非顺序的存储结构

    2. 组成

      链表由一系列结点(链表中每一个元素称为结点)组成。

    3. 链表类型

      单向链表、双向链表、循环链表

    单向链表实现

    单向链表结构

    单向链表结构

    单向链表的增删查改操作

    具体功能实现方法如下图:
    功能实现方法

    Linked 类准备

    /**
     * 单向链表
     *  head                                                                 last
     * --------------       --------------      --------------          --------------
     * | data | next | --> | data | next | --> | data | next | ... --> | data | null |
     * --------------       --------------     --------------           --------------
     */
    public class Linked<T> {
    
        /**
         * 头结点
         */
        private Node head;
    
        /**
         * 覆写 Object.toString 方法, 方便输出
         * @return 链表数据组成的字符串, 格式如: [data1, data2, data3,...,dataN]
         */
        @Override
        public String toString() {
            StringBuffer text = new StringBuffer();
            Node pNode = this.head;
            while (pNode != null) {
                text.append(",").append(pNode.data);
                pNode = pNode.next;
            }
            if (text.length() > 0) {
                text.deleteCharAt(0);
            }
            return "Linked[" + text.toString() +']';
        }
    
        /**
         * 节点
         */
        class Node{
            /**
             * 节点存放的元素(数据)
             */
            T data;
    
            /**
             * 节点指向的下一个节点
             */
            Node next;
    
            /**
             * 根据元素进行构造节点
             * @param data 元素
             */
            public Node(T data) {
                this(data, null);
            }
    
            /**
             * 根据元素和下一个节点进行构造节点
             * @param data 元素
             * @param next 下一个节点
             */
            public Node(T data, Node next) {
                this.data = data;
                this.next = next;
            }
        }
    }
    
    

    新增操作

    addHead(T data) 新增为头节点

    /**
     * 增加头结点
     *  1. 当前元素节点下一个节点 指向 之前头节点
     *  2. 头结点 指向 当前元素节点
     * @param data 元素
     * @return true: 成功; false: 失败
     */
    public boolean addHead (T data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
        return true;
    }
    

    add(int index, T data) 在指定的位置新增节点

    /**
     * 向 链表 某个位置添加节点
     * @param index 位置
     * @param data 元素
     * @return true: 成功; false: 失败(在找不到节点时会失败)
     */
    public boolean add (int index, T data) {
        // 索引为 0, 则增加为头节点
        if (index == 0) {
            return this.addHead(data);
        }
        // 根据 索引位置 寻找到该节点的前一个节点
        Node frontNode = this.head;
        for (int i = 1; i < index; i++) {
            frontNode = frontNode.next;
            // 找不到,则返回false --> 失败
            if (frontNode == null) {
                return false;
            }
        }
        // 1. 根据 前一个节点的下个节点 得到 索引位置对应的节点
        // 2. 前一个节点的下个节点 指向 当前添加的元素节点
        // 3. 当前添加的元素节点下个节点 指向 索引位置对应的节点
        Node nextNode = frontNode.next;
        Node newNode = new Node(data);
        frontNode.next = newNode;
        newNode.next = nextNode;
        return true;
    }
    

    addLast(T data) 新增为最后一个节点(尾节点)

    /**
     * 向链表最后添加元素节点
     * @param data 元素
     * @return true: 成功; false: 失败
     */
    public boolean addLast (T data) {
        // 头节点为空, 则增加为头节点
        if (this.head == null) {
            return this.addHead(data);
        }
        // 寻找最后一个节点
        Node lastNode = this.head;
        while (lastNode != null) {
            // 下一个节点为空, 则表示尾节点
            if (lastNode.next == null) {
                break;
            }
            lastNode = lastNode.next;
        }
        // 最后节点 下一个节点 指向 添加的元素节点
        lastNode.next = new Node(data);
        return true;
    }
    

    查询操作

    getHead(T data) 获取头节点的元素数据

    /**
     * 获取头结点的元素
     * @return null(在链表为空时会失败) 或 头结点的元素
     */
    public T getHead() {
        return this.isEmpty() ? null : this.head.data;
    }
    

    get(int index, T data) 获取指定位置节点的元素数据

    /**
     * 根据 索引位置获取元素
     * @param index 索引位置
     * @return null 或 索引位置对应的结点的元素
     */
    public T get(int index) {
        // 索引为0, 直接获取头结点元素
        if (index == 0) {
            return this.getHead();
        }
        // 获取索引位置对应的节点,当索引位置超出,则返回为null
        // 循环从
        Node pNode = this.head;
        for (int i = 1; i <= index; i++) {
            pNode = pNode.next;
            // 索引位置超出, 直接返回 null
            if (pNode == null) {
                return null;
            }
        }
        return pNode.data;
    }
    

    getLast(T data) 获取最后一个节点的元素数据

    /**
     * 获取链表尾节点元素
     * @return null(在找不到节点时会失败) 或 尾节点的元素
     */
    public T getLast() {
        if (this.isEmpty()) {
            return null;
        }
        // 循环寻找尾节点, 如果有节点的下一个节点为空, 则代表该节点为尾结点
        Node lastNode = this.head;
        while (lastNode != null) {
            if (lastNode.next == null) {
                break;
            }
            lastNode = lastNode.next;
        }
        return lastNode.data;
    }
    

    删除操作

    removeHead() 删除头节点

    /**
     * 删除头结点
     * @return true: 成功; false: 失败(在头节点为空时会失败)
     */
    public boolean removeHead() {
        if (this.isEmpty()) {
            return false;
        }
        this.head = this.head.next;
        return true;
    }
    

    remove(int index) 删除指定位置的节点

    /**
     * 根据索引位置删除节点
     * @param index 索引位置
     * @return true: 成功; false: 失败(在找不到节点时会失败)
     */
    public boolean remove(int index) {
        // 当索引位置为0, 删除头结点
        if (index == 0) {
            return this.removeHead();
        }
        // 根据索引位置找到 需要删除的节点 的前一个节点
        Node frontNode = this.head;
        for (int i = 1; i < index; i++) {
            frontNode = frontNode.next;
            // 索引位置还没遍历完,节点下一个节点 为空, 直接返回false
            if (frontNode == null) {
                return false;
            }
        }
        // 将 需要删除的节点 的前一个节点 指向 需要删除的节点 的下一个节点
        Node next = frontNode.next;
        frontNode.next = next.next;
        return true;
    }
    

    remove(T data) 根据元素删除节点

    /**
     * 根据元素删除节点
     * @param data 元素
     * @return true: 成功; false: 失败(在找不到节点时会失败)
     */
    public boolean remove (T data) {
        // 链表为空, 返回删除失败
        if (this.isEmpty()) {
            return false;
        }
        // 如果头节点恰巧和元素一样, 则删除头元素
        if (this.head.data.equals(data)) {
            return this.removeHead();
        }
        // 根据元素找到 需要删除的节点 的前一个节点
        Node frontNode = this.head;
        Node pNode = frontNode.next;
        while (pNode != null) {
            // 找到了元素对应的节点, 然后将 需要删除的节点 的前一个节点 指向 需要删除的节点 的下一个节点
            if (pNode.data.equals(data)) {
                frontNode.next = pNode.next;
                return true;
            }
            // 记录前一个节点 和 循环查找 需要删除的节点
            frontNode = pNode;
            pNode = pNode.next;
        }
        // 找不到 需要删除的节点, 返回false, 代表失败
        return false;
    }
    

    removeLast() 删除最后一个节点(尾节点)

    /**
     * 删除尾结点
     * @return true: 成功; false: 失败(在找不到尾节点时会失败)
     */
    public boolean removeLast() {
        // 链表为空 或 没有尾结点, 返回false, 代表失败
        if (this.isEmpty()) {
            return false;
        }
        // 寻找 尾节点 的 前一个节点,然后将该节点一下个节点指向为空
        Node frontNode = this.head;
        Node pNode = frontNode.next;
        while (pNode != null) {
            pNode = pNode.next;
            if (pNode != null) {
                frontNode = frontNode.next;
            }
        }
        frontNode.next = null;
        return true;
    }
    

    修改操作

    setHead(T data) 修改头节点元素数据

    /**
     * 重新 设置头节点的元素
     * @param data 新的元素
     * @return true: 成功; false: 失败(在找不到头节点时会失败)
     */
    public boolean setHead (T data) {
        if (this.isEmpty()) {
            return false;
        }
        head.data = data;
        return true;
    }
    

    set(int index, T data) 修改指定节点元素数据

    /**
     * 根据索引位置 设置 节点的元素
     * @param index 索引位置
     * @param data 元素
     * @return true: 成功; false: 失败(在找不到节点时会失败)
     */
    public boolean set (int index, T data) {
        // 如果索引为0, 则进行设置头结点元素
        if (index == 0) {
            return this.setHead(data);
        }
        // 寻找到需要修改元素的节点;
        // 如果在寻找时, 节点为空, 则代表没有该索引位置节点, 直接返回false
        Node pNode = this.head;
        for (int i = 1; i <= index; i++) {
            pNode = pNode.next;
            if (pNode == null) {
                return false;
            }
        }
        // 修改节点元素
        pNode.data = data;
        return true;
    }
    

    setLast(T data)修改最后一个节点(尾节点)元素数据

    /**
     * 设置尾结点元素
     * @param data 新的元素
     * @return true: 成功; false: 失败(在找不到尾节点时会失败)
     */
    public boolean setLast (T data) {
        // 如果链表为空, 直接返回false
        if (this.isEmpty()) {
            return false;
        }
        // 寻找尾节点, 然后进行设置节点元素值为新的元素
        Node lastNode = this.head;
        while (lastNode.next != null) {
            lastNode = lastNode.next;
        }
        lastNode.data = data;
        return true;
    }
    

    其他操作

    contains(T data) 判断链表是否包含对应的元素数据

    /**
     * 判断链表是否包含对应的元素数据
     * @param data 元素
     * @return true : 不包含; false : 包含
     */
    public boolean contains(T data) {
        // 如果链表为空, 直接返回false
        if (this.isEmpty()) {
            return false;
        }
        // 从头节点开始遍历,如果匹配上则返回true, 匹配不上, 返回false
        Node pNode = this.head;
        while (pNode != null) {
            if (pNode.data.equals(data)) {
                return true;
            }
            pNode = pNode.next;
        }
        return false;
    }
    

    isEmpty() 判断链表是否为空

    /**
     * 判断链表是否为空
     * @return true: 为空; false: 不为空
     */
    public boolean isEmpty() {
        return this.head == null;
    }
    

    测试

    代码

    public class LinkedTest {
    
        public static void main(String[] args) {
            Linked<Integer> intLinked = new Linked<>();
    
            System.out.println("----------------- 测试 链表新增操作start -----------------");
            // 测试空链表时 新增头节点
            intLinked.addHead(-1);
            System.out.println("空链表时 新增头节点 intLinked.addHead(-1) -> " + intLinked);
    
            // 测试新增节点位置为0 -> 新增头节点
            intLinked.add(0, 1);
            System.out.println("新增节点位置为0 -> 新增头节点 intLinked.add(0, 1) -> " + intLinked);
    
            // 测试链表不为时 新增头节点
            intLinked.addHead(0);
            System.out.println("试链表不为时 新增头节点 intLinked.addHead(0) -> " + intLinked);
    
            // 测试 新增尾节点
            intLinked.addLast(2);
            System.out.println("新增尾节点 intLinked.addLast(2) -> " + intLinked);
            System.out.println("----------------- 测试 链表新增操作end -----------------\n");
    
            System.out.println("----------------- 测试 链表查询操作start -----------------");
            // 测试 新增指定位置节点
            intLinked.add(3, 3);
            intLinked.add(4, 4);
            System.out.println("新增指定位置节点 intLinked.add(3, 3);intLinked.add(4, 4); -> " + intLinked);
    
            // 测试 获取头结点元素数据
            System.out.println("获取头结点元素数据 intLinked.getHead() -> " + intLinked.getHead());
    
            // 测试 获取指定位置结点元素数据
            System.out.println("获取指定位置结点元素数据 intLinked.get(1) -> " + intLinked.get(1));
            // 测试 获取指定位置结点元素数据(不存在的节点)
            System.out.println("获取指定位置结点元素数据(不存在的节点) intLinked.get(9) -> " + intLinked.get(9));
            // 测试 获取尾结点元素数据
            System.out.println("获取尾结点元素数据 intLinked.getLast() -> " + intLinked.getLast());
            System.out.println("----------------- 测试 链表查询操作end -----------------\n");
    
            System.out.println("----------------- 测试 链表删除操作start -----------------");
            // 测试 删除头节点
            System.out.println("删除头节点 intLinked.removeHead() -> " + intLinked.removeHead() + "; 链表: " + intLinked);
            // 测试 删除指定位置节点
            System.out.println("删除指定位置节点 intLinked.remove(1) -> " + intLinked.remove(1) + "; 链表: " + intLinked);
            // 测试 删除指定位置节点(不存在的节点)
            System.out.println("删除指定位置节点(不存在的节点) intLinked.remove(9) -> " + intLinked.remove(9) + "; 链表: " + intLinked);
            // 测试 删除指定元素节点
            System.out.println("删除指定元素节点 intLinked.remove(new Integer(3)) -> " + intLinked.remove(new Integer(3)) + "; 链表: " + intLinked);
            // 测试 删除尾节点
            System.out.println("删除尾节点 intLinked.removeLast() -> " + intLinked.removeLast() + "; 链表: " + intLinked);
            System.out.println("----------------- 测试 链表删除操作end -----------------\n");
    
            System.out.println("----------------- 测试 链表修改操作start -----------------");
            // 测试 修改头节点
            System.out.println("修改头节点 intLinked.setHead(-2) -> " + intLinked.setHead(-2)+ "; 链表: " + intLinked);
            // 测试 修改指定位置节点
            System.out.println("修改指定位置节点 intLinked.set(1, 0) -> " + intLinked.set(1, 0) + "; 链表: " + intLinked);
            // 测试 修改指定位置节点(不存在的节点)
            System.out.println("修改指定位置节点(不存在的节点) intLinked.set(9, 8) -> " + intLinked.set(9, 8) + "; 链表: " + intLinked);
            // 测试 修改尾节点
            System.out.println("修改尾节点 intLinked.setLast(666) -> " + intLinked.setLast(666) + "; 链表: " + intLinked);
            System.out.println("----------------- 测试 链表修改操作end -----------------\n");
    
            System.out.println("----------------- 测试 链表其他操作start -----------------");
            // 测试 链表是否包含该元素
            System.out.println("链表是否包含该元素 intLinked.contains(666) -> " + intLinked.contains(666) + "; 链表: " + intLinked);
            // 测试 链表是否包含该元素(不存在的元素)
            System.out.println("链表是否包含该元素(不存在的元素) intLinked.contains(777) -> " + intLinked.contains(7777) + "; 链表: " + intLinked);
    
            // 测试 链表是否为空
            Linked<String> strLinked = new Linked<>();
            System.out.println("链表是否为空 strLinked.isEmpty() -> " + strLinked.isEmpty() + "; 链表: " + strLinked);
            // 测试 链表是否为空(不为空)
            strLinked.add(0, "Hello");
            System.out.println("链表是否为空(不为空) strLinked.isEmpty() -> " + strLinked.isEmpty() + "; 链表: " + strLinked);
            System.out.println("----------------- 测试 链表其他操作end -----------------");
        }
    
    }
    

    测试结果

    ----------------- 测试 链表新增操作start -----------------
    空链表时 新增头节点 intLinked.addHead(-1) -> Linked[-1]
    新增节点位置为0 -> 新增头节点 intLinked.add(0, 1) -> Linked[1,-1]
    试链表不为时 新增头节点 intLinked.addHead(0) -> Linked[0,1,-1]
    新增尾节点 intLinked.addLast(2) -> Linked[0,1,-1,2]
    ----------------- 测试 链表新增操作end -----------------
    
    ----------------- 测试 链表查询操作start -----------------
    新增指定位置节点 intLinked.add(3, 3);intLinked.add(4, 4); -> Linked[0,1,-1,3,4,2]
    获取头结点元素数据 intLinked.getHead() -> 0
    获取指定位置结点元素数据 intLinked.get(1) -> 1
    获取指定位置结点元素数据(不存在的节点) intLinked.get(9) -> null
    获取尾结点元素数据 intLinked.getLast() -> 2
    ----------------- 测试 链表查询操作end -----------------
    
    ----------------- 测试 链表删除操作start -----------------
    删除头节点 intLinked.removeHead() -> true; 链表: Linked[1,-1,3,4,2]
    删除指定位置节点 intLinked.remove(1) -> true; 链表: Linked[1,3,4,2]
    删除指定位置节点(不存在的节点) intLinked.remove(9) -> false; 链表: Linked[1,3,4,2]
    删除指定元素节点 intLinked.remove(new Integer(3)) -> true; 链表: Linked[1,4,2]
    删除尾节点 intLinked.removeLast() -> true; 链表: Linked[1,4]
    ----------------- 测试 链表删除操作end -----------------
    
    ----------------- 测试 链表修改操作start -----------------
    修改头节点 intLinked.setHead(-2) -> true; 链表: Linked[-2,4]
    修改指定位置节点 intLinked.set(1, 0) -> true; 链表: Linked[-2,0]
    修改指定位置节点(不存在的节点) intLinked.set(9, 8) -> false; 链表: Linked[-2,0]
    修改尾节点 intLinked.setLast(666) -> true; 链表: Linked[-2,666]
    ----------------- 测试 链表修改操作end -----------------
    
    ----------------- 测试 链表其他操作start -----------------
    链表是否包含该元素 intLinked.contains(666) -> true; 链表: Linked[-2,666]
    链表是否包含该元素(不存在的元素) intLinked.contains(777) -> false; 链表: Linked[-2,666]
    链表是否为空 strLinked.isEmpty() -> true; 链表: Linked[]
    链表是否为空(不为空) strLinked.isEmpty() -> false; 链表: Linked[Hello]
    ----------------- 测试 链表其他操作end -----------------
    
    

    单向链表实现全部代码

    /**
     * 单向链表
     *  head                                                                 last
     * --------------       --------------      --------------          --------------
     * | data | next | --> | data | next | --> | data | next | ... --> | data | null |
     * --------------       --------------     --------------           --------------
     */
    public class Linked<T> {
    
        /**
         * 头结点
         */
        private Node head;
    
        /**
         * 增加头结点
         *  1. 当前元素节点下一个节点 指向 之前头节点
         *  2. 头结点 指向 当前元素节点
         * @param data 元素
         * @return true: 成功; false: 失败
         */
        public boolean addHead (T data) {
            Node newNode = new Node(data);
            newNode.next = head;
            head = newNode;
            return true;
        }
    
        /**
         * 向 链表 某个位置添加节点
         * @param index 位置
         * @param data 元素
         * @return true: 成功; false: 失败(在找不到节点时会失败)
         */
        public boolean add (int index, T data) {
            // 索引为 0, 则增加为头节点
            if (index == 0) {
                return this.addHead(data);
            }
    
            // 根据 索引位置 寻找到该节点的前一个节点
            Node frontNode = this.head;
            for (int i = 1; i < index; i++) {
                frontNode = frontNode.next;
                // 找不到,则返回false --> 失败
                if (frontNode == null) {
                    return false;
                }
            }
            // 1. 根据 前一个节点的下个节点 得到 索引位置对应的节点
            // 2. 前一个节点的下个节点 指向 当前添加的元素节点
            // 3. 当前添加的元素节点下个节点 指向 索引位置对应的节点
            Node nextNode = frontNode.next;
            Node newNode = new Node(data);
            frontNode.next = newNode;
            newNode.next = nextNode;
            return true;
        }
    
        /**
         * 向链表最后添加元素节点
         * @param data 元素
         * @return true: 成功; false: 失败
         */
        public boolean addLast (T data) {
            // 头节点为空, 则增加为头节点
            if (this.head == null) {
                return this.addHead(data);
            }
            // 寻找最后一个节点
            Node lastNode = this.head;
            while (lastNode != null) {
                // 下一个节点为空, 则表示尾节点
                if (lastNode.next == null) {
                    break;
                }
                lastNode = lastNode.next;
            }
            // 最后节点 下一个节点 指向 添加的元素节点
            lastNode.next = new Node(data);
            return true;
        }
    
        /**
         * 获取头结点的元素
         * @return null(在链表为空时会失败) 或 头结点的元素
         */
        public T getHead() {
            return this.isEmpty() ? null : this.head.data;
        }
    
        /**
         * 根据 索引位置获取元素
         * @param index 索引位置
         * @return null 或 索引位置对应的结点的元素
         */
        public T get(int index) {
            // 索引为0, 直接获取头结点元素
            if (index == 0) {
                return this.getHead();
            }
            // 获取索引位置对应的节点,当索引位置超出,则返回为null
            // 循环从
            Node pNode = this.head;
            for (int i = 1; i <= index; i++) {
                pNode = pNode.next;
                // 索引位置超出, 直接返回 null
                if (pNode == null) {
                    return null;
                }
            }
            return pNode.data;
        }
    
        /**
         * 获取链表尾节点元素
         * @return null(在找不到节点时会失败) 或 尾节点的元素
         */
        public T getLast() {
            if (this.isEmpty()) {
                return null;
            }
    
            // 循环寻找尾节点, 如果有节点的下一个节点为空, 则代表该节点为尾结点
            Node lastNode = this.head;
            while (lastNode != null) {
                if (lastNode.next == null) {
                    break;
                }
                lastNode = lastNode.next;
            }
            return lastNode.data;
        }
    
        /**
         * 删除头结点
         * @return true: 成功; false: 失败(在头节点为空时会失败)
         */
        public boolean removeHead() {
            if (this.isEmpty()) {
                return false;
            }
            this.head = this.head.next;
            return true;
        }
    
        /**
         * 根据索引位置删除节点
         * @param index 索引位置
         * @return true: 成功; false: 失败(在找不到节点时会失败)
         */
        public boolean remove(int index) {
            // 当索引位置为0, 删除头结点
            if (index == 0) {
                return this.removeHead();
            }
            // 根据索引位置找到 需要删除的节点 的前一个节点
            Node frontNode = this.head;
            for (int i = 1; i < index; i++) {
                frontNode = frontNode.next;
                // 索引位置还没遍历完,节点下一个节点 为空, 直接返回false
                if (frontNode == null) {
                    return false;
                }
            }
            // 将 需要删除的节点 的前一个节点 指向 需要删除的节点 的下一个节点
            Node next = frontNode.next;
            frontNode.next = next.next;
            return true;
        }
    
        /**
         * 根据元素删除节点
         * @param data 元素
         * @return true: 成功; false: 失败(在找不到节点时会失败)
         */
        public boolean remove (T data) {
            // 链表为空, 返回删除失败
            if (this.isEmpty()) {
                return false;
            }
            // 如果头节点恰巧和元素一样, 则删除头元素
            if (this.head.data.equals(data)) {
                return this.removeHead();
            }
            // 根据元素找到 需要删除的节点 的前一个节点
            Node frontNode = this.head;
            Node pNode = frontNode.next;
            while (pNode != null) {
                // 找到了元素对应的节点, 然后将 需要删除的节点 的前一个节点 指向 需要删除的节点 的下一个节点
                if (pNode.data.equals(data)) {
                    frontNode.next = pNode.next;
                    return true;
                }
                // 记录前一个节点 和 循环查找 需要删除的节点
                frontNode = pNode;
                pNode = pNode.next;
            }
            // 找不到 需要删除的节点, 返回false, 代表失败
            return false;
        }
    
        /**
         * 删除尾结点
         * @return true: 成功; false: 失败(在找不到尾节点时会失败)
         */
        public boolean removeLast() {
            // 链表为空 或 没有尾结点, 返回false, 代表失败
            if (this.isEmpty()) {
                return false;
            }
            // 寻找 尾节点 的 前一个节点,然后将该节点一下个节点指向为空
            Node frontNode = this.head;
            Node pNode = frontNode.next;
            while (pNode != null) {
                pNode = pNode.next;
                if (pNode != null) {
                    frontNode = frontNode.next;
                }
            }
            frontNode.next = null;
            return true;
        }
    
        /**
         * 重新 设置头节点的元素
         * @param data 新的元素
         * @return true: 成功; false: 失败(在找不到头节点时会失败)
         */
        public boolean setHead (T data) {
            if (this.isEmpty()) {
                return false;
            }
            head.data = data;
            return true;
        }
    
        /**
         * 根据索引位置 设置 节点的元素
         * @param index 索引位置
         * @param data 元素
         * @return true: 成功; false: 失败(在找不到节点时会失败)
         */
        public boolean set (int index, T data) {
            // 如果索引为0, 则进行设置头结点元素
            if (index == 0) {
                return this.setHead(data);
            }
            // 寻找到需要修改元素的节点;
            // 如果在寻找时, 节点为空, 则代表没有该索引位置节点, 直接返回false
            Node pNode = this.head;
            for (int i = 1; i <= index; i++) {
                pNode = pNode.next;
                if (pNode == null) {
                    return false;
                }
            }
            // 修改节点元素
            pNode.data = data;
            return true;
        }
    
        /**
         * 设置尾结点元素
         * @param data 新的元素
         * @return true: 成功; false: 失败(在找不到尾节点时会失败)
         */
        public boolean setLast (T data) {
            // 如果链表为空, 直接返回false
            if (this.isEmpty()) {
                return false;
            }
            // 寻找尾节点, 然后进行设置节点元素值为新的元素
            Node lastNode = this.head;
            while (lastNode.next != null) {
                lastNode = lastNode.next;
            }
            lastNode.data = data;
            return true;
        }
    
        /**
         * 判断链表是否包含对应的元素数据
         * @param data 元素
         * @return true : 不包含; false : 包含
         */
        public boolean contains(T data) {
            // 如果链表为空, 直接返回false
            if (this.isEmpty()) {
                return false;
            }
            // 从头节点开始遍历,如果匹配上则返回true, 匹配不上, 返回false
            Node pNode = this.head;
            while (pNode != null) {
                if (pNode.data.equals(data)) {
                    return true;
                }
                pNode = pNode.next;
            }
            return false;
        }
    
        /**
         * 判断链表是否为空
         * @return true: 为空; false: 不为空
         */
        public boolean isEmpty() {
            return this.head == null;
        }
    
        /**
         * 覆写 Object.toString 方法, 方便输出
         * @return 链表数据组成的字符串, 格式如: [data1, data2, data3,...,dataN]
         */
        @Override
        public String toString() {
            StringBuffer text = new StringBuffer();
            Node pNode = this.head;
            while (pNode != null) {
                text.append(",").append(pNode.data);
                pNode = pNode.next;
            }
            if (text.length() > 0) {
                text.deleteCharAt(0);
            }
            return "Linked[" + text.toString() +']';
        }
    
        /**
         * 节点
         */
        class Node{
            /**
             * 节点存放的元素(数据)
             */
            T data;
    
            /**
             * 节点指向的下一个节点
             */
            Node next;
    
            /**
             * 根据元素进行构造节点
             * @param data 元素
             */
            public Node(T data) {
                this(data, null);
            }
    
            /**
             * 根据元素和下一个节点进行构造节点
             * @param data 元素
             * @param next 下一个节点
             */
            public Node(T data, Node next) {
                this.data = data;
                this.next = next;
            }
        }
    }
    
    展开全文
  • java编写的实现数据库表的增删查改方法
  • Java数组的增删查改

    2017-07-07 14:25:57
    Java基础对每个程序员都非常重要,最近抽空开始复习Java基础部分,复习到数据结构与算法部分参考...Java数组是Java语言数据结构的最基本组成之一,我在参照网上资料和该书的前提下,写下如下Java数组的增删查改的代码。
          Java基础对每个程序员都非常重要,最近抽空开始复习Java基础部分,复习到数据结构与算法部分参考了美Robert Lafore的Java数据结构与算法第二版,收益匪浅。
    

    故写下博客起到记录、监督自己继续学习的作用,同时也想与大家共同进步。

          Java数组是Java语言数据结构的最基本组成之一,我在参照网上资料和该书的前提下,写下如下Java数组的增删查改的代码。

          代码说明:1.以对象为基本元素,且本文的增删查改仅涉及单个数组元素,且为一维数组。

                              2.在数组中的特定位置插入特定值的算法参考了如下资料:Java数组的指定位置插入一个元素

                              3.第一次在CSDN上发博客,如代码有错误、不当或大家对实现算法有更好的看法,欢迎留言。

                              4.欢迎转载,请注明出处。

        
    /**
     * 对象数组设计及相关方法测试
     * Created by Administrator on 2017/7/7.
     */
    
    /**
     * 人的类,仅有名字和年龄字段。
     */
    class Person{
        private String firstName;
        private String lastName;
        private int age;
    
        /**
         * 人类构造方法
         * @param first
         * @param last
         * @param a
         */
        public Person(String first,String last,int a){
            firstName = first;
            lastName = last;
            age = a;
        }
        /**
         * 对象元素显示方法,可用toString()方法代替
         */
        public void displayPerson(){
            System.out.println("firstName:"+firstName);
            System.out.println("lastName:"+lastName);
            System.out.println("age:"+age);
        }
        public String getLastName(){
            return lastName;
        }
        public String getFirstName(){
            return firstName;
        }
        public int getAge(){
            return age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "firstName='" + firstName + '\'' +
                    ", lastName='" + lastName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    /**
     * 存储人的类的对象数组,并可以进行增删查改(由于数组长度不可变,故增操作不可超过最大长度。)
     */
    class DataArrayPerson{
        private Person[] a;//初始化数组
        int num;//元素下标
    
        /**
         * 对象数组构造方法
         * @param max
         */
        public DataArrayPerson(int max){//构造函数,仅初始化数组的最大元素容量
            a= new Person[max];
            num=0;
        }
    
        /**
         * 初始化插入
         * @param person
         */
        public void insert(Person person){//向数组中插入人对象
            a[num]=person;
            num++;
        }
    
        /**
         * 特定位置插入数组元素
         * 方法:构造第二个数组来移动插入元素后的所有元素
         * @param key , p
         */
        public int insertByKeyAndValue(int key, Person p){
    //        System.out.println(a.length); //元素个数
            Person [] b = new Person[a.length+1];//由于要移动插入元素后的所有元素,故长度要加1
            if(key<0||key>=a.length){//判断当前插入位置的下标是否合法
                return -1;
            }else {
                for (int i = 0; i < a.length; i++) {
                    b[i]=a[i];//将a数组的所有元素移到b数组,b数组空出最后一个位置
                }
                for (int i=key; i< b.length-1;i++){
                    b[i+1]=a[i];//将报括从插入位置开始的原先的元素向后移,插入的位置空出
                }
                b[key]=p;//插入元素
                a=b;//还原
                return 1;
            }
    }
        public void delete(String searchKey){//按数组-对象-关键字的方式找到值然后删除
            if (find(searchKey)==-1){
                System.out.println("此人不存在,无法删除!");
            }else{
                for (int j = find(searchKey); j < num; j++) {
                    a[j]=a[j+1];
                }
                num--;
                System.out.println("删除指定对象后的数组为:");
                displayDataArray();
            }
    
        }
        public int find(String searchName){//按人的首名查询
            int i;
            for (i = 0; i < num; i++) {
                if (a[i].getFirstName().equals(searchName)){
                    break;
                }
            }
            if (i==num){
                return -1;
            }
            return i;
        }
    
        /**
         * 打印数组
         */
        public void displayDataArray(){
            for (int i = 0; i < a.length; i++) {
                if (a[i]==null){
                    continue;//当前元素为空则跳出当前循环
                }
                System.out.println("当前元素为:"+a[i]+",当前下标为:"+i);
            }
        }
    }
    
    /**
     * 测试类
     */
    public class ClassDateApp {
        public static void main(String[] args) {
            Person p0 = new Person("li","bai",34);
            Person p1 = new Person("ma","bai0",34);
            Person p2 = new Person("zhao","bai1",34);
            Person p3 = new Person("sun","bai2",34);
            Person p4 = new Person("zhou","bai3",34);
            Person p5 = new Person("wu","bai4",34);
            Person p6 = new Person("xu","bai5",34);
            Person p7 = new Person("zhu","bai6",34);
            Person p8 = new Person("feng","bai7",34);
            Person p9 = new Person("chen","bai8",34);
            Person pt = new Person("ceshi","baice",35);
            Person pt1 = new Person("ceshi1","baice1",35);
            DataArrayPerson da = new DataArrayPerson(100);
            da.insert(p0);
            da.insert(p1);
            da.insert(p2);
            da.insert(p3);
            da.insert(p4);
            da.insert(p5);
            da.insert(p6);
            da.insert(p7);
            da.insert(p8);
            da.insert(p9);
            /**
            * 根据人的姓查找(也可根据其它方式查找,方法相同)
            */
            int findIndex=da.find("lao");
            if (findIndex==-1){
                System.out.println("此人不存在!");
            }else {
                System.out.println("此人存在且元素下标为:"+findIndex);
            }
            /**
             * 插入指定元素第一次测试
             */
           if (da.insertByKeyAndValue(4,pt)==-1){
               System.out.println("键值不合法!");
           }else {
               System.out.println("插入成功!新数组为:");
               da.displayDataArray();
           }
            /**
             * 插入指定元素第二次测试
             */
            if (da.insertByKeyAndValue(36,pt1)==-1){
                System.out.println("键值不合法!");
            }else {
                System.out.println("插入成功!新数组为:");
                da.displayDataArray();
            }
            /**
             * 删除方法测试
             */
            da.delete("xu");
     }
    
    }
    

            从上述代码可以看出,由于无序数组在插入时不需要寻找特定位置,故无序数组的插入时间复杂度为O(1)。而其它如有序数组的插入、数组元素的删除时间复杂度都为O(N),因为它们都需要寻找特定位置且要移动过半以上的元素。

           其它与数组相关的算法时间复杂度总结:

             线性查找:O(N),二分查找O(logN)。

          


    展开全文
  • Java初学之ArrayList实现购物车的增删查改 1、需求说明 2、代码 import java.util.ArrayList; import java.util.Iterator; import java.util.Scanner; /** * 购物车系统 * @author com * */ public class ...
  • JDBC—增删查改

    2019-07-15 19:38:41
    复习归纳总结之 JDBC 简单增删查改~
  • 在操作修改数据时,往往只需要改动一个值或少数几个值。 例如一条记录含有主键id, ...// User user=new User(125,"杨XX","男",new Date(new java.util.Date().getTime()),"K9501"); userDao.updateUser(user); }
  • MySQLⅡ增删查改

    2021-06-02 21:34:28
    增删查改(CURD) 以此student表为例: drop table if exists student; create table student( id INT, sn INT, name VARCHAR(20), qq_mail VARCHAR(20) ); 增加 单列全列插入 每次只能插
  • 数据结构:二叉搜索树的增删查改

    热门讨论 2021-03-29 16:09:26
    二叉查找树的增删查改
  • 大数据系列之Java调用elasticsearch的增删查改聚合 添加pom.xml依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...
  • 增删查改
  • MyBatis的增删查改

    2019-07-25 21:23:28
    MyBatis的增删查改 先创建pojo实体类 package com.kuang.pojo; public class User { private int id; private String name; private String pwd; public User() { } public User(int id, String name...
  • JDBCTemplate实现增删查改

    千次阅读 2017-07-09 21:56:31
    今天终于把这两天一直困扰我的问题解决了,就是利用JDBCTemplate实现增删查改,对数据库进行操作。 直接进入正题 先贴框架 需要导入的jar包 junit;spring-context;spring-jdbc;mysql-connector-java。 然后是...
  • 自定义MVC框架-增删查改,请再等一下,马上更新呢
  • MySQL表的增删查改(适合初阶学习)

    千次阅读 热门讨论 2020-10-31 17:21:52
    二、MySQL的增删查改1.新增(Create)2.删除(Delecte)3.查询(Retrieve)4. 修改(Update)总结 前言 一、 CRUD? CRUD : Create, Retrieve,Update,Delete 其实就是增删查改的简写,但是为了
  • 文章目录Mybaits接口方式实现增删查改定义一个dao层的接口定义该接口的xml映射文件测试一个下 Mybaits接口方式实现增删查改 ​ IUserDao.xml 其实定义了dao层接口的方法,定义了使用的sql语句,返回值,传入参数等。...
  • Java后端开发过程中,往往会遇到需要实现对数据表进行增删查改的接口,这种任务难度比较低,但是操作比较繁琐,而且代码实现起来也是千篇一律的样式,下面是一种自己总结出来的快速生成增删查改代码的方法,采用...
  • 文章目录一、链表的概念和结构1.链表的概念2.链表的分类二、单向不带头非循环链表1.创建节点类型2.头插法3.尾插法4.获取链表长度5....置空链表总结 一、链表的概念和结构 1.链表的概念 简单来说链
  • Spring boot (一) —— 增删查改 本篇介绍如何使用spring boot 框架实现对数据的增删查改操作。这里先介绍一下我使用的工具。 编译器:IDEA 数据库:postgre 测试工具:postman 数据库工具:Navicat Premium 12 一...
  • 前两天学习了mybatis连接数据库,实现增删查改,和前面的文章JDBC实现增删查改有异曲同工之妙,在此记录,遗忘的时候翻一翻。 首先,还是建项目,什么项目?maven项目,不讲了,去翻前面的文章。 直接贴项目结构 ...
  • C++动态数组vector(增删查改

    千次阅读 2018-08-31 16:54:15
    这里做了比较全面的vector的增删查改操作,以及加入对象,可以理解为JAVA的Collection类,只是API的定义名称有差异而已。 Maqi对象: #include &lt;iostream&gt; #include &lt;cstring&gt; using...
  • ArrayList和LinkedList增删查改详解

    千次阅读 2018-09-04 15:50:15
    上次面试,被面试官怼着问数据结构,问的我很无奈,后来回去查找资料,总结了这一篇有关java数据结构的增删查改的实现的内容。 (一)ArrayList 1 新增 (1)往ArrayList中添加对象,也就是调用add(element)...
  • @RequestMapping("/logicDelete") public Result logicDelete(int id){ if (iTbBrandService.removeById(id)){ return new Result("1","删除成功"); }else { return new Result("2","删除失败");...
  • c++比c多了vector的功能,可以方便对数组进行增删查改; python没数组的概念; c、c++、java、go定义数组时都需要花括号来定义元素(后面的章节会讲解如何记忆和快速查看每种语言的语法);
  • MyBatis实现增删查改

    2020-01-21 02:43:05
    实体类数据库字段名与类属性相同 public class People { private int id; private String name;...<insert id="insOne" parameterType="people"> insert into people values(default,#{name},#{...
  • java的写法 public static void main(String[] args) { List list = new ArrayList(); //定义list list.add(1); //list中添加元素 list.add(2); list.remove(0); //删除list中的第一个元素 list.get(0); /...
  • 复习归纳总结基础理论知识之 数组 的前世今生~
  • 配置好hibernate之后,就可以使用其封装的类和方法。...mysqlModel.java: package com.models; import java.util.List; import javax.transaction.HeuristicMixedException; import javax.transaction.HeuristicRol
  • Struts之增删查改

    2019-07-02 09:33:35
    java < / artifactId > < version > 5.1 .44 < / version > < / dependency > < dependency > < groupId > javax . servlet < / groupId > < artifactId > javax . servlet - api < / ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,867
精华内容 1,146
关键字:

java增删查改总结

java 订阅