Java 面试前的底子准备 – 01

应用那么些在线网页编辑真的是不习惯,依旧windows live writer 好。

2014-10-04 Created By
BaoXinjian

上边列二个清单用于近期的面试:(
清单是网上down的 )

图片 1一、摘要

  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,

 

目录重建是3个争辨被不断热烈议论的议题。当然Oracle官方也有投机的意见,大家很多DBA也是比照这一准则来重建索引,那就是Oracle建议对于索引深度超过4级以及已删除的目录条目至少占有现有索引条目总数的五分一这2种情形下必要重建索引。近期Oracle也建议了一部分与之相反的见识,正是强烈建议不要定期重建索引。本文是参照了1525787.1并实行相应描述。

 

 

static 关键字的遵循:

  1. 效果在类上(该类必须只能是内部类,访问内部类的分鸡时,能够间接内部类名点调用)

  2. 作用在章程上(能够通过类名点调用,但是无法修饰构造方法,因为构造方法本人正是静态方法)

  3. 效果在代码块上(类被加载时,代码块自动执行,并且只进行一回,一般用于加载驱动恐怕单例设计形式)
  4. 静态导包(使被导包内的静态成员能够平素在我们一贯的类中平素利用,不供给带类名,比如
    Math 类的 PI 常量,但缺点很明显,可读性性下落)
  1. 重建索引的理由

final 关键字的成效:

  1. 功效在类上
    (该类变为最后类,不可能被一而再)
  2. 效率在品质上
    (属性改为常量,常量的地址分裂意被涂改)
  3. 效益在艺术上
    (方法成为最终方法,无法被子类重写)
  4. 作用在形参列表上(在方法类,值类型不允许被修改,引用类型对象的质量能够被改动,不过引用类型对象不可能被改变)

对此
final 的第贰点,要铭记在心那句话,使用  final
关键字修饰1个值类型变量时,值类型的值差异意修改;修饰的是引用型变量时,是教导用变量地址不可能变,但是引用变量所指向的指标中的内容还是能更改的。**
归咎到一点正是常量的地点无法改。**】

  •  Oracle的B树索引随着岁月的推迟变得不平衡(误解)
  •  索引碎片在时时刻刻加码
  •  索引不断追加,删除的半空中没有重复使用
  •  索引 clustering factor
    (集群因子)分化台,可以由此重建修复(误解)

transient 关键字的作用:

  1.  
  1. 重建索引的本质

foreach 达成原理:

    foreach便是 java
中的抓牢for循环,语法: for(Type agr : Coll){ }

    其落到实处原理正是行使了迭代器,所以会比常见
for
循环会连忙一点,不过也有弊端,便是只可以遍历元素,不能够修改成分。

   
本质:重建索引在数据库内部是先进行删除操作,再实施插入操作。

volatile 关键字作用:

 

 

  1. 反对重建索引的理由

单链集合中的知识点:

单链集合的根接口是Collection,其下有多少个子接口
List 和 Set,前者能积存重复成分,后者无法储存重复元素。

(1). 大部分脚本都凭借 index_stats
动态表。此表使用以下命令填充:

1. List 会面特点:

         成分的存取顺序是一致的,也能够储存重复成分

     List 集合完毕类的抉择规范 :
查询多就选拔ArrayList, 增加和删除多就选用LinkedList,
假使都多就分选ArrayList。

     List 集合达成类中动用的
contains()和remove()方法底层依赖的equals()方法,如若要动用那些格局,存入的实体类要贯彻equals()方法,

     能够运用LinkedList
来模拟站和队列,须要运用的是其add法斯特(),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;”>】

analyze index … validate
structure;

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() 方法时就会自行进行比较(第1种艺术的话,会活动将实体类对象提高为
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;”>】

尽管那是一种有效的目录检查办法,可是它在条分缕析索引时会获取独占表锁。对于大型索引,其震慑会是宏伟的,因为在此时期不允许对表执行DML
操作。

双链集合中的知识点:

双链集合的根接口是 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;”>线程池的中央思维是一种对象池的沉思,开辟一块内部存款和储蓄器空间,里面存放了不少
(未过逝)
的线程,池中线程执行调度由池管理器来处理。当有线程职分时,从池中取三个,执行到位后线程对象归池,那样能够幸免频仍创造线程对象所推动的性质费用,节省了系统的能源。就好比原先去旅社打饭是各类人看何人抢的赢,什么人先抢到什么人先吃,有了线程吃过后,便是排好队形,今日自作者跟你涉嫌好,你先来吃饭。比如:2个利用要和网络社交,有诸多步骤须要拜访互连网,为了不打断主线程,每种步骤都创建个线程,在线程中和互联网互动,用线程池就变的大致,线程池是对线程的一种包装,让线程用起来更为便利,只必要创七个线程池,把那个手续像职责一样放进线程池,在先后销毁时一旦调用线程池的绝迹函数即可。

单个线程的弊端:

  • 历次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;”>封装:所谓封装,约等于把客观事物封装成抽象的类,并且类能够把温馨的数据和章程只让可相信的类依然目的操作,对不可信的开始展览新闻隐藏。封装是面向对象的特点之一,是目的和类概念的重点特色。
一言以蔽之,二个类便是3个包裹了数量以及操作那个多少的代码的逻辑实体。在三个对象内部,某个代码或有个别数据足以是个体的,无法被外面访问。通过这种情势,对象对在这之中数据提供了分歧级别的维护,以预防程序中非亲非故的有的意外的更动或错误的选取了目的的村办部分。

继承: style=”font-size: medium;”>所谓继承是指可以让有个别项指标靶子获得另3个类别的靶子的习性的方法。它帮助按级分类的定义。继承是指那样一种力量:它能够选用现有类的拥有成效,并在无需再度编写原来的类的意况下对那几个作用举行扩展。
通过一连制造的新类称为“子类”或“派生类”,被持续的类称为“基类”、“父类”或“超类”。继承的历程,正是从一般到卓殊的长河。要完结一连,能够透过“继承”(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;”>接口分离原则:模块间要因此架空切口隔开开,而不是由此实际的类强耦合起来。

(2). 重建索引的直白结果是 REDO
活动或然会增多,总种类统负荷也大概会增进。

设计格局:

安排/更新/删除操作会招致索引随着索引的剪切和增强不断升高。

单例设计格局:

常见的单例形式主要有懒汉和饿汉三种,懒汉分线程安全和不安全,代码上来先:

重建索引后,它将连接的更为紧密;然则,随着对表不断推行
DML 操作,必须再一次分割索引,直到索引达到平衡甘休。

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

结果,重做活动扩充,且索引分割更有恐怕对品质产生直接影响,因为大家供给将更加多的
I/O、CPU 等用于索引重建。

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;
    }
}
  1. Oracle的最后提出

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

 

    一般而言,极少要求重建 B
树索引,基本原因是 B 树索引十分的大程度上能够自小编管理或自身平衡。

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;”>3个架空工厂类,能够派生出三个具体育工作厂类。  
      种种具体育工作厂类只可以制造三个切实产品类的实例。
虚幻工厂格局:
      style=”color: #ff0000;”>多个空洞产品类,每种抽象产品类能够派生出五个具体产品类。  
      2个空洞工厂类,能够派生出多少个具体育工作厂类。  
      每种具体育工作厂类能够创制七个具体产品类的实例。  
区别:
     工厂方法格局唯有2个空洞产品类,而肤浅工厂情势有八个。  
    
工厂方法格局的现实性工厂类只好成立叁个具体产品类的实例,而空虚工厂情势能够创制几个。

 

   
插入/更新和删除操作确实会促成索引块周围的可用空间形成碎片,不过一般的话那些碎片都会被正确的选定。

【下边排序私下认可都为升序】

    Clustering
factor群集因子反映了给定的索引键值所对应的表中的多少排序意况。重建索引不会对群集因子发生影响,集群因子只好通过重组表的数据变动。

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

挑选排序的思路:(n 为要排序的数字个数,都如若升序排列)

      style=”font-size: medium;”> style=”font-size: large;”>将要排序的指标分为八个部分,一个是前者已排序(假定为升序),一个后端未排序的,每一遍从后端选择八个细小值,并放入前端种类的最后,那样最多循环(n

  • 1)次后就排序实现了。【 style=”color: #ff0000;”>最起始时,前端部分没有成分,后端成分为整个】

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

        
图片 2

插入排序的思绪:

     style=”font-size: large;”>像玩扑克一样,可以将牌分为两堆,每一趟从后一堆中挤出第壹张,插入到前一堆中的稳妥地点,那样最多循环(n

  • 1)次就做到了排序。【 style=”color: #ff0000;”>最初阶时,前一堆唯有3个要素,后一堆是多余的要素】

如图:

     
图片 3

气泡排序的思路:

     style=”font-size: large;”>顾名思义,最大的因素会像气泡一样移至右端,利用比较相邻元素的法子,将较大的成分交流至右端,所以大的因素会不断的往右移动,直到移动到相当的地方(正是右端成分比它大的岗位)甘休。【 style=”color: #ff0000;”>当 i 和 i + 1
未曾生出过成分交流地点,就标明排序已成功】

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

       
图片 4

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

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三个旗标来记录左右两端已排序的成分地点。

如下图:

       
图片 5

代码如下:

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

  1. 改革方法

马上排序 -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;
}

}

    常常是事先考虑index
coalesce(索引合并),而不是重建索引。索引合并有如下优点:

高速排序 -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;
}
}

  •  不必要占用近磁盘存款和储蓄空间 2
    倍的上空
  •  能够在线操作
  •  无需重建索引结构,而是火速地集合索引叶块,那样可防止系统开发过大。

敏捷排序 -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;
}
}

  1. 诚然需求重建索引的景观

联合排序法:

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;
    }
}
  •  索引或索引分区因介质故障损坏
  •  标记为UNUSABEL的目录供给重建
  •  索引移动到新的表空间或供给转移一些存款和储蓄参数
  •  通过SQL*Loader加载数据到表分区后,供给重建索引分区
  •  重建索引以启用键压缩
  •  位图索引本质不一样于B树引得,提出重建

二分搜寻法:

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

  • 一个服务器最多向贰个浏览器保存1几个 cookie

  • 多少个浏览器最多保留300个 cookie

 

笔者不明了到的中间转播和重定向:

style=”font-size: large;”>转载和重定向会清空上3个response中缓存的多寡,所以转载或重定向前的有所的
response都以对事情没有什么益处的,唯有目标能源的
response的出口才是可行的【也正是最后3个响应的数目才会被客户端接收,别的的响应数据都被免去了】

 

 

 

补充:

前日看来一段代码,如下:

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
类中的1个里边类
IntegerCache类的靶子将其储存起来,要是下次必要再一次装箱八个平等大小的数字(-128~127之内),就间接取从前的值了,那几个相比小的数值使用的是如出一辙块存储空间,当然,假诺接纳了
new 操作符,那么就必然会开发3个新的内部存款和储蓄器空间用来储存数据。

 

框架基础:

图片 6二、案例

Spring:

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

DI: 从应用程序的角度讲,本身不再须要new 对象了,只要求提供信赖对象的 set
方法【使用表明后,只必要使其成为成员变量即可,不需求 set
方法了】,等待 Spring 容器注入该目的,称为注重注入。


SpringMVC:

目录是增强数据库查询品质的强大武器。

从未索引,就好比教室没有图书标签一样,找一本书自个儿想要的书比登天还难。

可是索引在选择的进度中,特别是在批量的DML的状态下会发出相应的零碎,以及B树高度会生出相应变更,由此能够对这么些变化较大的目录实行重构以增强质量。

N久从前Oracle提出我们定期重建那个中度为4,已删除的目录条目至少占有现有索引条目总数的1/5的那一个表上的目录。

但Oracle今后强烈建议不要定期重建索引。

 

Thanks and Regards

参考:了沙弥
http://blog.csdn.net/leshami/article/details/23763963

参考:了沙弥
http://blog.csdn.net/leshami/article/details/24266247

图片 7