Java提高逼格的套路和知識點

https://pintia.cn/

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

(刷題，C語言，gcc編譯器承認的一些語法規則) 

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

---

常見排序

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

複雜度

排序方法 時間複雜度（平均） 時間複雜度（最壞） 時間複雜度（最好） 空間複雜度 穩定性
冒泡排序 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) 穩定

---

//鏈表的創建，內容輸出，長度

#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;
}

---

迭代知識！！

（這套課程先別想着一次性消化，先學個大概，學個概念，學以至用，第二遍先把項目搞起來，這個過程當中能夠來理解，第三遍總結的時候再提升，別按照順序來，很累心，學一個謫仙太白醉塗鴉，天馬行空，想到哪學到哪……）

（完了就是微服務，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;
    }
}