Java 面试前的根基准备 – 01

洗完澡出来口疮舌燥,多少个老女子坐在石凳上剥桔子吃,小编想以此时候尽管能像之前一样来点红心萝卜就好了,脆脆甜甜的,仍是能够冷却洗澡之后的“燥气”,舒服极了。澡堂子依然不行澡堂子,某个东西还在有一部分事物已经破灭了,然则若是澡堂子还在一天,那么些温暖的记得就能被唤起。

单例设计情势:

大面积的单例格局重要有懒汉和饿汉二种,懒汉分线程安全和不安全,代码上来先:

春节个中喜事多,这家有酒那家办事的,小编和老人亲坐在车里,妇女总爱“嚼舌头根子”,就说起哪家子女什么不孝顺,过大年都不回来,阿爹说:“度岁是什么?就是子女啊,孩子不回来叫什么年!”作者心里豁然沉重了,吐弃新岁假期外出旅行回家来自然还有点不情愿,没悟出作者的回村对于老人来说那样主要!此时依旧有部分弹冠相庆本身的选用。回家,和父阿娘在一道,哪怕不是过大年;回家,和老母去洗一把澡,在原来的老大澡堂子里搓搓澡,其实比“外面包车型地铁景点”都好。

排序代码:采取,插入,气泡

选料排序的笔触:(n 为要排序的数字个数,都假使升序排列)

      style=”font-size: medium;”> style=”font-size: large;”>将要排序的靶子分为七个部分,二个是前者已排序(假定为升序),一个后端未排序的,每一次从后端采取3个十分小值,并放入前端种类的最后,那样最多循环(n

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

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

        
图片 1

插入排序的笔触:

     style=”font-size: large;”>像玩扑克牌一样,能够将牌分为两堆,每趟从后一堆中抽出第2张,插入到前一堆中的得当位置,那样最多循环(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;
    }
}

澡堂子就在桥头附近。因为桥名叫兴港桥所以周边的营业所、油坊、卤菜铺子都是桥名命名,包蕴那澡堂子,那正是华夏农村的知识风俗,看到那个商铺就清楚那里是哪块了。作者打包好洗漱用品就和生母相跟着到了澡堂子。深藕红漆大篆字在白墙上虽说土气了点但很显明,还和童年一模一样,柜台也许不行柜台,镜子依然不行镜子,站柜台的小业主换了人,但依旧和以前一样,磕着瓜子笑脸迎人,都以街坊邻居的开些荤素玩笑。可惜柜台旁边的角落里少了充裕长久飘着香馥馥的茶叶蛋炉子,那只是最佳的冲凉佐餐佳肴,只要来澡堂子洗澡鼻子里除了香胰子的香味正是那茶叶蛋的意味了,“挣不了几个钱,不弄了。”她依旧磕着瓜子,毫不在意地说着。进了澡堂子,里面包车型地铁组织基本没变,还是能勾起我有趣的小儿想起,上学的时候每种礼拜五都要回家,回家必做的一件事就是不错地在澡堂子里洗把澡然后清清爽爽地回高校,那美观依然要归功于阿娘的搓澡。那会阿妈依旧嘲笑作者:“你是天天洗澡的人呢?怎么洗的?跟水相个嘴啊?怎么那么多渍垢?”她要我本人看,弄得笔者也很害羞,老母笑着说:“刻钟候皮,搓出来的是黑泥,未来整天坐办公室了,搓出来的是白泥,颜色变浅了,量倒更加多了。”“都在身上攒着呢,能不多嘛。”笔者洗着从本身身上搓下来的那么些渍垢,小编想世上最牛的搓澡师正是全天下的慈母和老爹了,他们为投机孩子搓澡的时候总是不放过一存一厘的肌肤,手下的那幅皮囊是上下一心身上掉下来的肉,一点一滴饲养养大的,哪能容许那个脏东西附着在地点吧?作者也和从前一样帮阿娘搓了背,她还是嫌弃笔者不够劲道,像蚊子咬一样。

 

新岁的那几天里气象一向阴沉,太阳能磁能热水器出不迭热水,洗澡就成了难题,阿娘说,桥头的澡堂子又再次开了,就寻思着带笔者去澡堂洗澡。

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

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

foreach 实现原理:

    foreach正是 java
中的压实for循环,语法: for(Type agr : Coll){ }

    其达成原理便是利用了迭代器,所以会比平常for
循环会火速一点,但是也有弊端,便是只可以遍历成分,无法修改成分。

集合排序法:

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

设计形式:

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

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

 

  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. 效益在代码块上(类被加载时,代码块自动执行,并且只举办一回,一般用来加载驱动可能单例设计方式)
  4. 静态导包(使被导包内的静态成员能够平昔在我们直接的类中一贯动用,不须要带类名,比如
    Math 类的 PI 常量,但缺点很引人侧目,可读性性下跌)

选拔那个在线网页编辑真的是不习惯,如故windows live writer 好。

下边列叁个清单用于近来的面试:(
清单是网上down的 )

面向对象的三大特点和中国共产党第五次全国代表大会主导条件:

三大特色:

  • 封装
  • 继承
  • 多态

中国共产党第五次全国代表大会骨干条件:

  • 单纯性职责规范
  • 绽焦作闭原则
  • 轮换原则
  • 信赖原则
  • 接口分离原则

详细:

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;”>盛营口闭原则:八个模块在扩展性方面应该是开放的而在更改性方面应当是封闭的。比如:2个网络模块,原来只服务端功用,而现行反革命要加盟客户端作用,那么相应在并非修改服务端功效代码的前提下,就能够增添客户端功效的兑现代码,那须要在规划之初,就应有将服务端和客户端分开,公共部分虚幻出来。

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

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

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;”>】

双链集合中的知识点:

双链集合的根接口是 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()
方法,来取得下3个剖析事件(就是开端文书档案,停止文书档案,起始标签,甘休标签),当远在有个别成分时能够调用
XmlPullParser的getAttributte() 方法来赢得属性的值,也可调用它的
nextText() 获取本节点的值。

什么是线程池,
以及线程池的亮点
:

style=”font-size: large;”>线程池的主干考虑是一种对象池的思考,开辟一块内部存款和储蓄器空间,里面存放了好多
(未病逝)
的线程,池中线程执行调度由池管理器来处理。当有线程职务时,从池中取1个,执行到位后线程对象归池,那样能够幸免频仍成立线程对象所带动的品质费用,节省了系统的能源。就好比原先去酒店打饭是每一种人看什么人抢的赢,什么人先抢到什么人先吃,有了线程吃过后,便是排好队形,明天笔者跟你关系好,你先来用餐。比如:多个施用要和互连网社交,有不少手续须求拜访网络,为了不打断主线程,种种步骤都创造个线程,在线程杏月互连网互动,用线程池就变的简短,线程池是对线程的一种包装,让线程用起来更为方便人民群众,只供给创1个线程池,把那个步骤像任务同样放进线程池,在先后销毁时只要调用线程池的销毁函数即可。

单个线程的坏处:

  • 每便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
写的,是在是比网页的好多了。。。。

单链集合中的知识点:

单链集合的根接口是Collection,其下有八个子接口
List 和 Set,前者能积存重复成分,后者不能够积存重复成分。

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()是杰出近似的,分歧的便是前者有被抬高的因素调用,参数只有一个,后者有七个参数,第多个参数是要丰裕的因素,第三个参数是早就添加的要素,(当然,那三种都会去遍历集合,直到给这么些成分找到2个分外的职位,最坏的意况正是要遍历整个集合才找到)

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;”>】

transient 关键字的法力:

  1.  

二分搜寻法:

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

  • 七个服务器最多向3个浏览器保存十九个 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 操作符,那么就必然会开发2个新的内部存款和储蓄器空间用来储存数据。

 

volatile 关键字效能:

 

 

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

 

final 关键字的功力:

  1. 功能在类上
    (该类变为最后类,不能够被接续)
  2. 效益在性质上
    (属性改为常量,常量的地方不允许被改动)
  3. 功用在措施上
    (方法成为最后方法,不能够被子类重写)
  4. 效果在形参列表上(在方法类,值类型不容许被涂改,引用类型对象的天性可以被修改,不过引用类型对象无法被更改)

对此
final 的第三点,要铭记在心那句话,使用  final
关键字修饰三个值类型变量时,值类型的值不容许修改;修饰的是引用型变量时,是指点用变量地址无法变,可是引用变量所针对的指标中的内容仍然得以更改的。**
归纳到一点正是常量的地方无法改。**】

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

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

}

厂子形式:

差不离分三类:

  • 简短工厂方式
  • 工厂方法模式
  • 空洞工厂方式

    style=”font-size: large;”>前两者能够划分为联合,就是工厂方法情势。

那便是说工厂方法格局和浮泛工厂
方式的对待:

厂子方法情势:
      style=”color: #ff0000;”>一个抽象产品类,能够派生出八个实际产品类。  
      style=”color: #000000;”>多个空洞工厂类,能够派生出八个具体育工作厂类。  
      各类具体育工作厂类只可以创立1个切实产品类的实例。
虚幻工厂格局:
      style=”color: #ff0000;”>多个空洞产品类,每一个抽象产品类能够派生出多少个具体产品类。  
      三个华而不实工厂类,可以派生出多少个具体育工作厂类。  
      每一个具体育工作厂类能够创制七个有血有肉产品类的实例。  
区别:
     工厂方法方式唯有3个空洞产品类,而空虚工厂方式有多个。  
    
工厂方法方式的切实可行工厂类只可以创立三个切实可行产品类的实例,而空虚工厂方式能够创建八个。

 

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

SpringMVC:

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

Spring:

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

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

框架基础:

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

发表评论

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