總結之java編程常用算法

數組冒泡排序

相鄰兩個數兩兩相比，n[i]跟n[j+1]比，如果n[i]>n[j+1]，則將連個數進行交換，
j++, 重複以上步驟，第一趟結束後，最大數就會被確定在最後一位，這就是冒泡排序又稱大（小）數沉底，
i++,重複以上步驟，直到i=n-1結束，排序完成。
時間複雜度都是O（n2）

 int num[]={34,212,12,25,57,48};

        for(int i=0;i<num.length-1;i++){
            for (int j=0;j<num.length-i-1;j++){
                if(num[j]>num[j+1]){
                    int flag =num[j];
                    num[j]=num[j+1];
                    num[j+1]=flag;
                }
            }
        }
        for(int a : num){
            System.out.println(a);
        }

選擇排序

第一個跟後面的所有數相比，如果小於（或小於）第一個數的時候，暫存較小數的下標，第一趟結束後，將第一個數，與暫存的那個最小數進行交換，第一個數就是最小（或最大的數）
下標移到第二位，第二個數跟後面的所有數相比，一趟下來，確定第二小（或第二大）的數
重複以上步驟
直到指針移到倒數第二位，確定倒數第二小（或倒數第二大）的數，那麼最後一位也就確定了，排序完成。
時間複雜度都是O（n2）
代碼：

public class Sort {
    public static void main(String[] args) {
       int[] array =new int[]{2,5,7,3,1,8} ;
       int[] result =selectionSort(array);
       for(int num:result){
           System.out.println(num);
       }
    }
    public static int[] selectionSort(int[] array){
        int minIndex ,temp;//minIndex最小值索引
        for(int i=0;i<array.length-1;i++){
            minIndex=i;
            for(int j=i+1;j<array.length;j++){
                if(array[j] <array[minIndex]){
                    minIndex=j;
                }
            }
            temp =array[i];
            array[i] =array[minIndex];
            array[minIndex]=temp;
        }
        return array;
    }
}

一個數組中，只有一個數字出現一次，其他數字都出現兩次，請編程找出這個數字。

  int array[] ={1,1,2,2,3,3,4,5,5};
        System.out.println(getionenum(array));

自己寫的方法（全部數字的總和-兩次出現數字的總和*2）

public static int getionenum(int[] array){
     int total=0;
        int total2 =0;
        for(int i=0;i<array.length;i++){
           total=total+array[i];
        }
        for(int j=0;j<array.length;j++){
        //j後面的數字和j比
            for(int k=j+1;k<array.length;k++){
                if(array[k]==array[j]){
                    total2=total2+array[k];
                    System.out.println(total2);
                }
            }
        }
        return  total-total2*2;
        }

高玩解法:利於異或運算

public static int getionenum(int[] array){
  int resualt=0;
        for(int i=0;i<array.length;i++)
        {
        	//resualt^=array[i];
            resualt= resualt^array[i];
        }
        return resualt;

解釋：resualt =0^array[1] ^array[2] … ^array[i]

同一個數字異或兩遍相當於沒有異或
異或運算可交換
0 ^1=1 ; 1 ^1 =0
最終結果:resualt =0 ^4= 4

JavaScript實現倒計時功能

<div id="div">
    
</div>
<script>
    function  resetTime(time) {
        var timer=null;
        var t=time;
        var m=0;
        var s=0;
        m=Math.floor(t/60%60);
        m<10&&(m='0'+m);
        s=Math.floor(t%60);
        function countDown(){
            s--;
            s<10&&(s='0'+s);
            if(s.length>=3){s=59;
                m=m-1;
            }
            if(m.length>=3){
                m='00';
                s='00';
                clearInterval(timer);
            }
            var div =document.getElementById("div");
            div.innerHTML=m+"分鐘"+s+"秒";
        }
        timer=setInterval(countDown,1000);
    }
    resetTime(2353);
</script>

//String數組轉int數組

public static int[] StringToInt(String[] arrs){

        int[] ints = new int[arrs.length];

        for(int i=0;i<arrs.length;i++){

            ints[i] = Integer.parseInt(arrs[i]);

        }

        return ints;

    }

//String 字符串拆分 1:11,2:11,

 String  goods=request.getParameter("goods");
        String [ ] line=goods.split(",");
        for(String str:line) {
            System.out.println(str);
            String [ ] line2=str.split(":");
            for (String s:line2){
                System.out.println(s);
            }
        }

儘量均分


   public static int[] matchExpert2(int total,int count){
        int anArray[] =  new int[count];
        if(total % count == 0){
            int recordExpert = total / count;

            for(int expertNum:anArray){
                expertNum = recordExpert;
                System.out.println(expertNum);
            }
        }else {
            int recordCount1 = (total / count)+1;
            int n=0;//n表示組中記錄數爲recordCount1的最大專家數.
            int m=recordCount1*n;
            while (((total-m) % (count -n )) !=0){


                n++;
                m=recordCount1*n;
                anArray[n-1] = recordCount1;
                System.out.println(recordCount1);
            }
            int recordCount2 = (total - m) /(count-n);

            for (int i=n;i <count;i++){
                anArray[i] = recordCount2;
                System.out.println(recordCount2);
            }
            //將前n個組的記錄數設爲recordCount1.
            //將n+1個至後面所有組的記錄數設爲recordCount2.
        }
        System.out.println(Arrays.toString(anArray));
        return  anArray;
    }

儘量均分（不能均分時，整除平均值上浮動1或2）

public int[] matchExpert(int total,int count){
        int anArray[] =  new int[count];
        if(total % count == 0){//均分
            int recordExpert = total / count;
            for(int i=0;i<anArray.length;i++){
                anArray[i] = recordExpert;
            }
        }else {
            Random ra = new Random();
           int temp =ra.nextInt(2)+1;//隨機1或2
           int recordCount1 = (total / count)+temp;//專家數
           int n=0;//n表示組中記錄數爲recordCount1的最大專家數.
           int m=0;
           while (((total-m) % (count -n )) !=0){
               if((total-m) % (count -n ) == 1){//如果只剩下一個，就分配一個
                   recordCount1 = (total / count)+1;//專家數
               }else {
                   temp = ra.nextInt(2) + 1;//隨機1或2
                   recordCount1 = (total / count) + temp;//專家數
               }
               n++;
               m=m+recordCount1;
               anArray[n-1] = recordCount1;
           }
           int recordCount2 = (total - m) /(count-n);
            for (int i=n;i <count;i++){
                anArray[i] = recordCount2;
            }
            //將前n個組的記錄數設爲recordCount1.
          //將n+1個至後面所有組的記錄數設爲recordCount2.
        }
        randomArr(anArray);
      return  anArray;
    }

數組打散（隨機）


    public static void randomArr(int[] num) {
        Random random = new Random();
        int index;
        for (int i = (num.length - 1); i >= 0; i--) {
            index = random.nextInt(num.length);
            int temp = num[i];
            num[i] = num[index];
            num[index] = temp;
        }
        System.out.println(Arrays.toString(num));
    }

統計重複的字母如xxyyyyyzzz變成2x4y3z （面試題）

public class StringTo {
    public static void main(String[] args) {
        String str = "xxyyyyvzzzddduuuuuui";//輸入字符

        String result = stringToSomeString(str);

        System.out.println(result);
    }

    public static String stringToSomeString(String str){
        String[] strArr = str.split("");
        String result = "";//結果
        String now = "";//當前字符
        String temp = "";//之前字符
        int sum = 1;//字符統計數
        for(int i= 0;i<strArr.length;i++){
            now = strArr[i];
            if(i==0){
                temp = strArr[i];
                continue;
            }
            //當字符爲最後一個字符是，字符必須輸出
            if(i==strArr.length-1){
                //當前字符和之前字符相等
                if(now.equals(temp)){
                    sum +=1;
                }

                if(sum == 1){
                    //之前字符出現1次
                    result += temp;
                }else{
                    //之前字符出現sum次
                    result += String.valueOf(sum)+temp;
                    sum = 1;
                }
                //不相等 輸出最後一個字符
                if(now.equals(temp)){
                }else{
                    result += now;
                }



            }else{//當字符不是最後一個字符，字符如果重複不輸出，統計加一
                //當前字符和之前字符相等
                if(now.equals(temp)){
                    sum +=1;
                }else{
                    if(sum == 1){
                        //之前字符出現1次
                        result += temp;
                    }else{
                        //之前字符出現sum次
                        result += String.valueOf(sum)+temp;
                        sum = 1;
                    }
                    temp = now;

                }
            }

        }
        return result;
    }
}

關於代碼的執行順序

以下代碼輸出結果爲多少

public class testReal {
    public static void main(String[] args) {
        A ab =new B();
        B abc=new B();
    }
}

class A{
    static {
        System.out.println("1");
    }
    public A(){
        System.out.println("2");
    }
}

class B extends  A{
    static {
        System.out.println("A");
    }
    public B(){
        System.out.println("B");
    }
}

正確結果：

1
A
2
B
2
B

改成下面也一樣

  A ab =new B();
  A abc=new B();

  B ab =new B();
  B abc=new B();

知識點：

1.1、一個類中的初始化順序
類內容（靜態變量、靜態初始化塊） => 實例內容（變量、初始化塊、構造器）

1.2、兩個具有繼承關係類的初始化順序
父類的（靜態變量、靜態初始化塊）=> 子類的（靜態變量、靜態初始化塊）=> 父類的（變量、初始化塊、構造器）=> 子類的（變量、初始化塊、構造器）
1.3 靜態變量和靜態初始化快，只執行一次

總結之java編程常用算法

數組冒泡排序

選擇排序

一個數組中，只有一個數字出現一次，其他數字都出現兩次，請編程找出這個數字。

JavaScript實現倒計時功能

儘量均分

儘量均分（不能均分時，整除平均值上浮動1或2）

數組打散（隨機）

統計重複的字母如xxyyyyyzzz變成2x4y3z （面試題）

關於代碼的執行順序

知識點：

Window 安裝 Python 失敗 0x80070643，發生嚴重錯誤

總結之數據導出到word模板——使用poi導出

2020年已經過了一半，記錄韶華（空貼）

總結之三級或以上指標多變報表編碼設計

總結之JVM調優（三）——Tomcat優化及代碼優化

面試題之JAVA航空母艦——你看我會造航母

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

總結之java編程常用算法

數組冒泡排序

選擇排序

一個數組中，只有一個數字出現一次，其他數字都出現兩次，請編程找出這個數字。

JavaScript實現倒計時功能

儘量均分

儘量均分（不能均分時，整除平均值上浮動1或2）

數組打散（隨機）

統計重複的字母 如xxyyyyyzzz變成2x4y3z （面試題）

關於代碼的執行順序

知識點：

統計重複的字母如xxyyyyyzzz變成2x4y3z （面試題）