葡京在线开户SQL格式化利器

行使这在线网页编辑真的是免惯,还是
windows live writer 好。

工具列表

  • SQL格式化 Python 包
    sqlparse,文档地址
  • 在线的 SQL
    格式化工具:http://sqlformat.org/,基于上述python包搭建,可以在线转化
  • sublime 插件
    • SqlBeautifier
    • Select
      Quoted,sublime快速选择引号内容,可以运用该插件先选中引号中文本,再用SqlBeautifier进行格式化,快速实现SQL格式化。

下列一个清单用于最近之面试:(
清单是网上down的 )

示例

  1. static,final,transient
    等重大字之意向
  2. foreach 实现原理
  3. synchronized 和 volatile关键字

  4. List,Map,Set
    及其各种实现类似,底层实现原理,实现类似的优缺点

  5. 设计模式(单例【懒汉,饿汉,静态代码块,线程安全无安全】,工厂,观察,包装)

  6. 多线程(Runable 和 Thread)

  7. 好家伙是线程池,
    以及线程池的独到之处
  8. sleep() 和 wait() 的区别
  9. IO(字节,字符,序列,内存,对象,打印。。。)

  10. 照机制与自省编制

  11. 解析 xml文件几栽方法的规律和风味 [
    Dom, SAX, PULL ]
  12. sql 和 nosql(mysql 和 redis)

  13. 数据结构和算法(栈,队列,链表,树,图,排序,搜索)

  14. JDK 源码

  15. JVM(GC
    算法,垃圾回收器,类加载器,双委派类型,Java
    内存模型,happens-before 原则)
  16. web 分布式 session 实现的法子(4种)

  17. SOA,RPC,dubbo

  18. 重新上加几只抢腐烂掉的触及:override 和
    overload,final 和 finally,

sqlparse

$ pip install sqlparse
$ python
>>> import sqlparse
>>> print(sqlparse.format("select * from (select a, b, sum(c) from foo where d = 1 and e in ('a', 'b') group by f) t1 join (select a, g from bar) t2 on t1.a = t2.a left outer join t3 on t1.a = t3.a", reindent=True, keyword_case='upper'))
SELECT *
FROM
  (SELECT a,
          b,
          sum(c)
   FROM foo
   WHERE d = 1
     AND e IN ('a',
               'b')
   GROUP BY f) t1
JOIN
  (SELECT a,
          g
   FROM bar) t2 ON t1.a = t2.a
LEFT OUTER JOIN t3 ON t1.a = t3.a

 

Sublime插件

安装SqlBeautifierSelect Quoted晚,即可使用cmd + '疾选中文本,再就此cmd + k, cmd + f开展格式化。

Sublime SqlBeautifier 演示

 

static 关键字的企图:

  1. 作用在类上(该类必须只能是其中类,访问中类的成员经常,可以直接内部类名点调用)

  2. 打算在方式及(可以通过类似名点调用,但是非克修饰构造方法,因为构造方法本身就是静态方法)

  3. 图在代码块及(类为加载时,代码块自动执行,并且只实行同一蹩脚,一般用来加载驱动或单例设计模式)
  4. 静态导包(使为导包内的静态成员好一直当咱们一直的接近吃直接采用,不需要带类名,比如
    Math 类的 PI 常量,但缺点很明确,可读性性降低)

final 关键字之作用:

  1. 图在相近上
    (该类变为最终类,不可知被接续)
  2. 用意在性质上
    (属性改为常量,常量的地址不容许受改动)
  3. 图在法上
    (方法成为最终方法,不克于子类重写)
  4. 用意在形参列表上(在方法类,值类型不同意给改,引用类型对象的性可以让涂改,但是引用类型对象不能够为改动)

对此
final 的第二沾,要切记这词话,使用  final
关键字修饰一个值类型变量时,值类型的价值不同意修改;修饰的是引用型变量时,是乘引用变量地址不能够更换,但是引用变量所对的目标被之始末要好变更的。**
概括到某些就算是常量的地方不能够更改。**】

transient 关键字的意:

  1.  

foreach 实现原理:

    foreach就是 java
中之加强for循环,语法: for(Type agr : Coll){ }

    其落实原理就是是应用了迭代器,所以会见比普通
for
循环会快速一点,但是也时有发生弊,就是只能遍历元素,不能够修改元素。

volatile 关键字图:

 

 

单链集合中的知识点:

单链集合的根接口是Collection,其下起些许只子接口
List 和 Set,前者会储存重复元素,后者不可知积存重复元素。

1. List 会师特点:

         元素的存取顺序是一律的,也足以储存重复元素

     List 集合实现类的选择标准 :
查询多便分选ArrayList, 增删多就分选LinkedList,
如果都多就是挑选ArrayList。

     List 集合实现类似中以的
contains()和remove()方法底层依赖的equals()方法,如果只要采取这些办法,存入的实体类设实现equals()方法,

     可以利用LinkedList
来模拟站和行,需要采取的是其addFast(),addLast() 等方式,

     三栽循环: 普通for ,迭代器,
增强for,

  • 通常 for
    循环能删除集合元素(记住要及时将循环变量减一)
  • 迭代器,能去除集合元素(只能使迭代器自身之
    remove 方法)
  • 提高 for
    循环,不克去集合元素,只能用来遍历集合(普通数组也得遍历,而且比通常for快)

style=”font-size: medium;”>之前写了的List集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>ArrayList
去除重复元素 style=”color: #ff0000;”>】

                                        
【List
实现非递归删除目录 style=”color: #ff0000;”>】

2. Set 集合的特性:

       元素的存取顺序不必然是均等的 (
Set集合在底层进行了排序,Hash算法去还并排序或者二叉树排序,不能够管排好后的依次的储存的次第一定非相同
),不可知储存重复元素

   Set 集合常用实现类似:
HashSet,TreeSet,LinkedHashSet

   HashSet
底层去还依赖之是hashCode()方法和equals()方法,为了削减调用equals()方法的频率,一定要重新写hashCode()方法,因为只有当要存储的要素的
hash 值出现同时才见面调用equals()方法开展判重。

  LinkedHashSet
能保证元素的存取一致,因为生链表结构,又坐有hash算法,就会去重。

  TreeSet的特点:

         
可以指定顺序,然后对象的仓储会随指定的各个进行排序。

  实现排序的星星点点种方法:

       1 . 元素实体类实现
Comparable 接口,并促成 compareTo() 方法,最好还要再写 equals()
方法,

       2 . 写一个 Comparator (
比较器接口 ) 的贯彻类似,并落实 compare() 方法,在创造 TreeSet
集合时,将比较器对象传递进入,( 也可不写实现类似,直接写单匿名内部类
)。然后 TreeSet 集合对象调用
add() 方法时虽会自动进行比(第一种办法吧,会自行将实体类对象提升为
Comparable 类型调用重写后底 compareTo方法 ,

     
第二栽艺术的说话就是会见调用比较器类的compare方法)compareTo方法及compare()是坏像样的,不同之尽管是前者有让添加的素调用,参数就生一个,后者来一定量独参数,第一个参数是要抬高的要素,第二只参数是早已长的素,(当然,这点儿种植都见面去遍历集合,直到于此元素找到一个相当的职位,最特别之情事便是一旦遍历整个集合才找到)

style=”font-size: medium;”>前面写过之Set集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>HashSet
存储于定义对象如何保管元素唯一性 style=”color: #ff0000;”> style=”font-size: large;”>】

style=”font-size: large;”>                                  
【 style=”font-size: large;”>TreeSet
如何管元素的唯一性 style=”color: #ff0000;”> style=”font-size: large;”>】

style=”font-size: large;”>                                  
【 style=”font-size: large;”>LinkedHashSet
的概述和以 style=”color: #ff0000;”> style=”font-size: large;”>】

双链集合中之知识点:

双链集合的到底接口是 Map ,Map中存储的是
key-value 对,其中key是绝无仅有的,和 Set 集合一样,只是Map的唯一性针对被
key 。
  1.HashMap 和 Hashtable 的区别:

      仔细看即简单单称呼,会意识
Hashtable 不太符合驼峰式命名,那是以他是比较的镇的本,Hashtable 出自
JDK1.0 版本,是线程安全的(导致效率低),HashMap 是 JDK1.2
版本出现的,是线程不安全之(所以效率高),这样一来 HashMap 就替了
Hashtable了。(这点得同 StringBuffer 一样,然后出去了 StringBuild
替代了StirngBuffer )。

还有重要之某些,就是 HashMap 允许 key 为
null键和null值,Hashtable 是匪同意。

style=”font-size: medium;”>之前写的 Map 集合的博客: style=”color: #ff0000;”>【 style=”color: #ff0000;”>Map
集合概述及其特色 style=”color: #ff0000;”> style=”font-size: large;”>】

解析xml文件之老三种方法: [ DOM, SAX,
PULL]

DOM: style=”color: #ff0000;”>消耗内存:先管
xml文档都念到外存中,然后再用 DOM API
来访问树形结构,并获取数据。这个写起非常简短,但是生耗费内存。
SAX: style=”color: #ff0000;”>解析效率高,占用内存少,基于事件驱动的:更加简约地说不怕是针对性文档进行逐项扫描,当扫描到文档
(document)开始跟收、元素 (element) 开始同结束、文档 (document)
结束等地方经常通报事件处理函数,由事件处理函数做相应动作,然后继续同的扫视,直至文档结束。
PULL:与 SAX 类似,也是基于事件驱动,我们好调用它的 next()
方法,来得到下一个分析事件(就是开始文档,结束文档,开始标签,结束标签),当远在某个元素时得调用
XmlPullParser的getAttributte() 方法来抱属性之值,也只是调用它的
nextText() 获取本节点的价值。

嘿是线程池,
以及线程池的优点
:

style=”font-size: large;”>线程池的骨干考虑是相同种植对象池的构思,开辟一片内存空间,里面存放了重重
(未合眼)
的线程,池中线程执行调度由池管理器来拍卖。当有线程任务时,从池子中拿走一个,执行就后线程对象归池,这样好免频繁创建线程对象所带动的性能开销,节省了网的资源。就哼于原先去餐饮店打饭是每个人看谁抢的大胜,谁先抢到谁先吃,有矣线程吃下,就是去掉好队形,今天自己与你干好,你先来用。比如:一个使要跟网社交,有无数手续需要看网络,为了不打断主线程,每个步骤都创个线程,在线程中与网络互动,用线程池就变的简短,线程池是本着线程的一模一样种包装,让线程用起更便利,只需要创造一个线程池,把这些手续像任务同样放进线程池,在程序销毁时要调用线程池的灭绝函数即可。

单个线程的弊端:

  • 历次new
    Thread新建对象性能差
  • style=”font-size: large;”>线程缺乏统一保管,可能随便界定新建线程,相互之间竞争,及可能占了多系统资源导致死机或者OOM
  • style=”font-size: large;”>缺乏更多职能,如定时执行、定期执行、线程中断

线程池的便宜 :

  • style=”font-size: large;”>重用存在的线程,减少对象创建、消亡的开销,性能好。
  • style=”font-size: large;”>可有效控制最深并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
  • style=”font-size: large;”>提供定时执行、定期执行、单线程、并发数控制等功效。

sleep() 和 wait() 的区别:

sleep() 来自 Thread 类,wait() 来自
Object 类
调用 sleep() 方法的过程中,线程不见面释放对象锁。而调用 wait()
方法线程会释放对象锁
sleep() 睡眠后未起被系统资源,wait() 让出系统资源其他线程可以占
CPU
sleep(milliseconds) 需要指定一个上床时,时间一模一样到会自行唤醒.

下面是故 windows live writer
写的,是当凡较网页的好多矣。。。。

面向对象的老三好特点与五老骨干尺度:

其三生特征:

  • 封装
  • 继承
  • 多态

五生中心规则:

  • 单纯任务规范
  • 放封闭原则
  • 轮换原则
  • 指原则
  • 接口分离原则

详细:

style=”font-size: large; color: #ff0000;”>封装:所谓包,也尽管是把客观事物封装成抽象的好像,并且类可管自己的数目及方法才为可信之近乎还是目标操作,对不可信的开展信息隐藏。封装是面向对象的特征之一,是目标和相近概念的严重性特点。
简单的说,一个像样即是一个封装了数量和操作这些多少的代码的逻辑实体。在一个靶中,某些代码或少数数据可是私有的,不克叫外面看。通过这种措施,对象对内部数据提供了不同级别之护,以戒程序中无关的片意外的转移或者错误的运用了目标的私有部分。

继承: style=”font-size: medium;”>所谓继承是靠好让有项目的靶子获得任何一个类型的对象的性能的主意。它支持按级分类的定义。继承是指这样同样种力量:它好应用现有类的备机能,并当无需再次编辑原来的类似的情事下本着这些成效拓展扩展。
通过持续创建的新类称为“子类”或“派生类”,被延续的类称为“基类”、“父类”或“超类”。继承的长河,就是打一般到特种的进程。要兑现持续,可以经过“继承”(Inheritance)和“组合”(Composition)来落实。继承概念的贯彻方式来二类:实现连续和接口继承。实现持续是依赖直接动用基类的特性和道而无论是需额外编码的能力;接口继承是依靠仅以性能与方式的名称、但是子类必须提供实现之力量;

多态: style=”font-size: medium;”>所谓多态就是负一个看似实例的同等方法在不同景象有异表现形式。多态机制使所有不同内部结构的靶子好共享相同之标接口。这意味着,虽然针对不同对象的具体操作不同,但经过一个共用的好像,它们(那些操作)可以经同样之不二法门给调用。

style=”font-size: large; color: #ff0000;”>多态三不行因素:

  • 继承
  • 法重写
  • style=”font-size: medium; color: #000000;”>父类引用指向子类对象

    style=”font-size: large; color: #ff0000;”>纯净任务规范: style=”font-size: medium; color: #000000;”>指一个类的效果要单纯,不能够完善。如同一个丁平等,分配的干活未可知无限多,否则一天到晚虽然忙忙碌碌的,但效率也大不起。

    style=”font-size: large; color: #ff0000;”>放封闭原则:一个模块于扩展性方面应该是开之假设以更改性方面应当是封的。比如:一个大网模块,原来只有服务端功能,而如今一经加入客户端功能,那么相应以毫无修改服务端功能代码的前提下,就能多客户端功能的贯彻代码,这要求以设计之初,就活该以服务端和客户端分开,公共部分虚幻出来。

    style=”font-size: large; color: #ff0000;”>轮换原则:子类应当可以替换父类并出现于父类能够出现的外地方。比如:公司来年度晚会,所有员工可参加抽奖,那么不论是一味职工或新员工,也不管是总部员工还是派出员工,都应可以参加抽奖,否则就店就不调和了。

style=”font-size: large; color: #ff0000;”>依赖原则:切切实实指抽象,上层依赖下层。假设B是比A低之模块,但B需要用到A的效用,这个时刻,B不应直接使用A中之实际类:
而当由B定义一空洞接口,并出于A来实现这个抽象接口,B只使用此抽象接口:这样就是达成了指倒置的目的,B也败了对A的靠,反过来是A依赖让B定义的抽象接口。通过上层模块难以避免依赖下层模块,假如B也直接依赖A的实现,那么即使可能引致循环依赖。

style=”font-size: large; color: #ff0000;”>接口分离原则:模块间如果透过架空接口隔离开,而休是通过具体的类强耦合起来。

设计模式:

单例设计模式:

大面积的单例模式主要发生懒汉和饿汉有数种植,懒汉分线程安全和非安全,代码上来先:

1 . 懒汉式(线程不安全),我现在喜把它喊懒加载

package com.msym.sort;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  懒汉式(线程不安全)
 */
public class Singleton {

    private static Singleton instance = null;

    //私有化构造函数,这是单例模式必须的。
    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

2 . 懒汉式(线程安全)

package com.msym.singleton;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  懒汉式(线程安全)
 */

public class Singleton {

    private static Singleton instance = null;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

3 . 饿汉式(静态成员变量)

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  饿汉式(静态成员变量)
 */
public class Singleton {
    
    private static Singleton instance = new Singleton();
    
    private Singleton(){}

public static Singleton getInstance(){
return instance;
}
}

 

4 . 饿汉式(采用静态代码块)

package com.msym.singleton;

/**
 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  饿汉式(静态代码块)
 */
public class Singleton {

    private static Singleton instance = null;

    static{
        instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

5 . 采用静态内部类

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  静态内部类的形式
 */
public class Singleton {
    /**
     * 静态内部类,用于创建单例对象
     * @author 码上猿梦
     *  http://www.cnblogs.com/daimajun/
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    private Singleton(){}
    
    /**
     * 类名.内部类成员变量
     * @return
     */
    public static final Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

 

6 . 再度校验锁

package com.msym.singleton;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 *  双重校验锁
 */
public class Singleton {
    /*
     * 使用volatile修饰
     */
    private volatile static Singleton instance = null;
    
    private Singleton(){ }
    
    /**
     * 两次判断对象是否为空
     * @return
     */
    private static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class) {
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

厂子模式:

大体分三像样:

  • 简单易行工厂模式
  • 工厂方法模式
  • 架空工厂模式

    style=”font-size: large;”>前两者可以分开也同,就是厂方法模式。

这就是说工厂方法模式与浮泛工厂
模式的对立统一:

厂子方法模式:
      style=”color: #ff0000;”>一个架空产品类,可以派生出多独具体产品类。  
      style=”color: #000000;”>一个虚幻工厂类,可以派生出多独具体工厂类。  
      每个具体工厂类只能创造一个实际产品类似的实例。
虚幻工厂模式:
      style=”color: #ff0000;”>多个抽象产品类,每个抽象产品类可以派生出多独具体产品类。  
      一个华而不实工厂类,可以派生出多只具体工厂类。  
      每个具体工厂类可创造多个实际产品类似的实例。  
区别:
     工厂方法模式只生一个抽象产品类,而空虚工厂模式起差不多个。  
    
工厂方法模式之求实工厂类只能创造一个有血有肉产品类似的实例,而肤浅工厂模式可以创建多单。

 

【下面排序默认都也升序】

排序代码:选择,插入,气泡

摘排序的思绪:(n 也使排序的数字只数,都设升序排列)

      style=”font-size: medium;”> style=”font-size: large;”>将要排序的靶子分为两单部分,一个凡是前者已排序(假定也升序),一个后端未排序的,每次打后端选择一个最好小值,并放入前端序列的最后,这样极其多循环(n

  • 1)次后虽排序完成了。【 style=”color: #ff0000;”>最初步经常,前端部分没有元素,后端元素也全体】

    style=”font-size: large;”>如图:

        
葡京在线开户 1

插入排序的思绪:

     style=”font-size: large;”>像玩扑克牌一样,可以用牌分为两积聚,每次打晚一致堆放着挤出第一摆放,插入到眼前同堆积着之妥位置,这样最好多循环(n

  • 1)次就是好了排序。【 style=”color: #ff0000;”>最开始时,前同一堆只生一个元素,后一致积是多余的素】

如图:

     
葡京在线开户 2

气泡排序的思路:

     style=”font-size: large;”>顾名思义,最特别之元素会如气泡一样移至右端,利用比较相邻元素的计,将比充分的因素交换至右端,所以颇之要素会持续的通向右边走,直到移动及当的职务(就是右端元素于它可怜的职位)为止。【 style=”color: #ff0000;”>当 i 和 i + 1
无发出过元素交换位置,就标志排序已到位】

style=”font-size: large;”>如下图:

       
葡京在线开户 3

选排序,插入排序,冒泡排序:

package com.msym.sort;
  
/**
 * 排序算法:
 *      选择,插入,气泡
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class BasicSort {
    public static void selectionSort(int[] number) {
        for (int i = 0; i < number.length - 1; i++) {
            int minIndex = i;//假设第 i 个元素最小, 最开始是假设第一个元素最小
            for (int j = i + 1; j < number.length; j++) {
                if (number[j] < number[minIndex])
                    minIndex = j;//每次循环找到后端最小值的角标
            }
            if (i != minIndex) //如果i == minIndex,说明最小值的角标就是 i,不需要交换, 这里的 i 指的是位置.
                swap(number, i, minIndex);
        }
    }
    //插入排序  
    public static void injectionSort(int[] number) {
        for (int j = 1; j < number.length; j++) {
            int tmp = number[j]; //每次抽取后一堆的第一个元素
            int i = j - 1; //前一堆元素的最后一个,用于下面遍历的起点
            while (tmp < number[i]) { //最先和前一堆最后一个元素进行比较,然后依次往前进行比较
                number[i + 1] = number[i];
                i--;
                if (i == -1)
                    break;
            }
            number[i + 1] = tmp; //将 tmp 放在 i 的位置上
        }
    }
    //冒泡排序
    public static void bubbleSort(int[] number) {
        boolean flag = true;
        for (int i = 0; i < number.length - 1 && flag; i++) {
            flag = false; //每次将标志位重置为 false
            for (int j = 0; j < number.length - i - 1; j++) {
                if (number[j + 1] < number[j]) {
                    swap(number, j + 1, j);
                    flag = true; //交换过元素就将标志位改为 true
                }
            }
        }
    }
  
    private static void swap(int[] number, int i, int j) {
        int t;
        t = number[i];
        number[i] = number[j];
        number[j] = t;
    }
}

Shaker 排序法,改良后的气泡排序:

     排序思路:

          
方法就是在于气泡排序的双向进行,先叫气泡排序由左向右进行,再来被气泡排序由右为左进行,如此到位同样糟糕排序的动作,而你必须以left与right两单旗标来记录左右星星端都排序的要素位置。

如下图:

       
葡京在线开户 4

代码如下:

package com.msym.sort;

/**

 * 改良的气泡排序
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class ShakerSort {
    public static void sort(int[] number) {
        int i, left = 0, right = number.length - 1, shift = 0; //
        while (left < right) { 
            // 向右进行气泡排序,一次循环,最大值到达最右端
            for (i = left; i < right; i++) {
                if (number[i] > number[i + 1]) {
                    swap(number, i, i + 1);
                    shift = i;
                }
            }
            right = shift; 
            // 向左进行气泡排序,一次循环,最小值到达最左端
            for (i = right; i > left; i--) {
                if (number[i] < number[i - 1]) {
                    swap(number, i, i - 1);
                    shift = i;
                }
            }
            left = shift;
        }
    }

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

Shell 排序法 ,改良后底插入排序:

代码如下:

package com.msym.sort;

/**

 * 改良的插入排序
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class ShellSort {
    public static void sort(int[] number) {
        int gap = number.length / 2;
        while (gap > 0) {
            for (int k = 0; k < gap; k++) {
                for (int i = k + gap; i < number.length; i += gap) {
                    for (int j = i - gap; j >= k; j -= gap) {
                        if (number[j] > number[j + gap]) {
                            swap(number, j, j + gap);
                        } else
                            break;
                    }
                }
            }
            gap /= 2;
        }
    }

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

迅速清除序 -01:

package com.msym.sort;

/**

 * 快速排序法(一)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int s = number[left]; int i = left; int j = right + 1; while (true) { // 向右找 while (i + 1 < number.length && number[++i] < s); // 向左找 while (j - 1 > -1 && number[–j] > s);
if (i >= j)
break;
swap(number, i, j);
}
number[left] = number[j];
number[j] = s;
sort(number, left, j – 1);
// 对左边进行递回
sort(number, j + 1, right);
// 对右边进行递回
}
}

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}

}

速清除序 -02:

package com.msym.sort;

/**

 * 快速排序法(二)
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int s = number[(left + right) / 2]; int i = left - 1; int j = right + 1; while (true) { // 向右找 while (number[++i] < s); // 向左找 while (number[--j] > s);
if (i >= j)
break;
swap(number, i, j);
}
sort(number, left, i – 1); // 对左边进行递回
sort(number, j + 1, right); // 对右边进行递回
}
}

private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

快排除序 -03:

package com.msym.sort;

/**

 * 快速排序法(三)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class QuickSort {
    public static void sort(int[] number) {
        sort(number, 0, number.length - 1);
    }

private static void sort(int[] number, int left, int right) {
if (left < right) { int q = partition(number, left, right); sort(number, left, q - 1); sort(number, q + 1, right); } }
private static int partition(int number[], int left, int right) {
int s = number[right];
int i = left – 1;
for (int j = left; j < right; j++) { if (number[j] <= s) { i++; swap(number, i, j); } } swap(number, i + 1, right); return i + 1; }
private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
}

统一排序法:

package com.msym.sort;

/**

 * 合并排序法
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class MergeSort {
    public static int[] sort(int[] number1, int[] number2) {
        int[] number3 = new int[number1.length + number2.length];
        int i = 0, j = 0, k = 0;
        while (i < number1.length && j < number2.length) {
            if (number1[i] <= number2[j])
                number3[k++] = number1[i++];
            else
                number3[k++] = number2[j++];
        }
        while (i < number1.length)
            number3[k++] = number1[i++];
        while (j < number2.length)
            number3[k++] = number2[j++];
        return number3;
    }
}

次私分搜寻法:

package com.msym.search;

/**

 * 二分搜寻法(搜寻原则的代表)
 * 
 * @author 码上猿梦 http://www.cnblogs.com/daimajun/
 */
public class BinarySearch {
    public static int search(int[] number, int des) {
        int low = 0; //左
        int upper = number.length - 1; //右
        while (low <= upper) { //只要左边小于等于右边就进循环
            int mid = (low + upper) / 2; //取中间元素的角标(自动取整),然后进行比较
            if (number[mid] < des)
                low = mid + 1;
            else if (number[mid] > des)
                upper = mid - 1;
            else
                return mid;
        }
        return -1; //找不到就返回 -1
    }

public static void main(String[] args) {
int[] number = { 1, 4, 2, 6, 7, 3, 9, 8 };
QuickSort.sort(number); //先排序
int find = BinarySearch.search(number, 3); //找到值为 3 的要素
if (find != -1)
System.out.println(“找到数值为索引” + find);
else
System.out.println(“找不顶数值”);
}
}

 

jdbc 基础:

package com.msym.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**

 * 
 * @author 码上猿梦
 *  http://www.cnblogs.com/daimajun/
 */
public class temp{
    public static void main(String[] agrs) throws Exception{
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql:127.0.0.1:3306/Demo_db";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);
        String sql = "select * from msym_user where name = ? ";
        PreparedStatement st = conn.prepareStatement(sql);
        st.setString(1,"码上猿梦");
        ResultSet rs = st.executeQuery(sql);
        while(rs.next()){
            int id = rs.getInt("id");
            String nickName = rs.getString("nickName");
            System.out.print("id : " + id + "; " + "nick :" + nickName);
        }
    }
}

放资源的代码:

        // 4.释放资源.
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            rs = null; // 为了让JVM垃圾回收更早回收该对象.
        }

if (st != null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
st = null;
}

if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null;
}

会说话技术: 【session 和 cookie】

cookie
的几点:

  • cookie 用于携带的数据量最老吗 4KB

  • 一个服务器最多为一个浏览器保存20个 cookie

  • 一个浏览器最多保留300单 cookie

 

本人莫明白到之转化和重定向:

style=”font-size: large;”>转发与重定向会清空上一个
response中缓存的数额,所以转发或重定向前的具有的
response都是不行的,只有靶资源的
response的输出才是行得通之【也不怕是终极一个应的多寡才见面受客户端接收,其他的响应数据都吃破了】

 

 

 

补充:

今日张同样截代码,如下:

package com.msym.jyaml;

public class Demo {

public static void main(String[] args) {
Integer a = 1;
Integer b = 1;
Integer b2 = new Integer(1);

Integer c = 127;
Integer d = 127;

Integer e = 128;
Integer f = 128;
System.out.println(a==b);//true

        System.out.println(b==b2);//false
        System.out.println(c==d);//true
        System.out.println(e==f);//false
    }
}

这边提到到了机动装箱拆箱和 Integer
的一个里面类 IntegerCache。

     结果为什么会起如此的,那是为
JVM 内部发生一个优化机制,当数值比较小(-128~127)时,会采取 Integer
类中的一个中间类
IntegerCache类的目标将那个储存起来,如果下次亟需还装箱一个一如既往大小的数字(-128~127里头),就径直得到前的价了,这些比粗之数值使用的是平片存储空间,当然,如果使用了
new 操作符,那么即便必将会开发一个新的内存空间用来存储数据。

框架基础:

Spring:

IoC:从 Spring
角度来讲,之前的应用程序去 new 对象的权让 Spring
夺取了,称为控制反转。

DI: 从应用程序的角度讲,自己不再需要
new 对象了,只待提供依赖对象的 set
方法【使用注解后,只待而该改为成员变量即可,不欲 set
方法了】,等待 Spring 容器注入该目标,称为依赖注入。

SpringMVC: