精华内容
下载资源
问答
  • 精选代码面试题

    2018-11-09 13:55:02
    大家好,下面是我总结的某个公司的面试题,希望对最近找工作的年轻人们有帮助 1,变量的引用传值 $a='1'; $b=&$a; $b="2$b"; echo $a.",".$b; 大家可以自己敲一下试试,正确输出...

    大家好,下面是我总结的某个公司的面试题,希望对最近找工作的年轻人们有帮助

    1,变量的引用传值

    $a='1';
    $b=&$a;
    $b="2$b";
    echo $a.",".$b;

    大家可以自己敲一下试试,正确输出结果是21,21

    2,逻辑判断+字符串处理

    if(false != ($offset= strpos('zhangjia','zhang'))){
        var_dump($offset);
    }else{
        var_dump('not in');
    }
    
    
    if(false != ($offset = strpos('zhang','zhangjia'))){
        var_dump($offset);
    }else{
        var_dump('not in');
    }

    答案是两个都是not in

    3,常用的字符串和数组的处理

    $iniput='1,2,3,4,a,r,7,9';   问如何得到里面整数的总和

    答案:

    $input='1,2,3,4,a,r,7,9';
    $input=trim($input,',');
    $a=explode(',',$input);
    for($i=0;$i<count($a);$i++){
    	$a[$i]=(int)($a[$i]);
    }
    echo array_sum($a);

    4,封装一个函数,判断一个数组是不是多维数组

    if (count($array) == count($array, 1)) {
        echo '是一维数组';
    } else {
        echo '不是一维数组';
    }

    注意:count的第二个参数是递归底计算多维数组中的数组的元素个数,比如

    echo '不统计多维数组:'.count($arr,0);//count($arr,COUNT_NORMAL)
    echo "<br/>";
    echo '统计多维数组:'.count($arr,1);//count($arr,COUNT_RECURSIVE)

    5,考察数组下标

    $a=['a'];
    $a[2]='b';
    $a[]='c';
    $a['1']='d';
    print_r($a);
    foreach($a as $k=>$v){
    	echo $v.",";
    }
    echo "\n";
    for($i=0;$i<count($a);$i++){
    	echo $a[$i].'+';
    }

    结果:Array ( [0] => a [2] => b [3] => c [1] => d ) a,b,c,d, a+d+b+c+

    6,php如何在文件中追加写入

    答案:file_put_contents("文件名称",'文件内容',FILE_APPEND);

    7,考察递归+类的静态属性

    下面程序输出什么

    function test(){
        static $count=0;
        $count++;
        echo $count;
        if($count < 5){
            test();
        }
    }

    答案:12345

    8,请设计一个类实现下面的接口

    interface zhuge{
        const TYPE="二手";
        function input();
        function output();
    }

    答案自己想

    9,解释explain select * from db_ad_page 的结果

    结果是

    id:select的查询序列号

    select_type:是select的类型,有以下几种

         SIMPLE:简单SELECT(不使用UNION或子查询等)

         PRIMARY:最外面的SELECT

         UNION:UNION中的第二个或后面的SELECT语句

         DEPENDENT UNION:UNION中的第二个或后面的SELECT语句,取决于外面的查询

         UNION RESULT:UNION的结果。

         SUBQUERY:子查询中的第一个SELECT

         DEPENDENT SUBQUERY:子查询中的第一个SELECT,取决于外面的查询

         DERIVED:导出表的SELECT(FROM子句的子查询)

    table:显示这一行的数据是哪个表里的

    type:   显示连接使用了哪些类别,有无使用索引,

    结果从好到坏的的依次是system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL

    possible_keys:指列出mysql能使用哪个索引在该表中找到行

    key:显示mysql实际决定使用的键或索引,如果没有索引,则是null

    key_len:显示mysql决定使用的键长度

    ref:

    rows:显示mysql认为他查询是必须检查的行数

     

    展开全文
  • 代码面试题

    2017-03-15 15:50:10
    http://www.zuidaima.com/blog/3287724708793344.htm
    http://www.zuidaima.com/blog/3287724708793344.htm
    
    展开全文
  • java常见代码面试题

    千次阅读 2017-12-22 02:01:24
    按 Ctrl+C 复制代码 冒泡排序的优点:每进行一趟排序,就会少比较一次,因为每进行一趟排序都会找出一个较大值。如上例:第一趟比较之后,排在最后的一个数一定是最大的一个数,第二趟排序的时候,只需要...

    一、Java中的经典算法之冒泡排序(Bubble Sort)

     

    原理:比较两个相邻的元素,将值大的元素交换至右端。

    思路:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。重复第一趟步骤,直至全部排序完成。

    举例说明:要排序数组:int[] arr={6,3,8,2,9,1};   

    第一趟排序:

        第一次排序:63比较,6大于3,交换位置:  3  6  8  2  9  1

        第二次排序:68比较,6小于8,不交换位置:3  6  8  2  9  1

        第三次排序:82比较,8大于2,交换位置:  3  6  2  8  9  1

        第四次排序:89比较,8小于9,不交换位置:3  6  2  8  9  1

        第五次排序:91比较:9大于1,交换位置:  3  6  2  8  1  9

        第一趟总共进行了5次比较, 排序结果:      3  6  2  8  1  9

    ---------------------------------------------------------------------

    第二趟排序:

        第一次排序:36比较,3小于6,不交换位置:3  6  2  8  1  9

        第二次排序:62比较,6大于2,交换位置:  3  2  6  8  1  9

        第三次排序:68比较,6大于8,不交换位置:3  2  6  8  1  9

        第四次排序:81比较,8大于1,交换位置:  3  2  6  1  8  9

        第二趟总共进行了4次比较, 排序结果:      3  2  6  1  8  9

    ---------------------------------------------------------------------

    第三趟排序:

        第一次排序:32比较,3大于2,交换位置:  2  3  6  1  8  9

        第二次排序:36比较,3小于6,不交换位置:2  3  6  1  8  9

        第三次排序:61比较,6大于1,交换位置:  2  3  1  6  8  9

        第二趟总共进行了3次比较, 排序结果:         2  3  1  6  8  9

    ---------------------------------------------------------------------

    第四趟排序:

        第一次排序:23比较,2小于3,不交换位置:2  3  1  6  8  9

        第二次排序:31比较,3大于1,交换位置:  2  1  3  6  8  9

        第二趟总共进行了2次比较, 排序结果:        2  1  3  6  8  9

    ---------------------------------------------------------------------

    第五趟排序:

        第一次排序:21比较,2大于1,交换位置:  1  2  3  6  8  9

        第二趟总共进行了1次比较, 排序结果:  1  2  3  6  8  9

    ---------------------------------------------------------------------

    最终结果:1  2  3  6  8  9

    ---------------------------------------------------------------------

    由此可见:N个数字要排序完成,总共进行N-1趟排序,每i趟的排序次数为(N-i)次,所以可以用双重循环语句,外层控制循环多少趟,内层控制每一趟的循环次数,即

    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码

    冒泡排序的优点:每进行一趟排序,就会少比较一次,因为每进行一趟排序都会找出一个较大值。如上例:第一趟比较之后,排在最后的一个数一定是最大的一个数,第二趟排序的时候,只需要比较除了最后一个数以外的其他的数,同样也能找出一个最大的数排在参与第二趟比较的数后面,第三趟比较的时候,只需要比较除了最后两个数以外的其他的数,以此类推……也就是说,没进行一趟比较,每一趟少比较一次,一定程度上减少了算法的量。

    用时间复杂度来说:

      1.如果我们的数据正序,只需要走一趟即可完成排序。所需的比较次数和记录移动次数均达到最小值,即:Cmin=n-1;Mmin=0;所以,冒泡排序最好的时间复杂度为O(n)。

      2.如果很不幸我们的数据是反序的,则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:冒泡排序的最坏时间复杂度为:O(n2) 。

    综上所述:冒泡排序总的平均时间复杂度为:O(n2) 。

    代码实现:

     

    复制代码
    /*
     * 冒泡排序
     */
    public class BubbleSort {
      public static void main(String[] args) {
        int[] arr={6,3,8,2,9,1};
        System.out.println("排序前数组为:");
        for(int num:arr){
          System.out.print(num+" ");
        }
        for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
          for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
            if(arr[j]>arr[j+1]){
              int temp=arr[j];
              arr[j]=arr[j+1];
              arr[j+1]=temp;
            }
          }
        } 
        System.out.println();
        System.out.println("排序后的数组为:");
         for(int num:arr){
           System.out.print(num+" ");
         } 
      }
     }
    复制代码

     

    五、性能分析:

    若记录序列的初始状态为"正序",则冒泡排序过程只需进行一趟排序,在排序过程中只需进行n-1次比较,且不移动记录;反之,若记录序列的初始状态为"逆序",则需进行n(n-1)/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。

    六、算法优化:

    冒泡排序法存在的不足及改进方法:
    第一,在排序过程中,执行完最后的排序后,虽然数据已全部排序完备,但程序无法判断是否完成排序,为了解决这一不足,可设置一个标志位flag,将其初始值设置为非0,表示被排序的表是一个无序的表,每一次排序开始前设置flag值为0,在进行数据交换时,修改flag为非0。在新一轮排序开始时,检查此标志,若此标志为0,表示上一次没有做过交换数据,则结束排序;否则进行排序;

    复制代码
    package 冒泡排序;
    import java.util.Arrays;
    /**
     * 冒泡排序改进版
     * @author mmz
     *
     */
    public class BubbleSort1 {
        public static void BubbleSort(int[] arr) {
            boolean flag = true;
            while(flag){
                int temp;//定义一个临时变量
                for(int i=0;i<arr.length-1;i++){//冒泡趟数,n-1趟
                    for(int j=0;j<arr.length-i-1;j++){
                        if(arr[j+1]<arr[j]){
                            temp = arr[j];
                            arr[j] = arr[j+1];
                            arr[j+1] = temp;
                            flag = true;
                        }
                    }
                    if(!flag){
                        break;//若果没有发生交换,则退出循环
                    }
                }
            }
        }
        public static void main(String[] args) {
            int arr[] = new int[]{1,6,2,2,5};
            BubbleSort.BubbleSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }
    复制代码

      第二、在冒泡排序中,一趟扫描有可能无数据交换,也有可能有一次或多次数据交换,在传统的冒泡排序算法及近年来的一些改进的算法中,只记录一趟扫描有无数据交换的信息,对数据交换发生的位置信息则不予处理。为了充分利用这一信息,可以在一趟全局扫描中,对每一反序数据对进行局部冒泡排序处理,称之为局部冒泡排序。局部冒泡排序与冒泡排序算法具有相同的时间复杂度,并且在正序和逆序的情况下,所需的关键字的比较次数和移动次数完全相同。由于局部冒泡排序和冒泡排序的数据移动次数总是相同的,而局部冒泡排序所需关键字的比较次数常少于冒泡排序,这意味着局部冒泡排序很可能在平均比较次数上对冒泡排序有所改进,当比较次数较少的优点不足以抵消其程序复杂度所带来的额外开销,而当数据量较大时,局部冒泡排序的时间性能则明显优于冒泡排序。对于N个无序数据,我们在进行一趟冒泡排序时,如果第k个数据和第k+1个数据逆序,那么对第k+1个数据进行一趟向前的冒泡排序,使其移动到合适的位置,也就是说让前面k+1个数据调节为正序。因为这种冒泡法只对前k+1个数据冒泡处理,所以我们称它为——局部冒泡


    二。java去重复字符串

      
    /**
         * @方法一:先把字符串通过空拆分为数组,再利用list集合的contains方法去数组重复项添加数组项
         * @param str
         * @return
         */
    	public static String strDuprRem(String str){
    		String[] strArr =str.split("");
    		
    		if (strArr.length == 0 ) {
                	    return null; 
           				List<String> list = new ArrayList<String>(); 
    		StringBuffer sb = new StringBuffer();
    		for(int i=0;i < strArr.length;i++){
    			if(!list.contains(strArr[i])){
    				list.add(strArr[i]);
    				sb.append(strArr[i]+"");
    			}
    		}		
    		return sb.toString().substring(0, sb.toString().lastIndexOf(""));		
    	}
    	
    	 /**
         * @方法二:先把字符串通过字符串的toCharArray变为字符数组,
         * 再利用循环刻录字符数组每一项内容,利用循环比较刻录的每一项内容与数组每一项内容比较,相等就把内容置空,最后去处空格
         * @param str
         * @return
         */
    	public static String strDuprRem2(String str){
    		char[] charArr =str.toCharArray();
    		if(charArr==null){
    			return str;
    		}
    		if (charArr.length < 2 ) {
              	   return str; 
           		 }
    		//双层循环把字符数组重复项置空
    		for(int i=0;i<charArr.length;i++){
    			char tmp =charArr[i];
    			if(tmp!=' '){
    				for(int j=i+1;j<charArr.length;j++){
    					if(tmp==charArr[j]){
    						charArr[j]=' ';
    					}	
    				}
    			}
    		}
    		//字符数组去空
    		StringBuffer sb = new StringBuffer();
    		for(int t=0;t<charArr.length;t++){
    			if(charArr[t]!=' '){
    				sb.append(charArr[t]);
    			}		
    		}
    		
    		return sb.toString();		
    	}
    	
    	/**
         * @方法三:先把字符串通过字符串的toCharArray变为字符数组,
         * 再利用循环把字符数组每一项添加到set集合,由于set集合内容不允许重复从而到达去重的目的,
         * 添加进集合的时候要做空格判断空格项不能添加进集合,遍历set集合用StringBuffer转为字符串,
         * 但是set集合是无序,看到结果第三种内容顺序跟第一种不一样,要是有顺序要求此种方法不可用
         * @param str
         * @return
         */
    	public static String strDuprRem3(String str){
    		char[] charArr =str.toCharArray();
    		if(charArr==null){
    			return str;
    		}
    		if (charArr.length < 2 ) {
                		 return str; 
           		 }
    		
    		Set<String> hash =new HashSet<String>();
    		//字符数组循环添加进set集合
    		for(int i=0;i<charArr.length;i++){
    			if(charArr[i]!=' '){    //字符数组去空并添加到set集合
    				hash.add(String.valueOf(charArr[i]));
    			}
    		}
    //		//set集合遍历转为字符串
    		StringBuffer sb = new StringBuffer();
    		for(String laststr:hash){
    			sb.append(laststr);
    		}
    		return sb.toString();		
    	}
    
    
    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    
    

    写了两个去重复的方法,可以自己打印以下效率:

        public static void main(String[] args) {
    		StrWeiLoss strloss=new StrWeiLoss();
    		String chatStr1= strloss.strDuprRem("1    2 392   3   9   3  3  334scc  ccccccdcddddjdcjjjjjjjjf");
    		String chatStr2= strloss.strDuprRem2("1    2 392   3   9   3  3  334scc  ccccccdcddddjdcjjjjjjjjf");
    		String chatStr3= strloss.strDuprRem3("1    2 392   3   9   3  3  334scc  ccccccdcddddjdcjjjjjjjjf");
    		System.out.println("第一个方法结果"+chatStr1);
    		System.out.println("第二个方法结果"+chatStr2);
    		System.out.println("第二个方法结果"+chatStr3);		
    	}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12


    对比结果是,第一个方法要比第二个方法效率高


    三。java实现字符串反转

    1.最简单的方法,jdk提供的reverse()方法
    public static String reverse1(String str)
    {
       return new StringBuffer(str).reverse().toString();

    }

    利用StringBuffer的对象


    [java] view plain copy
    1. import java.util.*;  
    2. public class Main{  
    3.     public static void main(String[] args){  
    4.         Scanner in =new Scanner(System.in);  
    5.         while(in.hasNext()){  
    6.             String line=in.nextLine();//next()是遇到空格;nextLine()是遇到回车  
    7.             StringBuffer sb=new StringBuffer(line);  
    8.             sb.reverse();  
    9.               
    10.             System.out.println(sb.toString());  
    11.         }  
    12.     }  
    13. }  


    2.最常用的方法:
    public static String reverse3(String s)
     { 
       char[] array = s.toCharArray(); //将string类型参数转化为char[]类型参数
       String reverse = "";  //注意这是空串,不是null
       for (int i = array.length - 1; i >= 0; i--) 
       reverse += array[i]; 
       return reverse; 
      } 


    3.常用方法的变形:
    public static String reverse2(String s)

      int length = s.length(); 
      String reverse = "";  //注意这是空串,不是null
      for (int i = 0; i < length; i++) 
      reverse = s.charAt(i) + reverse;//在字符串前面连接,  而非常见的后面
      return reverse; 


    4.C语言中常用的方法:
     public static String reverse5(String orig)

      char[] s = orig.toCharArray(); 
      int n = s.length - 1; 
      int halfLength = n / 2; 
      for (int i = 0; i <= halfLength; i++) { 
        char temp = s[i]; 
        s[i] = s[n - i]; 
        s[n - i] = temp; 
      } 
      return new String(s);  //知道  char数组和String相互转化

    5、用栈实现String反转
    public String reverseByStack(){
    if(str ==null|| str.length() == 1){
    return null;
    }
    Stack<Character> stack = new Stack<Character>();
    char[] ch = str.toCharArray();//字符串转换成字符数组
    for (char c : ch) {
    stack.push(c);//每个字符,推进栈
    }
    for (int i = 0; i < ch.length; i++) {
    ch[i] = stack.pop();//移除这个堆栈的顶部对象
    }
    return new String(ch);
    }

    四。java数组去重
    总结了四种方法,接下来进行展示

    1、方法一

    [java] view plain copy
    1. //数组去重方法一  
    2. String[] array = {"a","b","c","c","d","e","e","e","a"};  
    3. List<String> result = new ArrayList<>();  
    4. boolean flag;  
    5. for(int i=0;i<array.length;i++){  
    6.     flag = false;  
    7.     for(int j=0;j<result.size();j++){  
    8.         if(array[i].equals(result.get(j))){  
    9.             flag = true;  
    10.             break;  
    11.         }  
    12.     }  
    13.     if(!flag){  
    14.         result.add(array[i]);  
    15.     }  
    16. }  
    17. String[] arrayResult = (String[]) result.toArray(new String[result.size()]);  
    18. System.out.println(Arrays.toString(arrayResult));  
    先遍历原数组,然后遍历结束集,通过每个数组的元素和结果集中的元素进行比对,若相同则break。若不相同,则存入结果集。
    两层循环进行遍历得出最终结果。

    2、方法二

    [java] view plain copy
    1. //数组去重方法二  
    2. String[] array = {"a","b","c","c","d","e","e","e","a"};  
    3. List<String> list = new ArrayList<>();  
    4. list.add(array[0]);  
    5. for(int i=1;i<array.length;i++){  
    6.     if(list.toString().indexOf(array[i]) == -1){  
    7.             list.add(array[i]);  
    8.     }  
    9. }  
    10. String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
    11. System.out.println(Arrays.toString(arrayResult));  
    通过使用indexOf方法进行判断结果集中是否存在了数组元素。

    3、方法三

    [java] view plain copy
    1. //数组去重方法三  
    2. String[] array = {"a","b","c","c","d","e","e","e","a"};  
    3. List<String> list = new ArrayList<>();  
    4. for(int i=0;i<array.length;i++){  
    5.     for(int j=i+1;j<array.length;j++){  
    6.         if(array[i] == array[j]){  
    7.             j = ++i;  
    8.         }  
    9.     }  
    10.     list.add(array[i]);  
    11. }  
    12. String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
    13. System.out.println(Arrays.toString(arrayResult));  
    嵌套循环,进行比较获取满足条件结果集。

    4、方法四

    [java] view plain copy
    1.         //数组去重方法四  
    2.         String[] array = {"a","b","c","c","d","e","e","e","a"};  
    3.         Arrays.sort(array);  
    4.         List<String> list = new ArrayList<>();  
    5.         list.add(array[0]);  
    6.         for(int i=1;i<array.length;i++){  
    7.             if(!array[i].equals(list.get(list.size()-1))){  
    8.                 list.add(array[i]);  
    9.             }  
    10.         }  
    11. <pre name="code" class="java"><span style="white-space:pre">        </span>String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
    System.out.println(Arrays.toString(arrayResult));
    
    先使用java提供的数组排序方法进行排序,然后进行一层for循环,进行相邻数据的比较即可获得最终结果集。

    5、方法五

    [java] view plain copy
    1. //数组去重方法五  
    2.         String[] array = {"a","b","c","c","d","e","e","e","a"};  
    3.         Set<String> set = new HashSet<>();  
    4.         for(int i=0;i<array.length;i++){  
    5.             set.add(array[i]);  
    6.         }  
    7.         String[] arrayResult = (String[]) set.toArray(new String[set.size()]);  
    8.         System.out.println(Arrays.toString(arrayResult));  

    
    
    
    
    展开全文
  • public int majorityNumber(int[] A){ if (A == null || A.length == 0) { return -1; } int candidate = 0; int count = 0; for (int i = 0; i ; i++) { if

    Given an array of integers, the majority number is the number that occurs more than half of the size of the array. Find it.

    Example

    For [1, 1, 1, 1, 2, 2, 2], return 1

    思路:将不同的元素凑对,剩下的元素则为答案。用到两两抵消的思想。


    public int majorityNumber(int[] A){
        	if (A == null || A.length == 0) {
        		return -1;
        	}
        	
        	int candidate = 0;
        	int count = 0;
        	for (int i = 0; i < A.length; i++) {
        		if (count == 0) {
        			candidate = A[i];
        		}
        		if (candidate == A[i]) {
        			count++;
        		} else count--;
        	}
        	return candidate;
        }


    展开全文
  • 代码面试题:Majority Number III

    千次阅读 2014-09-05 02:56:43
    Given an array of integers and a number k, the majority number is the number that occursmore than 1/k of the size of the array. Find it. Note There is only one majority number in the array. ...
  • 代码面试题:Majority Number II

    千次阅读 2014-09-04 10:08:03
    public int majorityNumber2(int[] A){ if (A == null || A.length == 0) { return -1; } int candidate1 = 0; int candidate2 = 0; int count1 = 0; int count2 = 0;
  • 《微软ASP.NET 电商网站开发实战 MVC6 +HTML5 +WCF+WebAPI+NoSQL+mongoDB+Redis+Core 视频 代码 面试题 》下载网盘:https://yunpan.cn/cP7SNIjgJYYjA 访问密码 7fc6微软特邀讲师 徐雷FrankXuLei 2016 授课 更新:...
  • Insert a integer as a ListNode to a sorted linked list.
  • Given an array with positive and negative integers. Resort the array so that
  • MyBatis面试题(2020最新版)

    万次阅读 多人点赞 2019-09-24 16:40:33
    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家 MyBatis 介绍 MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...
  • 华为OD面试题练习(代码题部分)

    千次阅读 2021-01-19 14:00:39
    华为OD面试题练习(代码题部分) 准备面试华为外包德科,记录一下一些面试题; 华为OD面试大致分为五轮,第一轮基础面试,第二轮机试
  • Flink案例代码面试题

    千次阅读 2019-06-03 17:06:41
    面试题来自微信公众号地址: https://mp.weixin.qq.com/s/RT4YUkUUNVO1mfihPoTVjQ Flink面试题,有时间会解决这些问题: 1、为何我使用 ValueState 保存状态 Job 恢复是状态没恢复? 2、fl...
  • 手撕前端面试代码题

    千次阅读 多人点赞 2020-11-21 13:33:15
    面试通常都有现场写代码的题目,我基本每次都或多或少的翻车.有意思的是,每次面试结束,自己改不到五分钟就调试出来了. 所以面试中的写代码的过程,一定不能紧张,要沉住气慢慢来.只要不是系统自动检查结果,只要是面试...
  • 海康面试代码题

    千次阅读 2018-09-08 21:05:20
    面试过程超级顺利,项目也感兴趣,简历从上到下问了一遍,就在我以为功德圆满之际,面试官突然说:当场你写个代码吧!!写个代码吧...代码吧...,我的内心是....#$%^&amp;*@#$%...,最近几个月每天都是python的...
  • Java面试题大全(2021版)

    万次阅读 多人点赞 2020-11-25 11:55:31
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java基础知识面试题 1、Java概述 ①. 何为编程 ...
  • java静态代码面试题 public class Father { static{ System.out.println(&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;Father___的静态代码块&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp...
  • 这里会不断收集和更新Android基础相关的面试题,目前已收集100题。 1.Android系统的架构 应用程序 Android会同一系列核心应用程序包一起发布,该应用程序包包括Email客户端,SMS短消息程序,日历,地图,浏览器,...
  • 多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。 2、String是最基本的数据类型吗? 基本数据类型包括byte、int、char、long、float、double、boolean和short。 ...
  • 重构从哪些方面(根据简历,复用和代码减半,无效代码。重复代码-工具类。配置简化。单一职责。业务。太老了-有新需求的时候-重写-测试.查询替换,mysql联表) 技术有点老,es,redis等技术都比较常见,没啥特别难的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,003
精华内容 14,001
关键字:

代码面试题