java多线程的实现与对线程创建于运行的一点点小小看法

/*
* @author     Quicljava多线程的实现与对线程创建于运行的一点点小小看法
* @blog    http://20xue.com
* @email    quicl@20xue.com
*/
public class Java多线程介绍 {
   
    public static void main (String [] args){
       
        new runner().start();
       
        while (true){
           
            System.out.println("main() Thread :" + Thread.currentThread().getName());
           
        }
       
    }

}

class runner extends Thread{
   
    public void run(){
       
            while (true){
           
            System.out.println("run() Thread :" + Thread.currentThread().getName());
           
        }
       
    }
   
}
/*
* 笔记:用Thread创建线程需要明白的几点知识:
* 1、如果要将代码放在一个线程上运行,这个代码应该在一个类的run函数中,并且run函数所在的类。
* 我们还可以看成,我们要实现多线程,必须要写一个继承了Thread类的子类,子类要覆盖Thread类中的run函数,在子类的run函数中调用
* 我们准备在新线程上要运行的程序代码。
* 2、启动一个新线程,我们不是直接调用的Thread的子类对象的run方法,而是调用Thread子类对象的start方法,这个start方法是从
* Tread类继承的。Tread类对象的start方法将产生一个新的线程,并在该线程上运行该Thread类对象中的run方法,根据面向对象的运
* 行时的多态性,在该线程上实际运行的是Thread子类,也就是我们写的那个子类对象中的run方法。
* 3、由于线程的代码在run方法中,那么该方法执行完成后线程就相应结束了,因此我们可以通过控制run方法中循环的条件来控制线程的结束。
* 疑问:在写run方法时候,为什么可以添加static呢?
*/

JAVA实现实现输入半径,输出一个星号组成的圆

/*
* @author  :Quicl
* @version    :1.0
* @email    :quicl@20xue.com
* @blog    :http://20xue.com
* @ps        :实现输入半径,输出一个星号组成的圆
*/

import java.util.Scanner;

public class XinghaoYuanClass {

    public static void main(String[] args) {

        Scanner kb = new Scanner(System.in);
        int a = kb.nextInt();
   
        graphic( a );
    }
   
    public static void graphic(int r){
       
        int y = 2 * r;
       
        int xa,xb;
        for(int R = 0;R <= y;R ++){
           
        xa = r – sp(R,r);
        xb = y – r + sp(R,r);
       
            for (int i = 0;i < xa;i ++){
                System.out.print("  ");
            }
           
            System.out.print("*");
           
            for (int i = xa + 1;i < xb;i ++){
                System.out.print("  ");
            }
           
            System.out.print("*");
            System.out.println();
           
        }
       
    }
   
    public static int sp(int R,int r){

        int s = (int) Math.sqrt(r * r – ( r – R ) * ( r – R));
        return s;
       
    }

}

Java常用的几个排序算法详细介绍

排序算法很多地方都会用到,近期又重新看了一遍算法,并自己简单地实现了一遍,特此记录下来,为以后复习留点材料。

废话不多说,下面逐一看看经典的排序算法:

1. 选择排序

选择排序的基本思想是遍历数组的过程中,以 i 代表当前需要排序的序号,则需要在剩余的 [i…n-1] 中找出其中的最小值,然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程,所以人们形象地称之为选择排序。举个实例来看看:

初始: [38, 17, 16, 16, 7, 31, 39, 32, 2, 11] 
 
i = 0:  [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] (0th [38]<->8th [2]) 
 
i = 1:  [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] (1st [38]<->4th [17]) 
 
i = 2:  [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] (2nd [11]<->9th [16]) 
 
i = 3:  [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] ( 无需交换 ) 
 
i = 4:  [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] (4th [17]<->9th [16]) 
 
i = 5:  [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] (5th [31]<->9th [17]) 
 
i = 6:  [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] (6th [39]<->9th [31]) 
 
i = 7:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 ) 
 
i = 8:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 ) 
 
i = 9:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

由例子可以看出,选择排序随着排序的进行( i 逐渐增大),比较的次数会越来越少,但是不论数组初始是否有序,选择排序都会从 i 至数组末尾进行一次选择比较,所以给定长度的数组,选择排序的比较次数是固定的: 1 + 2 + 3 + …. + n = n * (n + 1) / 2 ,而交换的次数则跟初始数组的顺序有关,如果初始数组顺序为随机,则在最坏情况下,数组元素将会交换 n 次,最好的情况下则可能 0 次(数组本身即为有序)。

由此可以推出,选择排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) (选择排序只需要一个额外空间用于数组元素交换)。

实现代码:

/** 
* Selection Sorting 
*/
SELECTION(new Sortable() { 
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) { 
        int len = array.length; 
        for (int i = 0; i < len; i++) { 
            int selected = i; 
            for (int j = i + 1; j < len; j++) { 
                int compare = array[j].compareTo(array[selected]); 
                if (compare != 0 && compare < 0 == ascend) { 
                    selected = j; 
                } 
            } 
 
            exchange(array, i, selected); 
        } 
    } 
})

2. 插入排序

插入排序的基本思想是在遍历数组的过程中,假设在序号 i 之前的元素即 [0..i-1] 都已经排好序,本趟需要找到 i 对应的元素 x 的正确位置 k ,并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位,为元素 x “腾位置”,最后将 k 对应的元素值赋为 x ,插入排序也是根据排序的特性来命名的。

以下是一个实例,红色 标记的数字为插入的数字,被划掉的数字是未参与此次排序的元素,红色 标记的数字与被划掉数字之间的元素为逐个向后移动的元素,比如第二趟参与排序的元素为 [11, 31, 12] ,需要插入的元素为 12 ,但是 12 当前并没有处于正确的位置,于是我们需要依次与前面的元素 31 、 11 做比较,一边比较一边移动比较过的元素,直到找到第一个比 12 小的元素 11 时停止比较,此时 31 对应的索引 1 则是 12 需要插入的位置。

初始:    [11, 31, 12, 5, 34, 30, 26, 38, 36, 18] 
 
第一趟: [11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] (无移动的元素) 
 
第二趟: [11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] ( 31 向后移动) 
 
第三趟: [5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] ( 11, 12, 31 皆向后移动) 
 
第四趟: [5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] (无移动的元素) 
 
第五趟: [5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] ( 31, 34 向后移动) 
 
第六趟: [5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] ( 30, 31, 34 向后移动) 
 
第七趟: [5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] (无移动的元素) 
 
第八趟: [5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] ( 38 向后移动) 
 
第九趟: [5, 11, 12, 18 , 26, 30, 31, 34, 36, 38] ( 26, 30, 31, 34, 36, 38 向后移动)

插入排序会优于选择排序,理由是它在排序过程中能够利用前部分数组元素已经排好序的一个优势,有效地减少一些比较的次数,当然这种优势得看数组的初始顺序如何,最坏的情况下(给定的数组恰好为倒序)插入排序需要比较和移动的次数将会等于 1 + 2 + 3… + n = n * (n + 1) / 2 ,这种极端情况下,插入排序的效率甚至比选择排序更差。因此插入排序是一个不稳定的排序方法,插入效率与数组初始顺序息息相关。一般情况下,插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) 。

实现代码:

/** 
* Insertion Sorting 
*/
INSERTION(new Sortable() { 
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) { 
        int len = array.length; 
        for (int i = 1; i < len; i++) { 
            T toInsert = array[i]; 
            int j = i; 
            for (; j > 0; j–) { 
                int compare = array[j – 1].compareTo(toInsert); 
                if (compare == 0 || compare < 0 == ascend) { 
                    break; 
                } 
                array[j] = array[j – 1]; 
            } 
 
            array[j] = toInsert; 
        } 
    } 
})

3. 冒泡排序

冒泡排序可以算是最经典的排序算法了,记得小弟上学时最先接触的也就是这个算法了,因为实现方法最简单,两层 for 循环,里层循环中判断相邻两个元素是否逆序,是的话将两个元素交换,外层循环一次,就能将数组中剩下的元素中最小的元素“浮”到最前面,所以称之为冒泡排序。

照例举个简单的实例吧:

 
 
初始状态:   [24, 19, 26, 39, 36, 7, 31, 29, 38, 23] 
 
内层第一趟: [24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ] ( 9th [23]<->8th [38 ) 
 
内层第二趟: [24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38] ( 8th [23]<->7th [29] ) 
 
内层第三趟: [24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38] ( 7th [23]<->6th [31] ) 
 
内层第四趟: [24, 19, 26, 39, 36, 7, 23, 31, 29, 38] ( 7 、 23 都位于正确的顺序,无需交换) 
 
内层第五趟: [24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38] ( 5th [7]<->4th [36] ) 
 
内层第六趟: [24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38] ( 4th [7]<->3rd [39] ) 
 
内层第七趟: [24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38] ( 3rd [7]<->2nd [26] ) 
 
内层第八趟: [24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38] ( 2nd [7]<->1st [19] ) 
 
内层第九趟: [7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38] ( 1st [7]<->0th [24] ) 
 
……… .

其实冒泡排序跟选择排序比较相像,比较次数一样,都为 n * (n + 1) / 2 ,但是冒泡排序在挑选最小值的过程中会进行额外的交换(冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换,与之对应的是选择排序,只会在内层循环比较结束之后根据情况决定是否进行交换),所以在我看来,选择排序属于冒泡排序的改进版。

实现代码:

/** 
* Bubble Sorting, it’s very similar with Insertion Sorting 
*/
BUBBLE(new Sortable() { 
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) { 
        int length = array.length; 
        int lastExchangedIdx = 0; 
        for (int i = 0; i < length; i++) { 
            // mark the flag to identity whether exchange happened to false 
            boolean isExchanged = false; 
            // last compare and exchange happened before reaching index i 
            int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i; 
            for (int j = length – 1; j > currOrderedIdx; j–) { 
                int compare = array[j – 1].compareTo(array[j]); 
                if (compare != 0 && compare > 0 == ascend) { 
                    exchange(array, j – 1, j); 
                    isExchanged = true; 
                    lastExchangedIdx = j; 
                } 
            } 
            // if no exchange happen means array is already in order 
            if (isExchanged == false) { 
                break; 
            } 
        } 
    } 
})

4. 希尔排序

希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”,划分为若干个小的数组,以 gap 来划分,比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ,如果以 gap = 2 来划分,可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组(对应的,如 gap = 3 ,则划分的数组为: [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] )然后分别对划分出来的数组进行插入排序,待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤,直至 gap = 1 ,即对整个数组进行插入排序,此时的数组已经基本上快排好序了,所以需要移动的元素会很小很小,解决了插入排序在处理大规模数组时较多移动次数的问题。

具体实例请参照插入排序。

希尔排序是插入排序的改进版,在数据量大的时候对效率的提升帮助很大,数据量小的时候建议直接使用插入排序就好了。

实现代码:

/** 
* Shell Sorting 
*/
SHELL(new Sortable() { 
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) { 
        int length = array.length; 
        int gap = 1; 
 
        // use the most next to length / 3 as the first gap 
        while (gap < length / 3) { 
            gap = gap * 3 + 1; 
        } 
 
        while (gap >= 1) { 
            for (int i = gap; i < length; i++) { 
                T next = array[i]; 
                int j = i; 
                while (j >= gap) { 
                    int compare = array[j – gap].compareTo(next); 
                    // already find its position 
                    if (compare == 0 || compare < 0 == ascend) { 
                        break; 
                    } 
 
                    array[j] = array[j – gap]; 
                    j -= gap; 
                } 
                if (j != i) { 
                    array[j] = next; 
                } 
            } 
            gap /= 3; 
        } 
 
    } 
})
5. 归并排序

归并排序采用的是递归来实现,属于“分而治之”,将目标数组从中间一分为二,之后分别对这两个数组进行排序,排序完毕之后再将排好序的两个数组“归并”到一起,归并排序最重要的也就是这个“归并”的过程,归并的过程中需要额外的跟需要归并的两个数组长度一致的空间,比如需要规定的数组分别为: [3, 6, 8, 11] 和 [1, 3, 12, 15] (虽然逻辑上被划为为两个数组,但实际上这些元素还是位于原来数组中的,只是通过一些 index 将其划分成两个数组,原数组为 [3, 6, 8, 11, 1, 3, 12, 15 ,我们设置三个指针 lo, mid, high 分别为 0,3,7 就可以实现逻辑上的子数组划分)那么需要的额外数组的长度为 4 + 4 = 8 。归并的过程可以简要地概括为如下:

1) 将两个子数组中的元素复制到新数组 copiedArray 中,以前面提到的例子为例,则 copiedArray = [3, 6, 8, 11, 1, 3, 12, 15] ;

2) 设置两个指针分别指向原子数组中对应的第一个元素,假定这两个指针取名为 leftIdx 和 rightIdx ,则 leftIdx = 0 (对应 copiedArray 中的第一个元素 [3] ), rightIdx = 4 (对应 copiedArray 中的第五个元素 [1] );

3) 比较 leftIdx 和 rightIdx 指向的数组元素值,选取其中较小的一个并将其值赋给原数组中对应的位置 i ,赋值完毕后分别对参与赋值的这两个索引做自增 1 操作,如果 leftIdx 或 rigthIdx 值已经达到对应数组的末尾,则余下只需要将剩下数组的元素按顺序 copy 到余下的位置即可。

下面给个归并的具体实例:

第一趟: 
 
辅助数组 [21 , 28, 39 | 35, 38] (数组被拆分为左右两个子数组,以 | 分隔开) 
 
[21 ,  ,  ,  ,  ] (第一次 21 与 35 比较 , 左边子数组胜出, leftIdx = 0 , i = 0 ) 
 
第二趟: 
 
辅助数组 [21, 28 , 39 | 35, 38] 
 
[21 , 28,  ,  ,  ] (第二次 28 与 35 比较,左边子数组胜出, leftIdx = 1 , i = 1 ) 
 
第三趟: [21, 28, 39 | 35 , 38] 
 
[21 , 28 , 35,  ,  ] (第三次 39 与 35 比较,右边子数组胜出, rightIdx = 0 , i = 2 ) 
 
第四趟: [21, 28, 39 | 35, 38 ] 
 
[21 , 28 , 35 , 38,  ] (第四次 39 与 38 比较,右边子数组胜出, rightIdx = 1 , i = 3 ) 
 
第五趟: [21, 28, 39 | 35, 38] 
 
[21 , 28 , 35 , 38 , 39] (第五次时右边子数组已复制完,无需比较 leftIdx = 2 , i = 4 )
以上便是一次归并的过程,我们可以将整个需要排序的数组做有限次拆分(每次一分为二)直到分为长度为 1 的小数组为止,长度为 1 时数组已经不用排序了。在这之后再逆序(由于采用递归)依次对这些数组进行归并操作,直到最后一次归并长度为 n / 2 的子数组,归并完成之后数组排序也完成。

归并排序需要的额外空间是所有排序中最多的,每次归并需要与参与归并的两个数组长度之和相同个元素(为了提供辅助数组)。则可以推断归并排序的空间复杂度为 1 + 2 + 4 + … + n = n * ( n + 2) / 4 (忽略了 n 的奇偶性的判断),时间复杂度比较难估,这里小弟也忘记是多少了(囧)。

实现代码:

/** 
* Merge sorting 
*/
MERGE(new Sortable() { 
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) { 
        this.sort(array, 0, array.length – 1, ascend); 
    } 
 
    private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) { 
        // OPTIMIZE ONE 
        // if the substring’s length is less than 20, 
        // use insertion sort to reduce recursive invocation 
        if (hi – lo < 20) { 
            for (int i = lo + 1; i <= hi; i++) { 
                T toInsert = array[i]; 
                int j = i; 
                for (; j > lo; j–) { 
                    int compare = array[j – 1].compareTo(toInsert); 
                    if (compare == 0 || compare < 0 == ascend) { 
                        break; 
                    } 
                    array[j] = array[j – 1]; 
                } 
 
                array[j] = toInsert; 
            } 
 
            return; 
        } 
 
        int mid = lo + (hi – lo) / 2; 
        sort(array, lo, mid, ascend); 
        sort(array, mid + 1, hi, ascend); 
        merge(array, lo, mid, hi, ascend); 
    } 
 
    private <T extends Comparable<T>> void merge(T[] array, int lo, int mid, int hi, boolean ascend) { 
        // OPTIMIZE TWO 
        // if it is already in right order, skip this merge 
        // since there’s no need to do so 
        int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]); 
        if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < 0 == ascend) { 
            return; 
        } 
 
        @SuppressWarnings("unchecked") 
        T[] arrayCopy = (T[]) new Comparable[hi – lo + 1]; 
        System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length); 
 
        int lowIdx = 0; 
        int highIdx = mid – lo + 1; 
 
        for (int i = lo; i <= hi; i++) { 
            if (lowIdx > mid – lo) { 
                // left sub array exhausted 
                array[i] = arrayCopy[highIdx++]; 
            } else if (highIdx > hi – lo) { 
                // right sub array exhausted 
                array[i] = arrayCopy[lowIdx++]; 
            } else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) { 
                array[i] = arrayCopy[lowIdx++]; 
            } else { 
                array[i] = arrayCopy[highIdx++]; 
            } 
        } 
    } 
})
6. 快速排序

快速排序也是用归并方法实现的一个“分而治之”的排序算法,它的魅力之处在于它能在每次 partition (排序算法的核心所在)都能为一个数组元素确定其排序最终正确位置(一次就定位准,下次循环就不考虑这个元素了)。Java常用的几个排序算法详细介绍 原文链接:easense2009.iteye.com/blog/1568614

Java学习如何才能成为高手之Java系统程序员修炼之道

学C的都说要学到系统级别才行,尔后又拿Java不底层抨击Java没有系统程序员一说。可是,Quicl找到了一篇很不错的关于Java学习的文章。下面就是我们Java学习者如何走向高手的步骤,也就是系统级Java程序员路线。一起来看看吧!


从2002开始接触Java学会HelloWorld这么经典的程序到如今不知不觉已经十年啦,十年中

亲耳听到过不少大牛的演讲,见到过项目中的神人在键盘上运指如飞的编程速度,当时就

被震撼了。当编程越来越成体力活,我们还能有自己的思想,还能修炼为Java系统级别的

程序员嘛?学习与修炼以下知识与技能,帮你早日达成愿望。

一:Java语言学习


对线程(thread),串行化,反射,网络编程,JNI技术,容器(Map,List, Iterator), 类加载器

(ClassLoader),输入输出流,垃圾回收机制, 有比较深入的了解,最起码做过项目应用。有

过Java项目的性能优化经验,最起码掌握一种性能监视工具的使用,熟悉JVM参数,最起

码知道可以在JVM启动时指定不同垃圾回收机制,以及不同垃圾回收机制之间的

差别,熟悉JVM参数优化。

二:J2EE方面


最好知道JDBC规范是怎么回事情,面对Oracle数据库如果告诉你JDBC驱动不能用了,你

还知道有OCI驱动可以。掌握常见的SQL语句,熟悉JMS, JNDI等组件,掌握一套web开

发模式,从前台到后台,有能力整合好这样的框架。理解并掌握MVC思想,像SSH已经实

现了MVC的分层,几乎不需要你自己再实现,假设你开发一个简单的Swing程序,你能MVC

就说明你真的掌握了MVC的精髓。有能力在J2EE前端开发中构建自己的MVC模式,知道

什么是WEB2.0,知道什么是SOA, SaaS, SaaP等含义

三:理解并能合理运用设计模式,UML建模


知道并理解设计模式中蕴含的几种基本原则如:里氏替换原则, 开闭原则,合成复用原则,

依赖倒置原则有很好的理解,并能举例说明。对常用的设计模式如工厂模式,单例模式,观

察者模式,责任链模式,桥接模式等知道灵活运用,明白什么是回调(Callback)。最后用一位

高人话来总结设计模式,它是为了让软件更容易被别人读懂,更容易维护而产生,设计模

式本质是程序员之间的交流,如果A用工厂模式设计一个模块B来接替,A只要说该模块是

工厂模式实现,B维护起来应该容易得多,所以设计模式是关于交流,不关于代码。切忌滥

用设计模式。学会使用UML建模工具至少熟悉一种URL建模工具。

四:注重用户体验,掌握KISS原则,知道欧卡姆剃刀原则


顾客就是上帝这个口号我们已经喊了N年了,程序员的劳动成果最终也需要转换为服务提

供给客户,用户体验至关重要,常常看到的场景是功能实现了,软件很难使用,程序员有个

很充足的理由我不是美工,其实注重用户体验跟美工八杆子也打不到一起,FoxMail的成功

在很大程度是用户体验的成功,友好,清晰的用户提示,强的容错与纠错设计是获得好的

用户体验的不二法门。傻瓜相机顾名思义傻子都会使用,这个就著名的KISS原则(Keep it

simple and stupid)意思是UI设计要简单明了,傻子一看就知道怎么用,想想我们做出来的

东西,对照说明书都不知道怎么用。另外一个就是最著名的例子IPhone手机外观设计,是

典型的欧卡姆剃刀设计原则来完成人机交互。

五:自动测试与软件配置管理(SCM)实现


知道什么是软件配置管理,知道Hudson – http://java.net/projects/hudson/运用该工具SCM,

知道怎么获取测试代码覆盖率, Java有效代码行数(NCSS),完成firebug, JDepend等工具

集成ant/maven。熟悉并注重在开发过程中使用JUnit单元测试,理解白盒测试规范。

六:熟悉常见的网络通信协议


对HTTP协议,知道POST, GET的区别是什么,阅读过HTTP相关的RFC文档。学会使用sniffer

工具查看数据包,帮助查找与调试程序,知道TCP与UDP的区别,知道并理解E-Mail发送

与接受的协议如SMTP, POP3,IMAP等协议,了解MIME与Base64编码。知道组播是怎

么回事情。

七:面向市场,永远对新技术保持渴望


计算机技术的发展日新月异,做为IT行业的软件开发人员要不断的给自己充电,更新自己

的技术与时代保持同步,同时还要面向市场,华为总裁任正非说过-“华为的技术革新必须面

向市场”,作为程序员同样要有市场意识,很多人都后悔没有在android刚出来的时候加以

关注学习。那些很早关注android开发技术的很多程序员因此获得丰厚回报。如今HTML5

得到越来越多的浏览器厂家支持,你是否已经跟上脚步,开始学习。

八:保持谦虚,三人行必有我师


乔帮主说他要保持初心,努力学习,我等更应该保持谦虚,IT技术发展日新月异,在你眼中

不可能实现的技术,也许别人早已经有思路。保持谦虚就有机会吸取别人身上的长处,古人

有云:满招损,谦受益。一个得道的高人更是说出了”下下人,上上智”的禅语。永远不要拒

绝帮助你周围的人解决难题,解决难题是进步最快途径。不要放弃任何一次可以提升自己技

术与能力的机会。

九:养成总结的习惯,不断反思


上学的时候老师常让写小结,也没总结出来所以然,以至于工作以后再也不提这档子事情,

建议每个项目做完以后对自己都有个小结,总结自己在项目里面学到了什么,反问自己能不

能完成在不需要别人帮助的情况下自己完成这样的系统搭建,是否熟悉与掌握项目中所用到

的技术,即使有些东西不是你负责完成的但是什么也不能阻挡一颗求知的心,总结要尽量详

细记录你遇到那些难题是怎么一个一个的解决的,下次再遇到你是否可以很快解决或者避免

这样的问题。有总结才有提高,孔子曰:学而不思则罔,如果我们只是coding到吐血,不

思考,不总结提高,永远不可能有能有本质提高,秦相李斯有云:“泰山不让土壤,故能

成其大,河海不择细流,故能就其深”,点滴积累不断总结方能量变导致质变。

十:数学功底与算法知识


用任何编程语言开发应用,都离不开核心算法支持,很多国外的软件单单从UI上看,恐怕写

几年程序的人都可以模仿,但是UI之下的那些真实深浅不一,相信不是你想模仿就可以模

仿的,为什么我们越来越山寨,因为我们没有核心竞争力,对于程序员来说算法与数学显然

是他最重要的核心竞争力之一。《算法导论》,《编程珠玑》等书绝对值得读十遍。微软亚洲

研究院视觉计算组负责人在一次演讲中说到他们招人的标准是“三好学生– 数学好,编程

好,态度好”。可是现实的普遍情况却是 – 微机原理闹危机,汇编语言不会变,实变函数学

十遍。计算机基础知识被大家普遍忽视。从今天开始好好学习吧……

十一:Java代码反编译与代码保护


Java编译产生字节码,因而可以被轻松的逆向工程(反编译),微软的C#生产的DLL也一样可

以被轻松反编译。正式由于这个原因产生了许多Java开源的代码保护工具,而Proguard是

其中佼佼者,已经被google集成在android之中用于Java代码保护,访问这里了解更多:

http://proguard.sourceforge.net/

十二:努力成为某个行业或者领域骨干


面对漫长的职业生涯,要想不被淘汰,必须具备一招鲜吃遍天下的能力,选择自己感兴趣的

方向,努力而深入的研究,计算机技术发展到今天已经细分很细,努力研究一种Java开源

框架或者开源HTTP服务器源码或者研究过网络爬虫源码或者WEBKIT内核,不愁没有人要

你。如果你是非常了解金融,企业ERP,证券,保险,移动应用行业的应用开发业务的人,

一样不用愁工作。这些知识不随语言而改变,努力做一个有核心竞争力的Java程序员。

十三:提高语言与书面表达能力,掌握基础的项目管理知识



文档与语言表达能力是最好的向外界展现自己能力的方式,很多程序员编程能力很高,表达

能力一般,Linux能够成功,除了归功于网络社区的力量之外,也得益于Linux作者本人给各

大基金会写信,宣传推广,试想如果没有良好的书面语言表达能力,即使Linux系统再优秀,

却无法被准确表达,失去各大基金会的支持,Linux还会像今天这么好的局面嘛。所以重视

文档,重视提升沟通与表达能力,才有可能成为Java系统程序员。掌握基本的2/8原则,学

会将模块细化分配给不同的人,预见并控制项目风险,把握项目进度,优化流程,合理的时

间管理,了解TDD,熟悉敏捷开发模式,常规软件开发模式。

十四:掌握英语,良好的读写能力


英语是计算机的母语,掌握好英语对于阅读英文资料学习新技术大有帮助,我的建议是尽量

读英文原版书,如果是算法方面的可能会困难一点,但是其它像设计模式,软件工程,OO

编程思想等尽量读原版,提高自己的英文水平,多多访问开发者,code project,程序员天堂,

Pc-magazine等英文IT网站。英语绝对是你必须修炼与提高的技能。此外英语好在外资企业

尤其重要,只有外语足够好才可能在外资企业中突破职业瓶颈,向上发展。Java学习如何才能成为高手之Java系统程序员修炼之道转载于 jsp555.iteye。c0m/bl0g/1562685 转载请注明!!!

期末考试试题-快速排序与输入年份输出星期数Java程序备份

import java.util.Scanner;

public class swap {

public static int dealLength;

static int[] dealArrayInt;

/*

* 我在写程序时候发现需要有两个全局变量,所以不假思索就添加上了

* 编写完后想看看能不能不用全局

* 可惜,没有发现不用全局能做出来的方法

* 下面是主函数

*/

public static void main(String[]args){

Scanner scan = new Scanner(System.in); 

String dealing = scan.next();  //输入dealing 待处理内容

char[] dealArray = dealing.toCharArray();

dealLength = dealing.length();

int dealBegin = 0;

int dealEnd = dealLength – 1;

int[] dealArrayInt = new int[dealLength];

//各种变量设置……都是临时加上去的,发现变量不够

for(int i=0;i <dealLength;i++){

dealArrayInt[i] =dealArray[i];

}

quickSort(dealArrayInt,dealBegin,dealEnd);

for(int i = dealLength – 1;i >= 0; i –)

        {

dealArray[i] =(char) dealArrayInt[i];

            System.out.print(dealArray[i]);

            System.out.print(" ");

        }

}

/*

* 上面是主函数

* 下面通通为我们的快速排序算法Java实现

*/

public static void quickSort( int[] dealArray , int begin , int end ){ 

if(begin < end){ 

int Position = Partition(dealArray,begin,end); 

quickSort( dealArray , begin , Position – 1); 

quickSort( dealArray , Position + 1 , end ); 

        } 

}

private static int Partition( int[] dealArray , int begin , int end ){

int transit = dealArray[begin];

while(begin < end){ 

while(end > begin && compare( transit , dealArray[end] ) <= 0 ){

end — ; 

dealArray[begin] = dealArray[end] ; 

while(begin < end && compare( transit , dealArray[begin] ) >= 0){ 

begin ++ ; 

dealArray[end] = dealArray[begin]; 

dealArray[begin] = transit ; 

return begin; 

private static int compare(int begin, int end) {

return begin – end ; 

/*

* 快速排序算法结束

*/

}

 

 

 

import java.util.Scanner;  //加入输入包

public class enterdatatime{

    public static void main(String args[]) {
       
        System.out.println("请输入您所要查询的日期格式如:20120608,输入完成后按回车得到结果");  //提示
        System.out.print("您输入的数据为:");
        

        Scanner dt = new Scanner(System.in); 
        String datatime = dt.next();  //输入dt的时间

        String year;
        String moon;
        String day;
        String center;
       
       
        center = datatime.substring(0,2); //截取字符串为center
        year = datatime.substring(2,4);   //截取字符串为year
        moon = datatime.substring(4,6);   //截取字符串为moon
        day = datatime.substring(6,8);    //截取字符串为day
       
        int preweek;  //设置中转变量
        int week;     //设置最终输出变量
        preweek = 5 – Integer.parseInt(center) + Integer.parseInt(year) + Integer.parseInt(year) / 4 + (13*Integer.parseInt(moon + 1) / 5) + Integer.parseInt(day) – 1 + 700;
        /*
        根据蔡勒公式进行运算
        使用Integer.parseInt()进行字符串到整形的转换
        +700避免负数的出现
        **/
        week = preweek%7 + 1;
       
        //System.out.println(Integer.parseInt(year));
       
        System.out.println("您好,您所查询的日期为星期"+week);
       
        }
               
    }

}