再也不会有那么的闺女了

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

七月13日,树做了贰个很意外的梦。

上边列三个清单用于近期的面试:(
清单是网上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,

不过树总是看不清她的脸。

 

不知情是看不清那张脸,仍旧醒来突然就记不起了。

 

梦中她是那样的耳熟能详,好像是轶事的结局。可为何小编努力去看清她的脸,去记住他的面容,却愈发嫌疑。

static 关键字的效果:

  1. 功用在类上(该类必须只好是个中类,访问内部类的积极分龙时,能够一向内部类名点调用)

  2. 成效在章程上(能够透过类名点调用,不过不可能修饰构造方法,因为构造方法本人就是静态方法)

  3. 效果在代码块上(类被加载时,代码块自动执行,并且只进行二遍,1般用于加载驱动恐怕单例设计格局)
  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,前者能积存重复成分,后者无法储存重复成分。

实则梦境改变不了什么,树知道。

壹. List 凑合特点:

         成分的存取顺序是同等的,也得以储存重复成分

     List 集合达成类的选拔条件 :
查询多就选取ArrayList, 增加和删除多就分选LinkedList,
如若都多就分选ArrayList。

     List 集合完毕类中选择的
contains()和remove()方法底层依赖的equals()方法,要是要选择这几个办法,存入的实体类要实现equals()方法,

     能够行使LinkedList
来模拟站和队列,供给动用的是其add法斯特(),addLast() 等方法,

     二种循环: 普通for ,迭代器,
增强for,

  • 1般 for
    循环能删除集合成分(记住要立即将循环变量减一)
  • 迭代器,能去除集合成分(只好采用迭代器自己的
    remove 方法)
  • 升高 for
    循环,无法去除集合成分,只好用来遍历集合(普通数组也能够遍历,而且比常见for快)

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

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

但这出乎意料的梦,就像是出乎意外的痴情,令她稍微慌乱。

二. Set 集合的性状:

       元素的存取顺序不必然是同等的 (
Set集合在底层实行了排序,Hash算法去重并排序或许二叉树排序,无法担保排好后的依次的蕴藏的次第一定分化),不能够积存重复成分

   Set 集合常用落成类:
HashSet,TreeSet,LinkedHashSet

   HashSet
底层去重看重的是hashCode()方法和equals()方法,为了收缩调用equals()方法的效用,一定要重写hashCode()方法,因为惟有当要存款和储蓄的成分的
hash 值出现雷同时才会调用equals()方法开始展览判重。

  LinkedHashSet
能保障成分的存取1致,因为有链表结构,又因为有hash算法,就能去重。

  TreeSet的特点:

         
能够钦定顺序,然后对象的蕴藏会遵从钦点的各种进行排序。

  达成排序的三种办法:

       一 . 因素实体类实现Comparable 接口,并达成 compareTo() 方法,最佳还要重写 equals()
方法,

       二 . 写2个 Comparator (
相比器接口 ) 的兑现类,并贯彻 compare() 方法,在创设 TreeSet
集合时,将相比较器对象传递进入,( 也足以不写实现类,直接写个匿名内部类
)。然后 TreeSet 集合对象调用
add() 方法时就会活动进行相比(第一种艺术的话,会自行将实体类对象提高为
Comparable 类型调用重写后的 compareTo方法 ,

     
第二种情势的话就会调用相比较器类的compare方法)compareTo方法和compare()是老大接近的,分歧的正是前者有被加上的成分调用,参数只有二个,后者有三个参数,第多少个参数是要添加的因素,第一个参数是1度增进的要素,(当然,那二种都会去遍历集合,直到给那些因素找到二个体面的岗位,最坏的境况正是要遍历整个集合才找到)

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的唯1性针对于
key 。
  1.HashMap 和 Hashtable 的区别:

      仔细看那七个称呼,会发现
Hashtable 不太适合驼峰式命名,那是因为她是相比较的老的本子,Hashtable 出自
JDK一.0 版本,是线程安全的(导致效能低),HashMap 是 JDK一.贰版本出现的,是线程不安全的(所以功效高),这样壹来 HashMap 就代替了
Hashtable了。(那点能够和 StringBuffer 1样,然后出去了 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个,执行到位后线程对象归池,那样能够幸免频仍创设线程对象所推动的品质开销,节省了系统的能源。就好比原先去商旅打饭是各种人看何人抢的赢,何人先抢到何人先吃,有了线程吃过后,正是排好队形,明马来西亚人跟你涉嫌好,你先来用餐。比如:1个用到要和互联网社交,有诸多步骤供给拜访互连网,为了不打断主线程,各样步骤都创立个线程,在线程夹钟互连网互动,用线程池就变的简短,线程池是对线程的一种包装,让线程用起来更为方便人民群众,只供给创八个线程池,把这个步骤像职责一样放进线程池,在先后销毁时只要调用线程池的绝迹函数即可。

单个线程的弊端:

  • 历次new
    Thread新建对象品质差
  • style=”font-size: large;”>线程贫乏统1管理,也许无界定新建线程,互相之间竞争,及容许占用过多系统财富导致死机大概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
写的,是在是比网页的好多了。。。。

她能在这么丧心病狂的社会里,长成岳丈样子,真的是1件有个别令人不可名状的事。

面向对象的三大特征和中国共产党第五次全国代表大会基本尺度:

三大特征:

  • 封装
  • 继承
  • 多态

中国共产党第五次全国代表大会亚湾原子核能发电站心条件:

  • 单纯性职分规范
  • 绽玉溪闭原则
  • 轮换原则
  • 依赖原则
  • 接口分离原则

详细:

style=”font-size: large; color: #ff0000;”>封装:所谓封装,也便是把客观事物封装成抽象的类,并且类能够把团结的数额和方法只让可信的类依然指标操作,对不可靠的进展音讯隐藏。封装是面向对象的表征之壹,是目的和类概念的主要特征。
简而言之,多个类正是3个卷入了多少以及操作这几个数据的代码的逻辑实体。在一个对象内部,有个别代码或少数数据足以是私有的,不能够被外边访问。通过那种措施,对象对里面数据提供了不一样级其余保卫安全,以幸免程序中非亲非故的片段意外的改动或错误的施用了目标的私人住房部分。

继承: style=”font-size: medium;”>所谓继承是指能够让有个别项目标靶子获得另二个品类的对象的质量的法子。它扶助按级分类的定义。继承是指那样1种力量:它可以行使现有类的装有成效,并在无需重新编排原来的类的气象下对那么些意义实行扩大。
通过延续创设的新类称为“子类”或“派生类”,被接二连三的类称为“基类”、“父类”或“超类”。继承的进度,正是从一般到独特的经过。要落到实处接二连三,能够通过“继承”(Inheritance)和“组合”(Composition)来促成。继承概念的贯彻格局有2类:达成延续与接口继承。达成持续是指直接利用基类的天性和章程而无需额外编码的能力;接口继承是指仅使用质量和艺术的称呼、不过子类必须提供完成的力量;

多态: style=”font-size: medium;”>所谓多态正是指三个类实例的同等方式在分化景色有两样表现情势。多态机制使拥有差异内部结构的靶子足以共享相同的表面接口。那意味,即便针对差别对象的具体操作差别,但透过一个公家的类,它们(这多少个操作)可以由此同样的艺术给予调用。

style=”font-size: large; color: #ff0000;”>多态3大要素:

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

    style=”font-size: large; color: #ff0000;”>单一职务规范: style=”font-size: medium; color: #000000;”>指2个类的法力要单纯,不可能健全。就好像一个人一样,分配的办事不能够太多,不然一天到晚固然忙费劲碌的,但效能却高不起来。

    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定义1浮泛接口,并由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;
    }
}

比比皆是年前,他还有个别苦涩的时候,总觉得本人要干一番要事,总希瞧着1夜成名。

二 . 懒汉式(线程安全)

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

她很粗笨,但她精晓自个儿要怎么。他很领会。

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

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

 

那年他身边有喜欢她的丫头,只怕说对她好的幼女。

四 . 饿汉式(选择静态代码块)

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

 

孙女话不多,也不是不会说话,只是在树前边线总指挥部是很平静。

陆 . 重新校验锁

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

树,有投机的大好。他领悟本人没那么聪明,所以他尤其努力。为了多看些专业书,为了能有让本人志得意满的作品,树与恒河沙数日出擦肩而过。

厂子情势:

约莫分3类:

  • 归纳工厂形式
  • 工厂方法形式
  • 架空工厂格局

    style=”font-size: large;”>前两者能够分开为联合,正是工厂方法格局。

那便是说工厂方法方式和虚幻工厂
方式的对待:

工厂方法方式:
      style=”color: #ff0000;”>一个空洞产品类,能够派生出三个实际产品类。  
      style=”color: #000000;”>一个空洞工厂类,能够派生出多少个具体工厂类。  
      种种具体育工作厂类只好创制1个现实产品类的实例。
泛泛工厂方式:
      style=”color: #ff0000;”>多个抽象产品类,各类抽象产品类能够派生出多少个实际产品类。  
      1个抽象工厂类,能够派生出三个具体育工作厂类。  
      各类具体育工作厂类可以创制两个具体产品类的实例。  
区别:
     工厂方法形式唯有一个抽象产品类,而空虚工厂格局有七个。  
    
工厂方法模式的实际工厂类只可以成立一个有血有肉产品类的实例,而肤浅工厂格局能够成立多少个。

 

姑娘总是劝她小心休息,身体是变革的老本。树总是答应,好。

【下边排序默许都为升序】

非常短的壹段日子,树每日都只是叁八个小时。每一趟躺下的时候,他就会频仍,脑公里不停的产出本身今后落魄的样子,姑娘可人的面貌。

排序代码:接纳,插入,气泡

采纳排序的笔触:(n 为要排序的数字个数,都借使升序排列)

      style=”font-size: medium;”> style=”font-size: large;”>将要排序的靶子分为三个部分,一个是前者已排序(假定为升序),一个后端未排序的,每一回从后端选择1个十分小值,并放入前端类别的末梢,那样最多循环(n

  • 一)次后就排序完结了。【 style=”color: #ff0000;”>最起首时,前端部分从没成分,后端成分为全方位】

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

        
图片 1

插入排序的思绪:

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

  • 1)次就大功告成了排序。【 style=”color: #ff0000;”>最早先时,前一批唯有2个要素,后一群是剩下的成分】

如图:

     
图片 2

气泡排序的思绪:

     style=”font-size: large;”>顾名思义,最大的要素会像气泡1样移至右端,利用相比较相邻成分的法门,将较大的因素调换至右端,所以大的因素会不停的往右移动,直到移动到相当的岗位(就是右端成分比它大的岗位)结束。【 style=”color: #ff0000;”>当 i 和 i + 壹未曾爆发过成分交流地点,就标明排序已到位】

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

就算有点不太领悟,但他却是叁个很善言辞的人。他想那大约与这一个日日夜夜有关,也与那个不乐意纪念的时刻有关。他看了过多书,各样种种的书。

飞速排序 -0一:

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 – 一);
// 对左侧进行递回
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;
}

}

他是搞艺术的,从小就喜好画画。而那1坚称就锲而不舍了二十几年。

相当的慢排序 -0二:

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 + 一, right); // 对左侧进行递回
}
}

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

在她老家那三个相当小很穷的地方,他多多少少是个名家。作为多少个考上省会城市大学的人之1,树精神看似有个别抖擞,话也多了一些。

快快排序 -0三:

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 = { 一, 四, 贰, 陆, 7, 三, 玖, 8 };
QuickSort.sort(number); //先排序
int find = BinarySearch.search(number, 三); //找到值为 3 的因素
if (find != -一)
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

  • 二个服务器最多向三个浏览器保存二十个 cookie

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

 

本人不知道到的转向和重定向:

style=”font-size: large;”>转载和重定向会清空上多少个response中缓存的数据,所以转发或重定向前的装有的
response都以不行的,唯有目的能源的
response的出口才是卓有成效的【也正是最后一个响应的数码才会被客户端接收,别的的响应数据都被扫除了】

 

 

 

补充:

前日看看1段代码,如下:

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
的2个里边类 IntegerCache。

     结果为何会出现那样的,那是因为
JVM 内部有多少个优化学工业机械制,当数值比较小(-12八~12七)时,会接纳 Integer
类中的八个之中类
IntegerCache类的对象将其储存起来,假若下次内需重新装箱一个一致大小的数字(-128~127以内),就直接取在此以前的值了,那几个比较小的数值使用的是同壹块存款和储蓄空间,当然,若是利用了
new 操作符,那么就一定会开发三个新的内部存款和储蓄器空间用来囤积数据。

有打火机,却不曾烟。那让特别想吸烟的树,有些无奈。突然就泄了气,壹臀部瘫软下来。

框架基础:

树,有个别马虎。

Spring:

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

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

在极度很穷相当的小的地点,没人知道树其实考上的只是一所很经常的高等高校,也没人会去关怀它究竟是做哪些的。人们只记得树考上了首府城市的高校,以后早晚要穿西装打领带,有专车接送。

SpringMVC:

可能还会有多个狗腿子一样的跟班,屁颠屁颠的跟在树的末尾。

树带着这些很穷十分的小的地点人们的羡慕和团结内心美好的奇想,去了卓殊很远很远的地点。

应该有十几层的楼,十分的大的市场。树那样想。美仑美奂,高高大大,是树能想到的形容词。

转了牛车转马车,坐完全小学车坐轻轨,树终于在那个高高大大的地点下了车。那须臾间,就击溃了那些来自很穷十分小地点的人。

眼光所及随地都以几10层的摩天津高校厦,玲琅满指标特等大商店,都让树某些眩晕。

树的作品毕竟肯有人买了。姑娘笑的专门的热情洋溢。

可是树却一贯愁眉不展,他觉得温馨的创作太廉价了,就如对友好的凌辱,对团结那一个个日日夜夜的凌辱。

固然树觉得侮辱了上下一心,但他要么卖了。他梦想存够钱,风风光光的回家办一场个人展。对于这么些小地方来说,那确实是壹件天天津大学学的情报。

某某学成归来,将在自笔者县第3遍设立了个人展。

想着自身将会被那么些曾经瞧不起的近邻领居簇拥着,树照旧非常快的将协调的著述卖了11分曾经谩骂过自个儿,满身都是铜臭味的生意人。

你的著述毕竟有人喜悦了。姑娘说。

你应当能够休息,好好去睡一觉。姑娘将本人炖好的汤放到了树前面。

树某些生气,他不欣赏被人催促。

但那时她丰裕欣喜,他伸入手握着姑娘的手。站了4起,将外孙女一把拉了复苏。然后,正是很霸气的吻,姑娘一十分的大心把手里的勺子丢到了地上。双臂使劲的抱着树。

那是她们的率先个吻,恐怕也是终极2个吻。

树,好像第2遍接吻,每一个动作都一点都不小力气,让闺女觉得有些生疼。那也是幼女的初吻,她通晓本人爱近年来以此人,所以满是深情。

树依然带着团结整个的东西回了要命很穷极小的地点,他想阐明那几人都以错的,自身有1天也会中标。

幼女,劝不动。便收10了行李,跟来了。

在十三分地点那里有人会欣赏树的小说,大七只是看欢畅。人们茶余饭后的研究都以那一个姑娘,以及树和侄女的关系。

立下了再也不会回来的誓言,树愤愤的走了。姑娘,依旧一道随从,未有点儿怨言。

望着为了本人风尘仆仆的姑娘,树有想给她七个家。买1栋房屋,然后生多少个儿女。过这种,每一日早出晚归等着吃爱妻做的饭,每一天都能和老伴孩子手牵手散步的日子。

房屋里的炊烟稳步小了,空气中伊始弥漫焦糊味。好像是心烧焦了感觉。

树兀的站起来,跑进房里,往锅里浇了犀利一大盆水。他盖好锅盖,一下子就死掉了,眼神也空荡荡的。

她冷不防意识窗户的犄角有石黄的东西,他来了些神气,小跑过去。那是壹根被他泡的皱皱巴巴的烟,有个别像她那双臂。

可是,树才三十多岁。

唯独树怎么会甘愿过这么的光景。

没多少人珍视所谓的学子,树觉得画画赚不了钱,也赢不到自尊。就下海了。

那天,姑娘哭的很痛心。即使他并不是因为她画画才喜欢树的,不过她以为只要不画画了树就不再是树了。

日趋来的树越来越忙,但孙女还老是现身。送早餐,整理房间,煲汤……

姑娘天天都会坐在树租的房舍里发呆,树平昔都不在家。他一而再很已经出去,很晚才回来。有时候过夜的排骨玉南瓜泥,会这么宁静的放三个夜晚。

幼女不知底她在做哪些,也常有不曾过问。她老是不厌倦的做着再一次的事体,送早餐,整理房间,煲汤……

树,为了自身的商号,每日忙的就餐的时刻都未曾了。对于突发性姑娘发来的“记得吃早餐”“天天早晚要美丽休息”1类的话,也接连“嗯”“嗯”“啊”“啊”的铺陈过去。

在静下来的须臾,树恍惚的想让孙女有一个家。他以为温馨是或不是太无情了,姑娘肯定会怨恨自个儿吧。

但他是那么的想成功,“笔者尽力挣钱,笔者所做的1切都是为了孙女。所以,她应有不会怪作者的。”他总是如此安慰本身。

实则树根本没时间想,到底是自身想要成功,照旧为了孙女。

他不想姑娘随后本身受穷,他以为这很丢脸,很穷困。

树,用皱皱Baba的手激起了那根烟。他冷不防望了望远方。

他现已很久未有那样心惊胆落了,只怕他一贯就不曾平稳过。他的眼神不像那个孩子那样纯洁明亮,他的视力是浑浊的,在那里你得不到一丝你想清楚的答案。

树想那些梦,是还是不是预示着什么。那些姑娘,会回到呢。依然会有下3个孙女出现。

温馨有史以来不曾牵手她的手,为什么在梦中,那感觉是那样的义气而温和。

本条梦一定预示着如何。树一向在内心狐疑。

皱皱Baba的烟,一明1(Wissu)灭稳步朝着它人生尽头走去。

后来,汤就好像此宁静的放了2个星期,放了3个月。

树根本没时间发觉。知道有1天,他打开门,问道令人切齿痛恨的含意时。他才赫然难熬的想,姑娘好像已经有一段时间没来了。

屋子凌乱布满了灰尘,再也从未人来扫除过了。

树,根本不记得姑娘多长期没来了。他只驾驭应该某些日子了。

她掏入手提式有线电话机,发了三个精晓的简讯过去。无人回应。

他大约是忙。树草草的给了如此八个答案,到头就睡下了。

不过她忽然梦里见到了孙女,梦里见到女儿在叫他。树,树。你爱不爱作者吗,树。

树,在梦中也绝非回应。他想使劲的抱紧姑娘,可发现房间已经空荡荡。

从那之后,树再也不曾重返住过。他忽然害怕那样清冷的屋子,害怕姑娘在梦之中喊她,树,树。

她醒来的时候总是会认为彻骨的冰冷,即便她不知底彻骨的冰凉到底是多冷。

笔者平时在本身工作的地点住,纵然不像个家,但最少不怎么人气。那里也能让她不再去想姑娘,只当她是偏离了,只怕早就找了四个住户马上快要订婚了。

他起头安心的办事,而商行也逐步的起来好转了。

就在合营社准备融资的时候,他霍然发现连个分享的人都并未有了。他想起了幼女,突然一下子略带痛恨自个儿,痛恨现实。

她跑去酒馆饮酒,随处都以谈情说爱的爱人,到处都以浓妆艳抹的女子,四处都是大喊。他却觉得不行的孤身,分外的阴冷,他不停的吃酒,不停的享用着寂寞。

并未有人是相当拉着她的幼女,也未尝人跟她说“好好休息”。他想起梦里孙女的不停的叫她,树,树。他纪念梦里女儿的脸。

她摇摇晃晃的想要回本人住的地方去探望,他想去看看姑娘。

在楼下的时候,他听见了警笛,看到了团结的房子灯亮着,他认为孙女回来了。他想要冲上去找孙女,然则警察拦住了他。

她就那样定定的站在那里瞧着窗台,他接近看到孙女站在那边,对着他笑了须臾间,然后不见了。警察抬了一具身体下来,白布盖着的。他忽然冲上去扯开白布,壹股恶臭弥漫开来,在场的每一个人都弯下腰开头呕吐。

人体已经改头换面了,他就那么定定的望着。直到警察找来了防毒面具,将尸体抬走。他就那样在这边站到了天亮。他径直在想着姑娘,平昔想着姑娘喊她,树,树。

树的眼眸闪过一丝希望,那是她浑浊的视力不令人感觉畏惧的缘故。

姑娘曾经说,想跟着他去到七个没人的地点,建一个小木屋。每一天都能够望着她,轻轻的喊他,树,树。

可是姑娘再也从没出现了,也不会再有那样的姑娘了。明早树又梦里见到他了,在梦之中他牵起了树的手,让树牢牢的抱着她。笔者通晓他甘愿跟自家在1块儿,该是原谅自个儿了。

树忽然哭了。

发表评论

电子邮件地址不会被公开。 必填项已用*标注