Java提高逼格的套路和知识点

时间  2020-06-03
标签 java 提高 套路 知识 栏目 Java 繁體版
原文   原文链接

https://pintia.cn/java

https://blog.csdn.net/weixin_45031646/article/details/91470296node

(刷题，C语言，gcc编译器承认的一些语法规则) git

提交Java代码套路（public class Main{）github

常见排序web

https://blog.csdn.net/hiudawn/article/details/80380572面试

复杂度redis

排序方法 时间复杂度（平均） 时间复杂度（最坏） 时间复杂度（最好） 空间复杂度 稳定性
冒泡排序 O(n2)O(n2) O(n2)O(n2) O(n)O(n) O(1)O(1) 稳定
选择排序 O(n2)O(n2) O(n2)O(n2) O(n2)O(n2) O(1)O(1) 不稳定
插入排序 O(n2)O(n2) O(n2)O(n2) O(n)O(n) O(1)O(1) 稳定
希尔排序 O(n1.3)O(n1.3) O(n2)O(n2) O(n)O(n) O(1)O(1) 不稳定
快速排序 O(nlog2n)O(nlog2n) O(n2)O(n2) O(nlog2n)O(nlog2n) O(nlog2n)O(nlog2n) 不稳定
归并排序 O(nlog2n)O(nlog2n) O(nlog2n)O(nlog2n) O(nlog2n)O(nlog2n) O(n)O(n) 稳定
堆排序 O(nlog2n)O(nlog2n) O(nlog2n)O(nlog2n) O(nlog2n)O(nlog2n) O(1)O(1) 不稳定
基数排序 O(n∗k)O(n∗k) O(n∗k)O(n∗k) O(n∗k)O(n∗k) O(n+k)O(n+k) 稳定spring

//链表的创建，内容输出，长度数据库

#include<stdio.h>
#include <malloc.h>

typedef struct linknode
{
int data;
linknode *next;
} Node,*Linklist;//Linklist表示结构体指针

Linklist CreateList_end(int n);//尾插法创建链表
void ShowList(Linklist L);//输出链表内容
int Linklength(Linklist L);//求单链表长度

int main(void)
{
Linklist L1;
int n;
scanf("%d",&n);
L1=CreateList_end(n);
ShowList(L1);
printf("%d\n",Linklength(L1));
return 0;
}

Linklist CreateList_end(int n)
{
Linklist head=(Linklist)malloc(sizeof(Node));
Node *p,*e;
p=head;
int x;
for(int i=0; i<n; i++)//尾插法创建链表
{
e=(Linklist)malloc(sizeof(Node));
scanf("%d",&x);
e->data=x;
p->next=e;
p=e;
}
p->next=NULL;//将链表的最后一个节点的指针域置空
head=head->next;//由于头结点为空，因此因此指向下一个节点这样才有数据域
return head;
}

void ShowList(Linklist L)//输出链表内容
{
while(L)
{
printf("%d ",L->data);
L=L->next;
}
printf("\n");
}

int Linklength(Linklist L)//求单链表长度
{
int k=0;
while(L!=NULL)
{
k++;
L=L->next;
}
return k;
}

迭代知识！！apache

（这套课程先别想着一次性消化，先学个大概，学个概念，学以至用，第二遍先把项目搞起来，这个过程当中能够来理解，第三遍总结的时候再提升，别按照顺序来，很累心，学一个谪仙太白醉涂鸦，天马行空，想到哪学到哪……）

（完了就是微服务，spring boot/cloud，redis缓存，消息中间件，Java基础，IMOOC，实验楼，w3c，51学院……）

（完了几个github项目来搞）

（完了把个人书看完，行业相关的电子书）

（完了再看四本书：计算机组成原理，数据结构，计算机网络，数据库）

（完了总结项目，看看视频分享）

（关于学习时候的笔记，记到这里很方便，可是要时常整理，和有道云整合）

（潜意识里多暗示本身，改变本身，作一个纯粹的人，配得上一个职业的终身的尽早入门的工程师）

（别想着休息了，累过几波以后，发现本身还能够继续，还能够继续好久……）

单例模式

/*
 *（很容易记住，就三个小细节：）
 *一、把类的构造函数私有化
 *二、本身建立一个类的对象到静态成员变量
 *三、对外提供一个公共的方法，返回类的对象
 */
private TokenProccessor(){}

private static final TokenProccessor instance = new TokenProccessor();

/**
 * 返回类的对象
 * @return
 */
public static TokenProccessor getInstance(){
    return instance;
}

Javeweb总体就是创建在一个容器的概念之上，核心的东西就是：域，容器……

注意一些看不见的东西和行为（域对象，filter，listener）

全部的这些框架，都是基于servlet的规范的，这些规范，决定了接口

核心的技术：注解的处理，Java动态代理，实现本身的SpringMVC框架，

部署集群-------用空间换取时间

redis空间有限------用时间换取空间

租个服务器-------完整的搭建各类项目，性能降低了，用时间换取空间

（第三课，安装redis）

很远古的时候，就据说JavaBean，可是定义是啥

（若是一个类，遵循了特定的写法，咱们叫它JavaBean，一般用于封装数据，能够经过反射技术实例化JavaBean对象）

  • 这个Java类必须具备一个无参的构造函数
  • 属性必须私有化。
  • 私有化的属性必须经过public类型的方法暴露给其它程序，而且方法的命名也必须遵照必定的命名规范

/WEB-INF/-------------------这个目录下的文件是受保护的，外界是无法直接访问的

注解Annotation是一个很🐂的东西，运用反射，是一个bug性质的东西，相似后门，作框架必需要用到这种东西

它不是对内存资源进行操做，而是对代码自己进行操做

（后面须要的话，再根据孤傲苍狼的demo进行操做）

最霸道的是那篇本身封装的框架啊！！眼里只装着解决问题的办法！

只为成功找方法，不为失败找接口！

Eclipse快捷键

new Date();

Ctrl+1

Date date = new Date();

面试：

服务器调优：

软：session钝化活化（Listener实现）

硬：集群，

拦截器是依赖Java反射机制来实现的。拦截器的实现，用到的是JDK实现的动态代理，咱们都知道，JDK实现的动态代理，须要依赖接口。拦截器

是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。拦截器不是在web.xml，好比struts在
struts.xml中配置。

分页查询后端代码抽取，各类不一样类型的分页查询能够复用代码

controller层

import org.apache.commons.lang3.StringUtils;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;

import cn.itcast.domain.Customer;
import cn.itcast.service.CustomerService;
import cn.itcast.utils.PageBean;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
    private Customer customer = new Customer();
    
    private CustomerService cs;

    private Integer currentPage;
    private Integer pageSize;
    public String list() throws Exception {
        //封装离线查询对象
        DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
        //判断并封装参数
        if(StringUtils.isNotBlank(customer.getCust_name())){
            dc.add(Restrictions.like("cust_name", "%"+customer.getCust_name()+"%"));
        }
        
        //1 调用Service查询分页数据(PageBean)
        PageBean pb = cs.getPageBean(dc,currentPage,pageSize);
        //2 将PageBean放入request域,转发到列表页面显示
        ActionContext.getContext().put("pageBean", pb);
        return "list";
    }

    @Override
    public Customer getModel() {
        return customer;
    }

    public void setCs(CustomerService cs) {
        this.cs = cs;
    }

    public Integer getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(Integer currentPage) {
        this.currentPage = currentPage;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }
}

 

domain层

import java.util.List;

public class PageBean {
    //当前页数
    private Integer currentPage;
    //总记录数
    private Integer totalCount;
    //每页显示条数
    private Integer pageSize;
    //总页数
    private Integer totalPage;
    //分页列表数据
    private List    list;
    public PageBean(Integer currentPage, Integer totalCount, Integer pageSize) {
        this.totalCount = totalCount;
        
        this.pageSize =  pageSize;
        
        this.currentPage = currentPage;
        
        if(this.currentPage == null){
            //如页面没有指定显示那一页.显示第一页.
            this.currentPage = 1;
        }
        
        if(this.pageSize == null){
            //若是每页显示条数没有指定,默认每页显示3条
            this.pageSize = 3;
        }
        
        //计算总页数
        this.totalPage = (this.totalCount+this.pageSize-1)/this.pageSize;
        
        //判断当前页数是否超出范围
        //不能小于1
        if(this.currentPage < 1){
            this.currentPage = 1;
        }
        //不能大于总页数
        if(this.currentPage > this.totalPage){
            this.currentPage = this.totalPage;
        }
        
    }
    //计算起始索引
    public int getStart(){
        return (this.currentPage-1)*this.pageSize;
    }
    
    public Integer getCurrentPage() {
        return currentPage;
    }
    public void setCurrentPage(Integer currentPage) {
        this.currentPage = currentPage;
    }
    public Integer getTotalCount() {
        return totalCount;
    }
    public void setTotalCount(Integer totalCount) {
        this.totalCount = totalCount;
    }
    public Integer getPageSize() {
        return pageSize;
    }
    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }
    public Integer getTotalPage() {
        return totalPage;
    }
    public void setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
    }
    public List getList() {
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
}

service层

import org.hibernate.criterion.DetachedCriteria;
import cn.itcast.utils.PageBean;

public interface CustomerService {
    //分页业务方法
    PageBean getPageBean(DetachedCriteria dc, Integer currentPage, Integer pageSize);
}
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;

import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import cn.itcast.service.CustomerService;
import cn.itcast.utils.PageBean;

public class CustomerServiceImpl implements CustomerService {
    private CustomerDao cd;
    @Override
    public PageBean getPageBean(DetachedCriteria dc, Integer currentPage, Integer pageSize) {
        //1 调用Dao查询总记录数
        Integer totalCount = cd.getTotalCount(dc);
        //2 建立PageBean对象
        PageBean pb = new PageBean(currentPage, totalCount, pageSize);
        //3 调用Dao查询分页列表数据
        List<Customer> list = cd.getPageList(dc,pb.getStart(),pb.getPageSize());
        //4 列表数据放入pageBean中.并返回
        pb.setList(list);
        return pb;
    }
    public void setCd(CustomerDao cd) {
        this.cd = cd;
    }
}

dao层

import cn.itcast.domain.Customer;

public interface CustomerDao extends BaseDao<Customer> {

}
import java.util.List;

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;

public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao {
    
}
import java.io.Serializable;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;

public interface BaseDao<T> {
    //增  想要传入T泛型， 接口名称上须要声明 传入int须要用Serilizable
    void save(T t);
    //删
    void delete(T t);
    //删
    void delete(Serializable id);
    //改
    void update(T t);
    //查 根据id查询
    T    getById(Serializable id);
    //查 符合条件的总记录数
    Integer    getTotalCount(DetachedCriteria dc);
    //查 查询分页列表数据
    List<T> getPageList(DetachedCriteria dc,Integer start,Integer pageSize);
}
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import cn.itcast.dao.BaseDao;

public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {

    private Class clazz;//用于接收运行期泛型类型
    
    public BaseDaoImpl() {
        //得到当前类型的带有泛型类型的父类
        ParameterizedType ptClass = (ParameterizedType) this.getClass().getGenericSuperclass();
        //得到运行期的泛型类型
        clazz = (Class) ptClass.getActualTypeArguments()[0];
    }

    @Override
    public void save(T t) {
        getHibernateTemplate().save(t);
    }

    @Override
    public void delete(T t) {
        getHibernateTemplate().delete(t);
    }

    @Override
    public void delete(Serializable id) {
        T t = this.getById(id);//先取,再删
        getHibernateTemplate().delete(t);
    }

    @Override
    public void update(T t) {
        getHibernateTemplate().update(t);
    }

    @Override
    public T getById(Serializable id) {
        return (T) getHibernateTemplate().get(clazz, id);
    }

    @Override
    public Integer getTotalCount(DetachedCriteria dc) {
        //设置查询的聚合函数,总记录数
        dc.setProjection(Projections.rowCount());
        List<Long> list = (List<Long>) getHibernateTemplate().findByCriteria(dc);
        //清空以前设置的聚合函数
        dc.setProjection(null);
        if(list!=null && list.size()>0){
            Long count = list.get(0);
            return count.intValue();
        }else{
            return null;
        }
    }

    @Override
    public List<T> getPageList(DetachedCriteria dc, Integer start, Integer pageSize) {
        List<T> list = (List<T>) getHibernateTemplate().findByCriteria(dc, start, pageSize);
        return list;
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程