这篇博客概述

前几天把Java容器部分和数据结构部分知识回顾了一下,通过再次学习对这些内容有了一些新的认识
以后这部分内容还需要更深入的挖掘,我把学习笔记放到了github,点击笔记

单链表的增删查
  • SingleLinkedNode类

    package world.keyi.collection;
    
    /**
     * @author 万一
     * @date 2021年05月06日23:17
     */
    public class SingleLinkedNode {
        //单向链表
        private Object data;
        private SingleLinkedNode next;
    
        public SingleLinkedNode() {
        }
    
        public SingleLinkedNode(Object data) {
            this.data = data;
        }
    
        public SingleLinkedNode(Object data, SingleLinkedNode next) {
            this.data = data;
            this.next = next;
        }
    
        public Object getData() {
            return data;
        }
    
        public void setData(Object data) {
            this.data = data;
        }
    
        public SingleLinkedNode getNext() {
            return next;
        }
    
        public void setNext(SingleLinkedNode next) {
            this.next = next;
        }
    }
  • SingleLinkedOperate类

    /**
     * @author 万一
     * @date 2021年05月06日23:19
     */
    public class SingleLinkedOperate {
        //对单向链表的操作
    
        //增加结点,从最后结点处新增
        public static void addData(SingleLinkedNode head, Object data){
            SingleLinkedNode newNode = new SingleLinkedNode(data);
            SingleLinkedNode temp = head;
            while (temp.getNext()!=null){
                temp=temp.getNext();
            }
            temp.setNext(newNode);
        }
    
        //遍历结点
        public static void traverse(SingleLinkedNode head){
            SingleLinkedNode temp = head;
            while (temp.getNext()!=null){
                System.out.print(temp.getNext().getData()+" ");
                temp=temp.getNext();
            }
        }
    
        //统计链表长度
        public static int length(SingleLinkedNode head){
            SingleLinkedNode temp=head;
            int length = 0;
            while (temp.getNext()!=null){
                length++;
                temp=temp.getNext();
            }
            return length;
        }
    
        //插入结点
        public static void insertNode(SingleLinkedNode head, int index, Object data){
            if(checkIndex(head, index)){
                SingleLinkedNode temp =head;
                int count=0;
                while (temp.getNext()!=null){
                    if (++count==index){
                        SingleLinkedNode newNode = new SingleLinkedNode(data);
                        SingleLinkedNode temp2=temp.getNext();
                        temp.setNext(newNode);
                        newNode.setNext(temp2);
                        break;
                    }
                    temp=temp.getNext();
                }
                System.out.println("插入结点成功");
            }else {
                System.out.println("index越界,插入结点失败");
            }
        }
    
        //检查index是否合法
        public static boolean checkIndex(SingleLinkedNode head,int index){
            boolean flag =true;
            SingleLinkedNode temp =head;
            if (index>length(head)||index<1){
                flag=false;
            }
            return flag;
        }
        //查找结点
        public static void queryNode(SingleLinkedNode head,int index){
            String result;
            if (checkIndex(head,index)){
                SingleLinkedNode temp=head;
                int count=0;
                while (temp.getNext()!=null){
                    if (++count==index){
                        System.out.println("索引"+index+"位置的数据:"
    						+temp.getNext().getData());
                        break;
                    }
                    temp=temp.getNext();
                }
            }else {
                System.out.println("index越界,查找结点失败");
            }
        }
    
        //删除结点
        public static void deleteNode(SingleLinkedNode head,int index){
            if (checkIndex(head, index)) {
                int count=0;
                SingleLinkedNode temp=head;
                while (temp.getNext()!=null){
                    if (++count==index){
                        temp.setNext(temp.getNext().getNext());
                        break;
                    }
                    temp=temp.getNext();
                }
                System.out.println("删除结点成功");
            }else {
                System.out.println("index越界,删除结点失败");
            }
        }
    
        //链表排序
        public static void sort(SingleLinkedNode head){
            SingleLinkedNode temp = head;
            SingleLinkedNode temp2;
            while (temp.getNext()!=null){
                temp2=head;
                while (temp2.getNext()!=null){
                    if (temp2.getData()!=null&&((int)temp2.getData()>
    						(int)temp2.getNext().getData())){
                        int tempData=(int)temp2.getData();
                        temp2.setData(temp2.getNext().getData());
                        temp2.getNext().setData(tempData);
                    }
                    temp2=temp2.getNext();
                }
                temp=temp.getNext();
            }
        }
    
        //删除链表重复数据,渣渣方法
        public static SingleLinkedNode deleteRepeatData(SingleLinkedNode head){
            //创建一个数组,每放一个结点进数组,遍历一次,重复的结点就删除
            SingleLinkedNode temp=head;
            ArrayList<Object> arr = new ArrayList<>();
            ArrayList<SingleLinkedNode> arr2 = new ArrayList<>();
            while (temp.getNext()!=null){
                if (!arr.contains(temp.getNext().getData())){
                    arr.add(temp.getNext().getData());
                    arr2.add(temp.getNext());
                }
                temp=temp.getNext();
            }
    
            head.setNext(arr2.get(0));
            for (int i = 0; i < arr2.size(); i++) {
                //将每一个结点全部断开
                arr2.get(i).setNext(null);
                if ((i+1)<arr2.size()){
                    SingleLinkedNode node = arr2.get(i);
                    SingleLinkedNode node2 = arr2.get(i+1);
                    node.setNext(node2);
                }
            }
            return head;
        }
    
        public static void main(String[] args) {
            SingleLinkedNode head = new SingleLinkedNode();
            addData(head,7);
            addData(head,7);
            addData(head,7);
            addData(head,7);
            addData(head,7);
            traverse(head);
            System.out.println();
            SingleLinkedNode newNode = deleteRepeatData(head);
            traverse(head);
    //        sort(head);
    //        System.out.println();
    //        traverse(head);
            //插入结点
    //        String result = insertNode(head, 5, 6);
    //        System.out.println(result);
    //        traverse(head);
    //        System.out.println();
            //查询结点
    //        queryNode(head,5);
    //        deleteNode(head,0);
    //        traverse(head);
        }
    }
近期目标

五月份主要学习内容是:Java基础内容回顾:
包括Java容器,多线程,注解,泛型,反射,动态代理,NIO,Stream流,常用设计模式,
JVM基础知识,日志处理。目的就是掌握基本概念,写点简单的demo,对这些知识点不至于一问三不知
我知道每一个任务中还有非常多的内容,以后还会不断重复学习。

六月份主要学习内容:SSM+SpringBoot,学习框架的底层原理,特别是Spring框架,
目前这些框架基本都会用,但要说底层原理,个人觉得稍微懂点的只有SpringMVC了,比如参数绑定,
视图解析,内容协商之类的,看网课这里讲的比较细致。

大概这些内容搞定后,就去尝试找个实习工作。