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面试程序题收集)

  • x86-64汇编语言训练程序与实战 十除以十等于一
    本文还有配套的精品资源，点击获取简介：汇编语言是一种低级语言，与机器代码紧密相关，特别适用于编写系统级代码及性能要求高的应用。nasm编译器是针对x86和x86-64架构的汇编语言编译器，支持多种语法风格和指令集。项目Euler提供数学和计算机科学问题，鼓励编程技巧应用，前100个问题的答案可共享。x86-64架构扩展了寄存器数量并引入新指令，提升了数据处理效率。学习汇编语言能够深入理解计算机底层
  • 9、汇编语言编程入门：从环境搭建到简单程序实现 神经网络酱 汇编语言MEPISGNU工具链
    汇编语言编程入门：从环境搭建到简单程序实现1.数据存储介质问题解决在处理数据存储时，若要使用MEPIS系统，需确保有其可访问的存储介质。目前，MEPIS无法向采用NTFS格式（常用于Windows2000和XP工作站）的硬盘写入数据。不过，若硬盘采用FAT32格式，MEPIS就能进行写入操作。此外，MEPIS还能将文件写入软盘和大多数USB闪存驱动器。若工作站连接到局域网，还可通过FTP协议或挂载
  • day15｜前端框架学习和算法 universe_01 前端算法笔记
    T22括号生成先把所有情况都画出来，然后（在满足什么情况下）把不符合条件的删除。T78子集要画树状图，把思路清晰。可以用暴力法、回溯法和DFS做这个题DFS深度搜索：每个边都走完，再回溯应用：二叉树搜索，图搜索回溯算法=DFS+剪枝T200岛屿数量（非常经典BFS宽度把树状转化成队列形式，lambda匿名函数“一次性的小函数，没有名字”setup语法糖：让代码更简洁好写的语法ref创建：基本类型的
  • 力扣热题100-------54. 螺旋矩阵 海航Java之路 力扣leetcode矩阵java
    给你一个m行n列的矩阵matrix，请按照顺时针螺旋顺序，返回矩阵中的所有元素。示例1：输入：matrix=[[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例2：输入：matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]提示：m==matrix.lengthn
  • Linux系统配置（应用程序） 1风天云月 Linuxlinux应用程序编译安装rpmhttp
    目录前言一、应用程序概述1、命令与程序的关系2、程序的组成3、软件包封装类型二、RPM1、RPM概述2、RPM用法三、编译安装1、解包2、配置3、编译4、安装5、启用httpd服务结语前言在Linux中的应用程序被视为将软件包安装到系统中后产生的各种文档，其中包括可执行文件、配置文件、用户手册等内容，这些文档被组织为一个有机的整体，为用户提供特定的功能，因此对于“安装软件包”与“安装应用程序”这两
  • 第28章 汇编语言--- 异常处理 hummhumm 汇编算法开发语言程序设计高级语言异常处理汇编语言
    在汇编语言中，异常处理是一个重要的概念，它涉及到处理器如何响应和处理程序运行时发生的非正常情况。异常可以是硬件错误（例如除零错误、非法指令）或者软件触发的中断（例如系统调用）。当发生异常时，处理器会暂停当前正在执行的程序，并转移到一个预先定义好的位置来处理这个异常。为了详细阐述第28章关于汇编语言中的异常处理，我们可以考虑一个简化的例子，展示异常处理的基本结构。请注意，实际的代码将取决于具体的处理
  • JVM 内存模型深度解析：原子性、可见性与有序性的实现 练习时长两年半的程序员小胡 JVM深度剖析：从面试考点到生产实践jvmjava内存模型
    在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
  • 深入理解汇编语言子程序设计与系统调用 网安spinage 汇编语言开发语言汇编算法
    本文将全面解析汇编语言中子程序设计的核心技术以及系统调用的实现方法，涵盖参数传递的多种方式、堆栈管理、API调用等关键知识点，并提供实际案例演示。一、子程序设计：参数传递的艺术1.寄存器传参：高效简洁.386.modelflat,stdcalloptioncasemap:none.dataxdd5;定义变量ydd6sumdd?.code;函数定义：addxy1addxy1procpushebpmo
  • CodeFoeces-450B ss5smi
    题目原题链接：B.JzzhuandSequences题意根据公式公式计算对应fn的值。参考了其他作者的代码和思路。找循环点。负数取余需要加取余数到>0为止才可取余。代码#includeusingnamespacestd;constintmod=1e9+7;intmain(){longlongf[10],x,y,n;cin>>x>>y>>n;x=(x+mod)%mod;y=(y+mod)%mod;f
  • 图论算法经典题目解析：DFS、BFS与拓扑排序实战 周童學 数据结构与算法深度优先算法图论
    图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
  • Matrix-Breakout 2 Morpheus靶场解题过程
    信息收集目标探测靶机目标很明显就是61.139.2.141了扫描开放端口发现22、80、81访问端口主机访问80翻译一下，并没有发现什么审查源代码发现里面有一张图片，下载下来看看是否有图片的隐写wgethttp://61.139.2.141/trinity.jpegstegoveritas-itrinity.jpeg-o/home/kali/Desktop/11分解后发现什么都没有，里面的keep
  • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
    在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
  • 收集落叶 申文秀
    走啊，一起走，我们一起去收集落叶落叶的模样早已映入我的眼帘耳边已响起叶子落在地上的“沙沙”声走啊，去收集落叶，落叶是我们的回忆落叶的样子如此俏皮心形是写给秋姑娘的情书圆形是秋姑娘送给大地的礼物三角形是秋姑娘礼服上的碎珠片哟！秋姑娘举行的盛装宴会开始了你看！秋之宴会开始了松叶缓缓飘落在空中跳起了华尔兹枫叶跳着芭蕾兜着圈子盘旋而下银杏叶是杂技演员，正“七上八下”地翻跟头每个落叶都在宴会上展示自己最美妙
  • 为了在未来的人工智能世界中取得成功，学生们必须学习人类写作的优点 睿邸管家
    澳大利亚各地的学生在新学年开始使用铅笔、钢笔和键盘学习写字。在工作场所，机器也在学习写作，如此有效，几年之内，它们可能会写得比人类更好。有时它们已经做到了，就像Grammarly这样的应用程序所展示的那样。当然，人类现在的日常写作可能很快就会由具有人工智能(AI)的机器来完成。手机和电子邮件软件常用的预测文本是无数人每天都在使用的一种人工智能写作形式。据AI行业研究机构称，到2022年，人工智能及
  • 02-Breakout靶机攻略 ZLlllllll0 02-Breakout靶机
    第一步搭建靶机下载地址：https://download.vulnhub.com/empire/02-Breakout.zip下载好了之后直接用VM打开然后右击虚拟机，把网络连接改成nat模式第二步，信息收集然后开启虚拟机，左上角编辑，虚拟网络编辑器里面看一下靶机是哪个网段。打开kali用nmap扫一下的这个网段的存活主机，也就是扫除这个靶机的具体ip地址nmap192.168.109.1/24扫
  • uniapp微信小程序 - 详解微信小程序平台用户授权登录全流程，uniapp v3版本中小程序端开发下用户点击登录后获取手机号/昵称/性别/头像等信息完成登录（提供完整示例代码，一键复制开箱即用） 十一猫咪爱养鱼 前端组件与功能(开箱即用)uniapp常见问题解决uniappvue3uniapp3小程序授权登录微信小程序登录获取用户信息教程获取用户昵称手机号头像信息登录vue3版本小程序平台授权登录uniap小程序端用户登录流程uni完整的小程序平台登录源码
    效果图在uniapp微信小程序端开发中，超详细实现用户授权登录完整功能源码，用户授权后获取手机号/昵称/头像/性别等，提供完整思路流程及逻辑讲解。uniappVue3和Vue2都能用，你也可以直接复制粘贴，然后改下参数放到你的项目中去就行。整体思路做功能之前，先来看一下整体流程是
  • C++编程基础与面向对象概念解析 侯昂 面向对象编程C++语法函数类与对象继承与多态性
    C++编程基础与面向对象概念解析背景简介C++是一种广泛使用的面向对象编程语言，它允许开发者创建高效、灵活且功能强大的程序。本文基于《C++Primer》一书的章节内容，深入解析C++的核心概念和面向对象编程原则，旨在帮助读者构建扎实的C++编程基础。面向对象编程的原则软件危机与进化介绍了软件危机的产生和软件进化的必要性，强调了面向对象编程（OOP）在应对这些问题中的优势。面向对象编程范式讨论了面
  • 中原焦点团队 坚持原创分享第 1172天 金JJ
    信阳案例督导：在学生出现危机时，学校启动心理应急程序，一位心理老师安抚个案的同时，其他心理老师给班级同学进行团体心理辅导，学校方面马上通知家长前来学校。学校危机干预应急流程的成熟，能有效降低个案的自杀风险。个案不愿谈及家庭及自己自杀行为等问题时，用沙盘、玩具等分散注意力，谈论他感兴趣的话题，老师温和的态度，关切的言语，个案的情绪逐渐平复。从个案自己说的，流露的非言语，家长、老师、同学、以往的记录，
  • MySQL复习题
    一.填空题1.关系数据库的标准语言是SQL。2.数据库发展的3个阶段中，数据独立性最高的是阶段数据库系统。3.概念模型中的3种基本联系分别是一对一、一对多和多对多。4.MySQL配置文件的文件名是my.ini或my.cnf。5.在MySQL配置文件中，datadir用于指定数据库文件的保存目录。6.添加IFNOTEXISTS可在创建的数据库已存在时防止程序报错。7.MySQL提供的SHOWCREA
  • 民事诉讼后，发现与刑事案件有关联怎么办 邓粤龙
    在一些民事案件中，当事人发起民事诉讼后，经过法院审理，发现该案件和刑事案件还有关联，这时就涉及到交叉案件的处理。民事诉讼的发起人是案件的当事人，而刑事诉讼通常是由检察院提请公诉的，两者并不属于同一程序，那么，民事诉讼后多久到刑事诉讼？下面我们一起看看小编的分析。一、民事诉讼后多久到刑事诉讼？民事诉讼和刑事诉讼性质不同，是独立的。普通民事纠纷适用民事诉讼，构成犯罪则进行刑事诉讼，二者之间一般没有转化
  • 著作权登记申请流程 知识产权宗师猫
    著作权也就是版权登记一般经过下列程序：一、作品登记应提交的材料：1、作品登记申请书（由作品登记机关提供标准格式）；2、作者或其他著作权人的身份证明文件：作者身份证明（复印件，须作者签名）；法人或非法人单位的工商注册登记证明或其他相关证明文件（复印件）；继承人身份证明文件（复印件）；委托作品的委托合同（复印件）；合作作者的合作协议或合同及各合作作者的身份证明（复印件）。3、作品著作权归属证明文件：作
  • 程序员必备：10 个提升代码质量的工具 大力出奇迹985 宠物
    在软件开发过程中，代码质量对项目的成功起着决定性作用。高质量的代码不仅易于维护和扩展，还能有效降低成本并提升可靠性。本文精心挑选了10个程序员必备工具，助力提升代码质量。这些工具涵盖代码格式化、静态分析、代码审查、测试、性能优化、安全扫描、版本控制、依赖管理、代码生成以及文档生成等多个关键领域。通过使用它们，开发者能够高效地发现并解决代码中的潜在问题，遵循最佳实践，提升代码的可读性、可维护性与安全
  • C#中的设计模式：构建更加优雅的代码 Envyᥫᩣᩚ c#开发语言
    C#在面向对象编程（OOP）方面的强大支持，我们可以探讨“C#中的设计模式”。这不仅有助于理解如何更好地组织代码，还能提高代码的可维护性和可扩展性。引言设计模式是软件工程中经过实践验证的解决方案模板，它们提供了一种标准化的方法来解决常见的开发问题。对于使用C#进行开发的程序员来说，理解和应用这些模式可以帮助创建结构良好、易于维护和扩展的应用程序。本文将介绍几种常用的设计模式，并展示如何用C#实现它
  • 前端面试每日 3+1 —— 第39天 浪子神剑
    今天的面试题(2019.05.25)——第39天[html]title与h1、b与strong、i与em的区别分别是什么？[css]写出你知道的CSS水平和垂直居中的方法[js]说说你对模块化的理解[软技能]公钥加密和私钥加密是什么？《论语》，曾子曰：“吾日三省吾身”（我每天多次反省自己）。前端面试每日3+1题，以面试题来驱动学习，每天进步一点！让努力成为一种习惯，让奋斗成为一种享受！欢迎在Iss
  • Jupyter Notebook：数据科学的“瑞士军刀” a小胡哦 机器学习基础人工智能机器学习
    在数据科学的世界里，JupyterNotebook是一个不可或缺的工具，它就像是数据科学家手中的“瑞士军刀”，功能强大且灵活多变。今天，就让我们一起深入了解这个神奇的工具。一、JupyterNotebook是什么？JupyterNotebook是一个开源的Web应用程序，它允许你创建和共享包含实时代码、方程、可视化和解释性文本的文档。它支持多种编程语言，其中Python是最常用的语言之一。Jupy
  • Python 程序设计讲义（26）：字符串的用法——字符的编码 睿思达DBA_WGX Python讲义python开发语言
    Python程序设计讲义（26）：字符串的用法——字符的编码目录Python程序设计讲义（26）：字符串的用法——字符的编码一、字符的编码二、`ASCII`编码三、`Unicode`编码四、使用`ord()`函数查询一个字符对应的`Unicode`编码五、使用`chr()`函数查询一个`Unicode`编码对应的字符六、`Python`字符串的特征一、字符的编码计算机默认只能处理二进制数，而不能处
  • 新手如何通过github pages静态网站托管搭建个人网站和项目站点 vvandre Web技术github
    一、githubpages静态网站托管介绍githubpages它是一个免费快捷的静态网站托管服务。对比传统建站，它有哪些优点呢？在传统方式中，首先要租用服务器，服务器上需要运行外部程序，还需要再购买域名，要配置SSL证书，最后还要配置DNS，将域名解析到服务器。这一套繁琐操作，基本上就把小白劝退了。graphTDA[租用服务器]-->B[部署Web应用(运行外部程序，如Nginx)]B-->C[
  • 《底线》这两个案子背后的真相 青瑶说
    《底线》这部剧在给我们普及司法程序，法律界限的同时，也用一些生活中曾经真实发生过的案例来向我们展示了现在普遍存在的社会问题和生活问题。最近的两个案子是和孩子有关，看他们的故事，自省。01唐啸云案唐啸云在母亲的五十岁生日的那天和母亲还有亲戚一起吃了一顿饭。饭桌上他还劝表弟要听父母的话。回到家就用自己的奖杯砸死了自己的母亲，然后分尸然后放进冰柜。然后就开启了自我放纵时光，带着失足女到处旅游。唐啸云的母
  • 《天才在左，疯子在右——心理疾病漫谈》|你焦虑了嘛？ 霞姝儿
    《天才在左，疯子在右——心理疾病漫谈》这本书的作者是宁安宁，2015年12月在哈尔冰出版社出版。ISBN：9787548423676.我花了5个小时40分钟看完的。这本书中很多关于行为和心理活动情况的分析与案例解析都很透彻。书中针对每个心理障碍都会有是非题供你来测试，有解析心理障碍出现的原因，有问题的症状表现形式的阐述，有类似问题的案例解析，还有解决方案的描写。看完之后，你可以对自己心理上及行为上
  • 安装器处点击“打开” 钦_79f7
    问题描述：安装系统SD卡里面的apk或者原有的程序更新版本或者通过ADB安装apk的时候，会遇到升级安装成功之后的一个选择——“打开”和“完成”，点击完成没有问题，但是，如果点击了"打开"，然后按Home键，从应用程序列表里面选择应用程序图标进入或者点击桌面启动图标，这个时候就会重新启动了一个应用程序，之后的操作就会出现混乱等问题。原因分析：参考底部相关资料链接解决方案：在launcherActi
  • 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其他