xuyuxin8145
xuyuxin8145

java面试程序题收集

 

java面试程序题收集

Java 面试 J# 算法

1.写一个方法，用一个for循环打印九九乘法表

Java代码 复制代码
  1. /**  
  2.   * 打印九九乘法口诀表  
  3.   */  
  4.  public void nineNineMulitTable(){   
  5.      for (int i = 1,j = 1; j <= 9; i++) {    
  6.            System.out.print(i+"*"+j+"="+i*j+" ");    
  7.            if(i==j){    
  8.                i=0;    
  9.                j++;    
  10.                System.out.println();    
  11.            }    
  12.        }    
  13.  }  
/** * 打印九九乘法口诀表 */ public void nineNineMulitTable(){ for (int i = 1,j = 1; j <= 9; i++) { System.out.print(i+"*"+j+"="+i*j+" "); if(i==j){ i=0; j++; System.out.println(); } } }

2.给定一个java.util.Date对象，如何转化为”2007-3-22 20:23:22”格式的字符串

Java代码 复制代码
  1. /**   
  2.   * 将某个日期以固定格式转化成字符串   
  3.   * @param date   
  4.  * @return str   
  5.  */    
  6.  public String date2FormatStr(Date date)   
  7.  {    
  8.    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    
  9.    String str = sdf.format(date);    
  10.    return str;    
  11.  }  
/** * 将某个日期以固定格式转化成字符串 * @param date * @return str */ public String date2FormatStr(Date date) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String str = sdf.format(date); return str; }

3.写一个方法，能够判断任意一个整数是否素数

Java代码 复制代码
  1. /**    
  2.  * 判断任意一个整数是否素数    
  3.  * @param num    
  4.  * @return boolean  
  5. */     
  6. public boolean isPrimeNumber(int num) {     
  7.   for (int i = 2; i <= Math.sqrt(num); i++) {     
  8.     if(num%i==0){     
  9.       return false;     
  10.     }     
  11.   }     
  12.   return true;     
  13. }  
/** * 判断任意一个整数是否素数 * @param num * @return boolean */ public boolean isPrimeNumber(int num) { for (int i = 2; i <= Math.sqrt(num); i++) { if(num%i==0){ return false; } } return true; }

4.写一个方法，输入任意一个整数，返回它的阶乘

Java代码 复制代码
  1. /**   
  2.   *获得任意一个整数的阶乘   
  3.   *@param n   
  4.   *@returnn!   
  5.   */    
  6.   public int factorial(int num)    
  7.   {    
  8.     //递归    
  9.     if(num == 1)    
  10.     {    
  11.         return 1;    
  12.     }    
  13.     return num*factorial(num-1);   
  14.   }  
/** *获得任意一个整数的阶乘 *@param n *@returnn! */ public int factorial(int num) { //递归 if(num == 1) { return 1; } return num*factorial(num-1); }

5.写一个方法，用二分查找法判断任意整数(已排序)在任意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1

Java代码 复制代码
  1. /**   
  2.  *二分查找特定整数在整型数组中的位置(递归)   
  3.  *@param dataset   
  4.  *@param data   
  5.  *@param beginIndex   
  6.  *@param endIndex   
  7.  *@return index   
  8.  */    
  9.  public int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){    
  10.    int midIndex = (beginIndex+endIndex)/2;    
  11.    //如果查找的数要比开始索引的数据要小或者是比结束索引的书要大，或者开始查找的索引值大于结束的索引值返回-1没有查到   
  12.    if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){   
  13.        return -1;   
  14.    }   
  15.    if(data <dataset[midIndex]){     
  16.        return binarySearch(dataset,data,beginIndex,midIndex-1);    
  17.    }else if(data>dataset[midIndex])    
  18.    {    
  19.        return binarySearch(dataset,data,midIndex+1,endIndex);    
  20.    }else {    
  21.        return midIndex;    
  22.    }    
  23.  }    
  24.     
  25.  /**   
  26.   *二分查找特定整数在整型数组中的位置(非递归)   
  27.   *@param dataset   
  28.   *@param data   
  29.   *@return index   
  30.   */    
  31.   public int binarySearch(int[] dataset ,int data)    
  32.   {    
  33.     int beginIndex = 0;     
  34.     int endIndex = dataset.length - 1;     
  35.     int midIndex = -1;    
  36.     if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){   
  37.         return -1;    
  38.     }   
  39.     while(beginIndex <= endIndex) {    
  40.         midIndex = (beginIndex+endIndex)/2;    
  41.         if(data <dataset[midIndex]) {     
  42.            endIndex = midIndex-1;     
  43.         } else if(data>dataset[midIndex]) {     
  44.           beginIndex = midIndex+1;     
  45.         }else {    
  46.           return midIndex;    
  47.         }    
  48.     }    
  49.     return -1;    
  50.   }  
/** *二分查找特定整数在整型数组中的位置(递归) *@param dataset *@param data *@param beginIndex *@param endIndex *@return index */ public int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){ int midIndex = (beginIndex+endIndex)/2; //如果查找的数要比开始索引的数据要小或者是比结束索引的书要大，或者开始查找的索引值大于结束的索引值返回-1没有查到 if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){ return -1; } if(data <dataset[midIndex]){ return binarySearch(dataset,data,beginIndex,midIndex-1); }else if(data>dataset[midIndex]) { return binarySearch(dataset,data,midIndex+1,endIndex); }else { return midIndex; } } /** *二分查找特定整数在整型数组中的位置(非递归) *@param dataset *@param data *@return index */ public int binarySearch(int[] dataset ,int data) { int beginIndex = 0; int endIndex = dataset.length - 1; int midIndex = -1; if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){ return -1; } while(beginIndex <= endIndex) { midIndex = (beginIndex+endIndex)/2; if(data <dataset[midIndex]) { endIndex = midIndex-1; } else if(data>dataset[midIndex]) { beginIndex = midIndex+1; }else { return midIndex; } } return -1; }

6.java排序汇总

Java代码 复制代码
  1. package com.softeem.jbs.lesson4;    
  2.      
  3. import java.util.Random;       
  4.      
  5. /**    
  6.    
  7.  * 排序测试类    
  8.    
  9.  *     
  10.    
  11.  * 排序算法的分类如下：    
  12.    
  13.  * 1.插入排序（直接插入排序、折半插入排序、希尔排序）；    
  14.    
  15.  * 2.交换排序（冒泡泡排序、快速排序）；    
  16.    
  17.  * 3.选择排序（直接选择排序、堆排序）；    
  18.    
  19.  * 4.归并排序；    
  20.    
  21.  * 5.基数排序。    
  22.    
  23.  *     
  24.    
  25.  * 关于排序方法的选择：    
  26.    
  27.  * (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。    
  28.    
  29.  * 　当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。    
  30.    
  31.  * (2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；    
  32.    
  33.  * (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。    
  34.    
  35.  *     
  36.    
  37.  */     
  38.      
  39. public class SortTest {      
  40.      
  41.        
  42.      
  43.        /**    
  44.    
  45.         * 初始化测试数组的方法    
  46.    
  47.         * @return 一个初始化好的数组    
  48.    
  49.         */     
  50.      
  51.        public int[] createArray() {      
  52.      
  53.               Random random = new Random();      
  54.      
  55.               int[] array = new int[10];      
  56.      
  57.               for (int i = 0; i < 10; i++) {      
  58.      
  59.                      array[i] = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减，保证生成的数中有负数      
  60.      
  61.               }      
  62.      
  63.               System.out.println("==========原始序列==========");      
  64.      
  65.               printArray(array);      
  66.      
  67.               return array;      
  68.      
  69.        }      
  70.      
  71.        
  72.      
  73.        /**    
  74.    
  75.         * 打印数组中的元素到控制台    
  76.    
  77.         * @param source    
  78.    
  79.         */     
  80.      
  81.        public void printArray(int[] data) {      
  82.      
  83.               for (int i : data) {      
  84.      
  85.                      System.out.print(i + " ");      
  86.      
  87.               }      
  88.      
  89.               System.out.println();      
  90.      
  91.        }      
  92.      
  93.        
  94.      
  95.        /**    
  96.    
  97.         * 交换数组中指定的两元素的位置    
  98.    
  99.         * @param data    
  100.    
  101.         * @param x    
  102.    
  103.         * @param y    
  104.    
  105.         */     
  106.      
  107.        private void swap(int[] data, int x, int y) {      
  108.      
  109.               int temp = data[x];      
  110.      
  111.               data[x] = data[y];      
  112.      
  113.               data[y] = temp;      
  114.      
  115.        }      
  116.      
  117.        
  118.      
  119.        /**    
  120.    
  121.         * 冒泡排序----交换排序的一种    
  122.    
  123.         * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。     
  124.    
  125.         * 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4    
  126.    
  127.         *     
  128.    
  129.         * @param data 要排序的数组    
  130.    
  131.         * @param sortType 排序类型    
  132.    
  133.         * @return    
  134.    
  135.         */     
  136.      
  137.        public void bubbleSort(int[] data, String sortType) {      
  138.      
  139.               if (sortType.equals("asc")) { //正排序，从小排到大      
  140.      
  141.                      //比较的轮数      
  142.      
  143.                      for (int i = 1; i < data.length; i++) {      
  144.      
  145.                             //将相邻两个数进行比较，较大的数往后冒泡      
  146.      
  147.                             for (int j = 0; j < data.length - i; j++) {      
  148.      
  149.                                    if (data[j] > data[j + 1]) {      
  150.      
  151.                                           //交换相邻两个数      
  152.      
  153.                                           swap(data, j, j + 1);      
  154.      
  155.                                    }      
  156.      
  157.                             }      
  158.      
  159.                      }      
  160.      
  161.               } else if (sortType.equals("desc")) { //倒排序，从大排到小      
  162.      
  163.                      //比较的轮数      
  164.      
  165.                      for (int i = 1; i < data.length; i++) {      
  166.      
  167.                             //将相邻两个数进行比较，较大的数往后冒泡      
  168.      
  169.                             for (int j = 0; j < data.length - i; j++) {      
  170.      
  171.                                    if (data[j] < data[j + 1]) {      
  172.      
  173.                                           //交换相邻两个数      
  174.      
  175.                                           swap(data, j, j + 1);      
  176.      
  177.                                    }      
  178.      
  179.                             }      
  180.      
  181.                      }      
  182.      
  183.               } else {      
  184.      
  185.                      System.out.println("您输入的排序类型错误！");      
  186.      
  187.               }      
  188.      
  189.               printArray(data);//输出冒泡排序后的数组值      
  190.      
  191.        }      
  192.      
  193.        
  194.      
  195.        /**    
  196.    
  197.         * 直接选择排序法----选择排序的一种    
  198.    
  199.         * 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。    
  200.    
  201.         * 性能：比较次数O(n^2),n^2/2    
  202.    
  203.         *       交换次数O(n),n    
  204.    
  205.         *       交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。    
  206.    
  207.         *       但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。    
  208.    
  209.         *     
  210.    
  211.         * @param data 要排序的数组    
  212.    
  213.         * @param sortType 排序类型    
  214.    
  215.         * @return    
  216.    
  217.         */     
  218.      
  219.        public void selectSort(int[] data, String sortType) {      
  220.      
  221.        
  222.      
  223.               if (sortType.equals("asc")) { //正排序，从小排到大      
  224.      
  225.                      int index;      
  226.      
  227.                      for (int i = 1; i < data.length; i++) {      
  228.      
  229.                             index = 0;      
  230.      
  231.                             for (int j = 1; j <= data.length - i; j++) {      
  232.      
  233.                                    if (data[j] > data[index]) {      
  234.      
  235.                                           index = j;      
  236.      
  237.        
  238.      
  239.                                    }      
  240.      
  241.                             }      
  242.      
  243.                             //交换在位置data.length-i和index(最大值)两个数      
  244.      
  245.                             swap(data, data.length - i, index);      
  246.      
  247.                      }      
  248.      
  249.               } else if (sortType.equals("desc")) { //倒排序，从大排到小      
  250.      
  251.                      int index;      
  252.      
  253.                      for (int i = 1; i < data.length; i++) {      
  254.      
  255.                             index = 0;      
  256.      
  257.                             for (int j = 1; j <= data.length - i; j++) {      
  258.      
  259.                                    if (data[j] < data[index]) {      
  260.      
  261.                                           index = j;      
  262.      
  263.        
  264.      
  265.                                    }      
  266.      
  267.                             }      
  268.      
  269.                             //交换在位置data.length-i和index(最大值)两个数      
  270.      
  271.                             swap(data, data.length - i, index);      
  272.      
  273.                      }      
  274.      
  275.               } else {      
  276.      
  277.                      System.out.println("您输入的排序类型错误！");      
  278.      
  279.               }      
  280.      
  281.               printArray(data);//输出直接选择排序后的数组值      
  282.      
  283.        }      
  284.      
  285.        
  286.      
  287.        /**    
  288.    
  289.         * 插入排序    
  290.    
  291.         * 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。    
  292.    
  293.         * 性能：比较次数O(n^2),n^2/4    
  294.    
  295.         *       复制次数O(n),n^2/4    
  296.    
  297.         *       比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。    
  298.    
  299.         *    
  300.    
  301.         * @param data 要排序的数组    
  302.    
  303.         * @param sortType 排序类型    
  304.    
  305.         */     
  306.      
  307.        public void insertSort(int[] data, String sortType) {      
  308.      
  309.               if (sortType.equals("asc")) { //正排序，从小排到大      
  310.      
  311.                      //比较的轮数      
  312.      
  313.                      for (int i = 1; i < data.length; i++) {      
  314.      
  315.                             //保证前i+1个数排好序      
  316.      
  317.                             for (int j = 0; j < i; j++) {      
  318.      
  319.                                    if (data[j] > data[i]) {      
  320.      
  321.                                           //交换在位置j和i两个数      
  322.      
  323.                                           swap(data, i, j);      
  324.      
  325.                                    }      
  326.      
  327.                             }      
  328.      
  329.                      }      
  330.      
  331.               } else if (sortType.equals("desc")) { //倒排序，从大排到小      
  332.      
  333.                      //比较的轮数      
  334.      
  335.                      for (int i = 1; i < data.length; i++) {      
  336.      
  337.                             //保证前i+1个数排好序      
  338.      
  339.                             for (int j = 0; j < i; j++) {      
  340.      
  341.                                    if (data[j] < data[i]) {      
  342.      
  343.                                           //交换在位置j和i两个数      
  344.      
  345.                                           swap(data, i, j);      
  346.      
  347.                                    }      
  348.      
  349.                             }      
  350.      
  351.                      }      
  352.      
  353.               } else {      
  354.      
  355.                      System.out.println("您输入的排序类型错误！");      
  356.      
  357.               }      
  358.      
  359.               printArray(data);//输出插入排序后的数组值      
  360.      
  361.        }      
  362.      
  363.        
  364.      
  365.        /**    
  366.    
  367.         * 反转数组的方法    
  368.    
  369.         * @param data 源数组    
  370.    
  371.         */     
  372.      
  373.        public void reverse(int[] data) {      
  374.      
  375.        
  376.      
  377.               int length = data.length;      
  378.      
  379.               int temp = 0;//临时变量      
  380.      
  381.        
  382.      
  383.               for (int i = 0; i < length / 2; i++) {      
  384.      
  385.                      temp = data[i];      
  386.      
  387.                      data[i] = data[length - 1 - i];      
  388.      
  389.                      data[length - 1 - i] = temp;      
  390.      
  391.               }      
  392.      
  393.               printArray(data);//输出到转后数组的值      
  394.      
  395.        }      
  396.      
  397.        
  398.      
  399.        /**    
  400.    
  401.         * 快速排序    
  402.    
  403.         * 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。    
  404.    
  405.         * 步骤为：    
  406.    
  407.         * 1. 从数列中挑出一个元素，称为 "基准"（pivot），    
  408.    
  409.         * 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。    
  410.    
  411.         * 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。    
  412.    
  413.         * 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。    
  414.    
  415.         * @param data 待排序的数组    
  416.    
  417.         * @param low    
  418.    
  419.         * @param high    
  420.    
  421.         * @see SortTest#qsort(int[], int, int)    
  422.    
  423.         * @see SortTest#qsort_desc(int[], int, int)    
  424.    
  425.         */     
  426.      
  427.        public void quickSort(int[] data, String sortType) {      
  428.      
  429.               if (sortType.equals("asc")) { //正排序，从小排到大      
  430.      
  431.                      qsort_asc(data, 0, data.length - 1);      
  432.      
  433.               } else if (sortType.equals("desc")) { //倒排序，从大排到小      
  434.      
  435.                      qsort_desc(data, 0, data.length - 1);      
  436.      
  437.               } else {      
  438.      
  439.                      System.out.println("您输入的排序类型错误！");      
  440.      
  441.               }      
  442.      
  443.        }      
  444.      
  445.        
  446.      
  447.        /**    
  448.    
  449.         * 快速排序的具体实现，排正序    
  450.    
  451.         * @param data    
  452.    
  453.         * @param low    
  454.    
  455.         * @param high    
  456.    
  457.         */     
  458.      
  459.        private void qsort_asc(int data[], int low, int high) {      
  460.      
  461.               int i, j, x;      
  462.      
  463.               if (low < high) { //这个条件用来结束递归      
  464.      
  465.                      i = low;      
  466.      
  467.                      j = high;      
  468.      
  469.                      x = data[i];      
  470.      
  471.                      while (i < j) {      
  472.      
  473.                             while (i < j && data[j] > x) {      
  474.      
  475.                                    j--; //从右向左找第一个小于x的数      
  476.      
  477.                             }      
  478.      
  479.                             if (i < j) {      
  480.      
  481.                                    data[i] = data[j];      
  482.      
  483.                                    i++;      
  484.      
  485.                             }      
  486.      
  487.                             while (i < j && data[i] < x) {      
  488.      
  489.                                    i++; //从左向右找第一个大于x的数      
  490.      
  491.                             }      
  492.      
  493.                             if (i < j) {      
  494.      
  495.                                    data[j] = data[i];      
  496.      
  497.                                    j--;      
  498.      
  499.                             }      
  500.      
  501.                      }      
  502.      
  503.                      data[i] = x;      
  504.      
  505.                      qsort_asc(data, low, i - 1);      
  506.      
  507.                      qsort_asc(data, i + 1, high);      
  508.      
  509.               }      
  510.      
  511.        }      
  512.      
  513.        
  514.      
  515.        /**    
  516.    
  517.         * 快速排序的具体实现，排倒序    
  518.    
  519.         * @param data    
  520.    
  521.         * @param low    
  522.    
  523.         * @param high    
  524.    
  525.         */     
  526.      
  527.        private void qsort_desc(int data[], int low, int high) {      
  528.      
  529.               int i, j, x;      
  530.      
  531.               if (low < high) { //这个条件用来结束递归      
  532.      
  533.                      i = low;      
  534.      
  535.                      j = high;      
  536.      
  537.                      x = data[i];      
  538.      
  539.                      while (i < j) {      
  540.      
  541.                             while (i < j && data[j] < x) {      
  542.      
  543.                                    j--; //从右向左找第一个小于x的数      
  544.      
  545.                             }      
  546.      
  547.                             if (i < j) {      
  548.      
  549.                                    data[i] = data[j];      
  550.      
  551.                                    i++;      
  552.      
  553.                             }      
  554.      
  555.                             while (i < j && data[i] > x) {      
  556.      
  557.                                    i++; //从左向右找第一个大于x的数      
  558.      
  559.                             }      
  560.      
  561.                             if (i < j) {      
  562.      
  563.                                    data[j] = data[i];      
  564.      
  565.                                    j--;      
  566.      
  567.                             }      
  568.      
  569.                      }      
  570.      
  571.                      data[i] = x;      
  572.      
  573.                      qsort_desc(data, low, i - 1);      
  574.      
  575.                      qsort_desc(data, i + 1, high);      
  576.      
  577.               }      
  578.      
  579.        }      
  580.      
  581.        
  582.      
  583.        /**    
  584.    
  585.         *二分查找特定整数在整型数组中的位置(递归)    
  586.    
  587.         *查找线性表必须是有序列表    
  588.    
  589.         *@paramdataset    
  590.    
  591.         *@paramdata    
  592.    
  593.         *@parambeginIndex    
  594.    
  595.         *@paramendIndex    
  596.    
  597.         *@returnindex    
  598.    
  599.         */     
  600.      
  601.        public int binarySearch(int[] dataset, int data, int beginIndex,      
  602.      
  603.                      int endIndex) {      
  604.      
  605.               int midIndex = (beginIndex + endIndex) >>> 1; //相当于mid = (low + high) / 2，但是效率会高些      
  606.      
  607.               if (data < dataset[beginIndex] || data > dataset[endIndex]      
  608.      
  609.                             || beginIndex > endIndex)      
  610.      
  611.                      return -1;      
  612.      
  613.               if (data < dataset[midIndex]) {      
  614.      
  615.                      return binarySearch(dataset, data, beginIndex, midIndex - 1);      
  616.      
  617.               } else if (data > dataset[midIndex]) {      
  618.      
  619.                      return binarySearch(dataset, data, midIndex + 1, endIndex);      
  620.      
  621.               } else {      
  622.      
  623.                      return midIndex;      
  624.      
  625.               }      
  626.      
  627.        }      
  628.      
  629.        
  630.      
  631.        /**    
  632.    
  633.         *二分查找特定整数在整型数组中的位置(非递归)    
  634.    
  635.         *查找线性表必须是有序列表    
  636.    
  637.         *@paramdataset    
  638.    
  639.         *@paramdata    
  640.    
  641.         *@returnindex    
  642.    
  643.         */     
  644.      
  645.        public int binarySearch(int[] dataset, int data) {      
  646.      
  647.               int beginIndex = 0;      
  648.      
  649.               int endIndex = dataset.length - 1;      
  650.      
  651.               int midIndex = -1;      
  652.      
  653.               if (data < dataset[beginIndex] || data > dataset[endIndex]      
  654.      
  655.                             || beginIndex > endIndex)      
  656.      
  657.                      return -1;      
  658.      
  659.               while (beginIndex <= endIndex) {      
  660.      
  661.                      midIndex = (beginIndex + endIndex) >>> 1; //相当于midIndex = (beginIndex + endIndex) / 2，但是效率会高些      
  662.      
  663.                      if (data < dataset[midIndex]) {      
  664.      
  665.                             endIndex = midIndex - 1;      
  666.      
  667.                      } else if (data > dataset[midIndex]) {      
  668.      
  669.                             beginIndex = midIndex + 1;      
  670.      
  671.                      } else {      
  672.      
  673.                             return midIndex;      
  674.      
  675.                      }      
  676.      
  677.               }      
  678.      
  679.               return -1;      
  680.      
  681.        }      
  682.      
  683.        
  684.      
  685.        public static void main(String[] args) {      
  686.      
  687.               SortTest sortTest = new SortTest();      
  688.      
  689.        
  690.      
  691.               int[] array = sortTest.createArray();      
  692.      
  693.        
  694.      
  695.               System.out.println("==========冒泡排序后(正序)==========");      
  696.      
  697.               sortTest.bubbleSort(array, "asc");      
  698.      
  699.               System.out.println("==========冒泡排序后(倒序)==========");      
  700.      
  701.               sortTest.bubbleSort(array, "desc");      
  702.      
  703.        
  704.      
  705.               array = sortTest.createArray();      
  706.      
  707.        
  708.      
  709.               System.out.println("==========倒转数组后==========");      
  710.      
  711.               sortTest.reverse(array);      
  712.      
  713.        
  714.      
  715.               array = sortTest.createArray();      
  716.      
  717.        
  718.      
  719.               System.out.println("==========选择排序后(正序)==========");      
  720.      
  721.               sortTest.selectSort(array, "asc");      
  722.      
  723.               System.out.println("==========选择排序后(倒序)==========");      
  724.      
  725.               sortTest.selectSort(array, "desc");      
  726.      
  727.        
  728.      
  729.               array = sortTest.createArray();      
  730.      
  731.        
  732.      
  733.               System.out.println("==========插入排序后(正序)==========");      
  734.      
  735.               sortTest.insertSort(array, "asc");      
  736.      
  737.               System.out.println("==========插入排序后(倒序)==========");      
  738.      
  739.               sortTest.insertSort(array, "desc");      
  740.      
  741.        
  742.      
  743.               array = sortTest.createArray();      
  744.      
  745.               System.out.println("==========快速排序后(正序)==========");      
  746.      
  747.               sortTest.quickSort(array, "asc");      
  748.      
  749.               sortTest.printArray(array);      
  750.      
  751.               System.out.println("==========快速排序后(倒序)==========");      
  752.      
  753.               sortTest.quickSort(array, "desc");      
  754.      
  755.               sortTest.printArray(array);      
  756.      
  757.        
  758.      
  759.               System.out.println("==========数组二分查找==========");      
  760.      
  761.               System.out.println("您要找的数在第" + sortTest.binarySearch(array, 74)      
  762.      
  763.                             + "个位子。（下标从0计算）");      
  764.      
  765.        }      
  766.      
  767. }  

你可能感兴趣的:(java面试程序题收集)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • 每日一题——第八十一题 互联网打工人no1 C语言程序设计每日一练c语言
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 398顺境，逆境 戴骁勇
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • git - Webhook让部署自动化 大猪大猪
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • 第六集如何安装CentOS7.0，3分钟学会centos7安装教程 date分享
    从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 每日一题——第八十八题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：输入一个9位的无符号整数，判断其是否有重复数字#include#include#includeintmain(){charnum_str[10];printf("请输入一个9位数的无符号数：");scanf_s("%9d",&num_str);if(strlen(num_str)!=9){printf("输入的不是一个9位无符号整数，请重新输入");}else{if(hasDuplicate
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 广州会刊小程序开发公司哪家好｜开发多少钱费用｜专业外包服务 红匣子实力推荐
    在选择广州会刊小程序开发公司时，有几个关键因素需要考虑。首先，您应该确定自己的需求和目标，以便找到最合适的开发公司。其次，您需要考虑公司的经验和专业知识。最后，您还应该考虑公司的信誉和口碑。开发-联系电话：13642679953（微信同号）首先，您应该明确自己的需求和目标。会刊小程序是一种用于展示会议信息和日程安排的应用程序。在选择开发公司之前，您应该明确自己的需求，包括功能要求、设计风格和用户体
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • ztree异步加载 3213213333332132 JavaScriptAjaxjsonWebztree
    相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。 我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。 设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
  • thirft rpc 具体调用流程 BlueSkator 中间件rpcthrift
    Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：         （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
  • 异或运算推导, 交换数据 dcj3sjt126com PHP异或^
    /* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
  • 事件源对象 周华华 JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • MySql配置及相关命令 g21121 mysql
            MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。           一 修改MySQL密码及用户      
  • [简单]poi删除excel 2007超链接 53873039oycg Excel
          采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下:      public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
  • Struts2添加 open flash chart 云端月影
    准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
  • spring包详解 aijuans spring
    下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
  • 网站推广之seo概念 antonyup_2006 算法Web应用服务器搜索引擎Google
       持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。     所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。     网站推广策略有很多，seo，email，adv
  • 单例模式,sql注入,序列 百合不是茶 单例模式序列sql注入预编译
      序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面    1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
  • Mockito单元测试实例 bijian1013 单元测试mockito
    Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
  • 精通Oracle10编程SQL(9)使用游标 bijian1013 oracle数据库plsql
    /* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
  • 【Java语言】动态代理 bit1129 java语言
      JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联   package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
  • Java通信之URL通信基础 白糖_ javajdkwebservice网络协议ITeye
    java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。 在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。 学习准备：建议首先学习java的IO基础知识   URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
  • 博弈Java讲义 - Java线程同步 (1) boyitech java多线程同步锁
      在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。    同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
  • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
    public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
  • An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
    今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！ 很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！ 打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
  • [矿业与工业]修建一个空间矿床开采站要多少钱? comsci
           地球上的钛金属矿藏已经接近枯竭...........        我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床.....        那么,现在要编制一个预算,提交给财政部门..
  • 解析Google Map Routes dai_lm google api
    为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
  • SQL还有多少“理所应当”？ datamachine sql
    转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
  • Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajaxyii
    经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
  • 使用git同步网站代码 dcj3sjt126com crontabgit
    转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com   管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
  • sql基本操作 蕃薯耀 sqlsql基本操作sql常用操作
    sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一     &
  • Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
    Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml <dependency> <
  • jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
      在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法     one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为    one(type,${data},fn) &nb
  • 拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
    这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。 这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。 话粗理不粗。 付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
  • 架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
    1.前言。   如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
  • ajax 被缓存的解决方案 Rainbow702 JavaScriptjqueryAjaxcache缓存
    使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。 今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。 解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
  • 修改date.toLocaleString()的警告 tntxia String
      我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下：   package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
  • 项目完成后的小总结 xiaomiya js总结项目
    项目完成了，突然想做个总结但是有点无从下手了。 做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。 先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他