`
scholers
  • 浏览: 620441 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

一道JAVA面试题

面试JavaJ#算法 
阅读更多

   题目：一列整型数组，从第一个开始，累加后续两个数字，得到一个新的数组，然后判断新的数组中的最大值，从而得到这个最大值是原始数组中哪三个数字累加的，输出（打印）这三个数字，并且输出（打印）出这个最大值。

   如:2,5,-6,12,7,15,6,-10

  结果应该是输出：12,7,15

   最大值： 34

 

 

 我的思路1：

  1.先统计处累加的数组，数组长度是原始数组长度-2

  2.计算新数组的最大值

  3.根据最大值的位置输出原始数组的三个数字

  4。输出最大值

 

 思路2（如果可以打乱原始数组的次序)：

  1。先冒泡排序一次，从小到大排序

  2。计算最后三个数字的值，得到结果

 

 

 

 

分享到：
| 美剧LOST--《迷失》
评论
35 楼 dreamtalee 2010-10-22   
public class Lianxi1
{
	public static void main(String[]args)
	{
		int[] sample = {2,5,-6,12,7,15,6,-10};
		int[] sample1= {15,8,12,13,5,17};
		result(sample1);
		result(sample);
	}
	public static void result(int[] old)
	{
		int index[]=new int[5];
		int max = 0;
		int j = 0;
		for(int i = 0; i<old.length-2; i++)
		{
			if(old[i]+old[i+1]+old[i+2]>max)
			{
				max = old[i]+old[i+1]+old[i+2];
				index[j] = i;
			}else if(old[i]+old[i+1]+old[i+2]==max)
			{
				j++;
				index[j] = i;
			}
			
		}
		System.out.println("max="+max);
		for(int k = 0;k<=j;k++)
		System.out.println(old[index[k]]+","+old[index[k]+1]+","+old[index[k]+2]);
	}
}

sample1= {15,8,12,13,5,17};
这种情况两组都打印
34 楼 scholers 2010-10-22  
lxs575208196 写道
我怎么看不懂题目的意思啊 、？  什么叫累加啊？  累加后怎么办。。。。


累加后形成一个新的数组，然后找出新数组的最大值，然后得到下标，算出新数组是原始数组中哪三个值计算出来的
33 楼 lxs575208196 2010-10-22  
我怎么看不懂题目的意思啊 、？  什么叫累加啊？  累加后怎么办。。。。
32 楼 scholers 2010-10-22  
marshaldong 写道
public static void main(String[] args)
{
int[] num = new int[] { 2, 5, -6, 12, 7, 15, 6, -10 };
int length = num.length;
ArrayList newArray = new ArrayList();

int i = 0;
for (; i < length - 2; i++)
{
newArray.add(num[i] + num[i + 1] + num[i + 2]);

}
int max = (Integer) Collections.max(newArray);
int index = newArray.indexOf(max);
System.out.println(max + "=" + num[index] + "+" + num[index + 1] + "+" + num[index + 2]);

}



这位兄弟对JAVA的基类很精通啊，这个方法最简单了，估计代码量最少
31 楼 marshaldong 2010-10-21  
public static void main(String[] args)
{
int[] num = new int[] { 2, 5, -6, 12, 7, 15, 6, -10 };
int length = num.length;
ArrayList newArray = new ArrayList();

int i = 0;
for (; i < length - 2; i++)
{
newArray.add(num[i] + num[i + 1] + num[i + 2]);

}
int max = (Integer) Collections.max(newArray);
int index = newArray.indexOf(max);
System.out.println(max + "=" + num[index] + "+" + num[index + 1] + "+" + num[index + 2]);

}
30 楼 luobin23628 2010-10-21  
tq02ksu 写道
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...

经测试。效率和楼上一样。
29 楼 luobin23628 2010-10-21  
tq02ksu 写道
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...

28 楼 luobin23628 2010-10-21  
tq02ksu 写道
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...

确实是一个好算法，不过程序有点小问题
更正一下 
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = {2, 5, -6, 12, 7, 15, 6, -10, 16 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
 			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = 0;
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}
27 楼 scholers 2010-10-21  
raito_yagami 写道
悲哀啊，题没看懂，还好我没遇到



别悲哀，大家关注的角度不一样，产生的结果就不一样了。
26 楼 raito_yagami 2010-10-20  
悲哀啊，题没看懂，还好我没遇到
25 楼 scx0237 2010-10-20  

public static void main(String[] args) {
int[] array={2,5,-6,12,7,15,6,-10};
int max=0;
Map map=new HashMap();
for (int i = 0; i < (array.length-3)+1; i++) {
if(i==0 ){
max=array[i]+array[i+1]+array[i+2];
}
if(max<array[i]+array[i+1]+array[i+2]){
max=array[i]+array[i+1]+array[i+2];
map.put("index", i);
map.put("value", max);
}
}
/**
* 最大的值  和 开始累加的数的下标。
*/
System.out.println(map);
}


错了 不要骂我  只是交流
24 楼 renwolang521 2010-10-20  
tq02ksu 写道
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...

你拿{2, 5, -6, 12, 7, 15, 6, -10, 16}这个数组试下 看你的程序对不？
23 楼 dxjaccp 2010-10-20  
public static void main(String[] args){
int[] arr = new int[]{2,5,-6,12,7,15,6,-10};
int max = 0;//记录最大值
int number = 0 ;//记录下标
for(int i = 0;i<arr.length-2;i++){
int result = arr[i]+arr[i+1]+arr[i+2];
if(result>max){
max = result;
number = i;
}
}
System.out.println("最大值为："+max+"三个数字分别为："+arr[number]+","+arr[number+1]+","+arr[number+2]);
}
22 楼 dxjaccp 2010-10-20  
public static void main(String[] args){
[b]int[] arr = new int[]{2,5,-6,12,7,15,6,-10};
int max = 0;//记录最大值
int number = 0 ;//记录下标
for(int i = 0;i<arr.length-2;i++){
int result = arr[i]+arr[i+1]+arr[i+2];
if(result>max){
max = result;
number = i;
}
}[/b] System.out.println("最大值为："+max+"三个数字分别为："+arr[number]+","+arr[number+1]+","+arr[number+2]);
}
21 楼 jwd001 2010-10-19  
lyw985 写道
感觉这题变简单了，
以前的题目是一列整型数组，找出最大的连续和值和起始下标
例子：4，-7，6，-10，-3，3，2 答案为：6，下标是2(以0开始)

从下标0开始累积和，找出最大的累积和（变量si）及下标（i），以及最小的累积和（sj）及下标j。如果i>j，那么从j+1到i的那段就是最大连续和（si-sj）；如果i<j, 则比较si与sn(全部和)-sj的大小，如果更大，则从0至i那段最大，否则j～n那段最大。

20 楼 scholers 2010-10-19  
<div class="quote_title">笑我痴狂 写道</div>
<div class="quote_div">
<div class="quote_title">scholers 写道</div>
<div class="quote_div">
<div class="quote_title">Kisses99 写道</div>
<div class="quote_div">
<div class="quote_title">scholers 写道</div>
<div class="quote_div">
<p>   题目：一列整型数组，从第一个开始，累加后续两个数字，得到一个新的数组，然后判断新的数组中的最大值，从而得到这个最大值是原始数组中哪三个数字累加的，输出（打印）这三个数字，并且输出（打印）出这个最大值。</p>
<p><span style="font-size: 14.4px;">   如:2,5,-6,12,7,15,6,-10</span></p>
<p><span style="font-size: 14.4px;">  结果应该是输出：</span><span style="font-size: 14.4px;">12,7,15</span></p>
<p><span style="font-size: 14.4px;">   最大值： 34</span></p>
<p> </p>
<p> </p>
<p> 我的思路1：</p>
<p>  1.先统计处累加的数组，数组长度是原始数组长度-2</p>
<p>  2.计算新数组的最大值</p>
<p>  3.根据最大值的位置输出原始数组的三个数字</p>
<p>  4。输出最大值</p>
<p> </p>
<p> 思路2（如果可以打乱原始数组的次序)：</p>
<p>  1。先冒泡排序一次，从小到大排序</p>
<p>  2。计算最后三个数字的值，得到结果</p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
</div>
<p>思路2不符合题意。</p>
</div>
<p> </p>
<p>  后来想了一下，思路2确实不符合题意</p>
</div>
<div class="quote_div">这样的面试题相信大家都做的出来</div>
<p> </p>
<p> </p>
<p> 恩，这里确实高手很多！</p>
</div>
<p> </p>
19 楼 笑我痴狂 2010-10-19  
<div class="quote_title">scholers 写道</div>
<div class="quote_div">
<div class="quote_title">Kisses99 写道</div>
<div class="quote_div">
<div class="quote_title">scholers 写道</div>
<div class="quote_div">
<p>   题目：一列整型数组，从第一个开始，累加后续两个数字，得到一个新的数组，然后判断新的数组中的最大值，从而得到这个最大值是原始数组中哪三个数字累加的，输出（打印）这三个数字，并且输出（打印）出这个最大值。</p>
<p><span style="font-size: 14.4px;">   如:2,5,-6,12,7,15,6,-10</span></p>
<p><span style="font-size: 14.4px;">  结果应该是输出：</span><span style="font-size: 14.4px;">12,7,15</span></p>
<p><span style="font-size: 14.4px;">   最大值： 34</span></p>
<p> </p>
<p> </p>
<p> 我的思路1：</p>
<p>  1.先统计处累加的数组，数组长度是原始数组长度-2</p>
<p>  2.计算新数组的最大值</p>
<p>  3.根据最大值的位置输出原始数组的三个数字</p>
<p>  4。输出最大值</p>
<p> </p>
<p> 思路2（如果可以打乱原始数组的次序)：</p>
<p>  1。先冒泡排序一次，从小到大排序</p>
<p>  2。计算最后三个数字的值，得到结果</p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
</div>
<p>思路2不符合题意。</p>
</div>
<p> </p>
<p>  后来想了一下，思路2确实不符合题意</p>
</div>
<div class="quote_div">这样的面试题相信大家都做的出来</div>
<p> </p>
18 楼 randi0624 2010-10-19  
tq02ksu 写道
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...

一看思想就比我考虑得好，，顶了、、、
17 楼 dingherry 2010-10-19  
1.用数组记录的方式，不如用MAP优。
2.若存在最大值是多个的情况，打印所有的数组对还是第一次出现的那组数据？
16 楼 tq02ksu 2010-10-19  
我想到一个更简单一点的方法.

启发就是比较连续2组数的时候只需要比较有差别的那2个. 比如:

数据下标 0 1 2 和 1 2 3 比较的时候只需要比较 下标0 和下标3 的大小即可. 这样比较的次数是原来的1/3.

具体实现如下: 
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 2, 5, -6, 12, 7, 15, 6, -10, 38 };
		Test.find(arr);
	}

	public static void find(int[] data) {
		/**
		 * make sure the length of data more than or equal 5;
		 */
		if (data.length <= 5)
			return;
		
		/**
		 * difference between current comparing data subscript
		 *     and max subscript of data
		 */
		int diff = 0;
		
		/**
		 * index of max subscript of data, can also be
		 *    a array to record max combinations.
		 */
		int maxIdx = 0;

		for (int i = 1; i < data.length - 2; i++) {
			
			int bigger = data[i - 1] - data[i + 2];
			
			if (diff + bigger > 0) {
				
				diff += bigger;
				
			} else {
				maxIdx = i;
				diff = data[i - 1] - data[i + 2];
			}
		}

		System.out.println("maxIndex : " + maxIdx + ", data : " + data[maxIdx]
				+ ", " + data[maxIdx + 1] + ", " + data[maxIdx + 2] + ". ");
	}
}


benchmark了一下. 确实要比楼上的那个实现快一点.
100000次. 这个是1515ms,
         楼上的实现是2406ms.

不过还没有达到3倍的效果...
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    原创一道Java笔试面试题考考大家

    根据提供的文件信息，我们可以分析出这是一道关于Java继承与方法重写的相关笔试面试题。题目涉及到了Java类的继承、方法重写、实例化对象时的调用顺序以及对象多态性等知识点。接下来，我们将对这些知识点进行详细的...

    一道java面试题 行列转换

    ### Java面试题：行列转换详解 #### 一、问题背景 在进行数据分析或者报表处理时，经常需要将数据从一种格式转换成另一种格式以便更好地展示或分析。其中一种常见的转换需求是从行转列（即行列转换）。本篇文章将...

    每天60秒，搞定一道JAVA面试题.zip

    【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..

    Java 面试题 Java 面试题

    根据给定的文件内容，我们可以总结出一系列与Java面试相关的知识点。下面将详细解析每一道题目涉及的关键概念。 ### 第一部分：基础知识 #### 1. final, finally, finalize的区别 - **final**: 用于声明变量、方法...

    阿里软件JAVA笔试题

    "阿里软件JAVA笔试题" 阿里软件JAVA笔试题是阿里巴巴公司为招聘软件开发工程师所设计的一份笔试题目，涵盖了JAVA语言、数据结构、算法、设计模式、数据库等多方面的知识点。 本题目共有15道题目，涵盖了以下几个...

    android和java面试大全集

    史上最全的android和java面试文档集。包括有： java程序员面试宝典.txt Java面试宝典2011版-1C,Java基础部分.doc... Java面试题及答案（基础题122道） - 在梦想与现实之间徘徊 - JavaEye技术网站.mht 等等，还有好多。

    Java高级面试题汇总及答案（2022年Java面试题及答案大全）

    这是一道经典的Java面试题。解决这个问题需要了解Java的内存管理机制，包括FULL GC的触发条件、Perm Gen的设置、System.gc()方法的调用等。 Java集合框架 3. Java集合框架是Java语言中的一种重要概念，它提供了...

    百家大公司java笔试题

    "100家大公司Java笔试题汇总.doc"这份文档提供了丰富的实践材料，建议考生们深入研究每一道题，不仅要找出正确答案，还要理解背后的原理，这样才能在真正的笔试中游刃有余，成功叩开心仪企业的门扉。同时，通过反复...

    企业公司软件测试面试笔试题集合 软件测试面试题

    企业公司软件测试面试笔试题集合 软件测试面试题 （测试基础）.doc 01_企业面试试卷（综合）.doc 01_企业面试试卷（综合）_参考答案.doc 04_企业面试试卷（测试基础）.doc 04_企业面试试卷（测试基础）_参考答案.doc...

    常见的Java上机面试题

    ### 常见的Java上机面试题：深入解析与实战指南 在IT行业的求职过程中，尤其是对于软件工程师或开发者而言，上机编程面试成为了一道必经的门槛。这种形式的面试旨在全面评估应聘者的技术能力，不仅考察理论知识的...

    java的一些面试题

    Java面试题涵盖了许多核心知识点，包括基础技术、项目经验、逻辑推理和SQL查询。下面将对这些方面进行详细的解析。 1. **基础技术题** - **UML图**：UML（统一建模语言）有多种图表，包括类图、对象图、用例图、...

    史上最难的一道Java面试题

    Java面试中的这道题目主要考察的是并发...总结来说，这道Java面试题主要测试了对`synchronized`关键字的理解，包括其作用、用法以及在并发环境中的内存可见性。理解这些概念对于编写正确且安全的多线程代码至关重要。

    java面试题-leetcode题解之第31题下一个排列.zip

    "java面试题_leetcode题解之第31题下一个排列" 的描述进一步确认了这是关于Java面试中的一道算法题目的解答，主要关注如何找到一个排列的下一个排列。在面试中，这样的问题通常用来评估候选人在处理数组操作和算法...

    Java程序员面试必备知识点，包括面试笔试题，简历模板，简历制作等

    java程序员求职之前看这一套就够了。包括Java程序员阿里面经等，java求职必备知识点，简历模板，JAVA核心知识点整理，蓝桥杯java历年真题及答案整理(共129道题目及答案)，Java面试突击-V3.0

    JAVA面试题大全

    JAVA面试题选择原则 - **筛选标准**：为了提高复习效率，本面试题集筛选掉了那些过时或者出现频率极低的问题，确保每一道题目都有实际的价值。 - **回答策略**：建议的答题方法包括三个方面：首先阐述基础知识，...

    java笔试题大集合及答案（另附各大公司笔试题）

    Java笔试题大集合是针对Java开发者进行技术面试和求职准备的重要资源，涵盖了广泛的知识点，旨在测试应聘者的编程基础、算法理解、数据结构、多线程、网络、数据库以及Java特性的掌握程度。这个大礼包通常包含不同...

    java截取字符串程序，一道面试题。答案

    java截取字符串，一道面试题。好像没有找到正确答案，今天找时间做了一个，仅供参考。本人运行过了。

Magicbox
Global site tag (gtag.js) - Google Analytics