最适合freshman的Java习题集数组

1. 求数组的平均值
2. 数组所有元素之和
3. 改变原有数组元素的值
4. 打印数组
5. 创建的数组&＃xff0c;并且赋初始值
6. 存在连续三个奇数的数组
7. 多数元素
8. 只出现一次的数字
9. 两数之和
10. 冒泡排序
11. 数组是否有序
12. 二分查找
13. 数组的拷贝
14. 数组转字符串

1.求数组的平均值

实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).

public class array
//基于数组的日常练习
public static void main(String[] args)
//求数组的平均值
//实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
int[] arr &＃61; 1,9,3,5,4;
System.out.println(arrAvg(arr));

//先得定义一个数组 遍历数组 求数组长度 求个元素和 然后和/长度&＃61;平均值
public static int arrSum(int[] arr)
int ret &＃61; 0;
for (int i &＃61; 0; i ret &＃43;&＃61; arr[i];

return ret;

public static double arrAvg(int[] arr)
double ret &＃61; 0.0;
double sum &＃61; arrSum(arr);
ret &＃61; sum / arr.length;
return ret;



2.数组所有元素之和

实现一个方法 sum, 以数组为参数, 求数组所有元素之和.

public class array
public static void main(String[] args)
int[] arr &＃61; 1,9,3,5,4;
//2.数组所有元素之和
System.out.println(arrSum(arr));//22

public static int arrSum(int[] arr)
int ret &＃61; 0;
for (int i &＃61; 0; i ret &＃43;&＃61; arr[i];

return ret;



3.改变原有数组元素的值

实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 1, 2, 3, 修改之后为 2, 4, 6

public class array
public static void main(String[] args)
// int[] arr &＃61; new int[3];
// arr[0]&＃61;1;
// arr[1]&＃61;2;
// arr[2]&＃61;3
int[] arr &＃61; 1,2,3;//定义一个数组&＃xff0c;并初始化
int[] ret &＃61; transform(arr);
printArr(arr);
System.out.println();
printArr(ret);

//打印数组元素
private static void printArr(int[] arr)
for (int i : arr) //不改变数组内部元素
System.out.print(i &＃43; " ");


public static int[] transform(int[] arr)
int[] ret &＃61; new int[arr.length] ; //新创建一个数组&＃xff0c;跟原数组等长&＃xff0c;不改变原数组元素
for (int i &＃61; 0; i ret[i] &＃61; arr[i]*2;

return ret;



4.打印数组

实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.

public class array
public static void main(String[] args)
int[] arr &＃61; 1,9,3,5,4;
String ret &＃61; arrPrint(arr);
System.out.print(ret);//[1,9,3,5,4]

// 实现一个方法 printArray, 以数组为参数,
// 循环访问数组中的每个元素, 打印每个元素的值.
public static String arrPrint(int[] arr)
String ret &＃61; "[";
for (int i &＃61; 0; i ret&＃43;&＃61;arr[i];
if (i !&＃61; arr.length-1) // i ret &＃43;&＃61; ",";


ret &＃43;&＃61; "]";
return ret;



 5.创建的数组&＃xff0c;并且赋初始值

创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100

import java.util.Arrays;
public class array
public static void main(String[] args)
int[] a&＃61;new int[100];
setNumber(a);
System.out.println(Arrays.toString(a));

//创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
public static int[] setNumber(int[] arr)
for (int i &＃61; 0; i <100; i&＃43;&＃43;)
arr[i] &＃61; i&＃43;1;

return arr;



6.存在连续三个奇数的数组

给你一个整数数组arr&＃xff0c;请你判断数组中是否存在连续三个元素都是奇数的情况&＃xff1a;如果存在&＃xff0c;请返回 true &＃xff1b;否则&＃xff0c;返回 false 。

示例 1&＃xff1a;输入&＃xff1a;arr &＃61; [2,6,4,1]                         输出&＃xff1a;false

解释&＃xff1a;不存在连续三个元素都是奇数的情况。

示例 2&＃xff1a;输入&＃xff1a;arr &＃61; [1,2,34,3,4,5,7,23,12]     输出&＃xff1a;true

解释&＃xff1a;存在连续三个元素都是奇数的情况&＃xff0c;即 [5,7,23] 。

public class array
public static void main(String[] args)
int[] a1 &＃61; 2,6,4,1;
numOdd(a1);
int[] a2 &＃61;1,2,34,3,4,5,7,23,12;
numOdd(a2);

//6.给你一个整数数组arr&＃xff0c;请你判断数组中是否存在连续三个元素都是奇数的情况&＃xff1a;
// 如果存在&＃xff0c;请返回true&＃xff1b;否则&＃xff0c;返回false。
public static int numOdd(int[] arr)
int count &＃61; 0;
for (int i &＃61; 0; i if(arr[i]%2&＃61;&＃61;1 && arr[i&＃43;1]%2&＃61;&＃61;1 && arr[i&＃43;2]%2&＃61;&＃61;1)
count&＃43;&＃43;;


if (count!&＃61;0)
System.out.println(true);
else
System.out.println(false);

return count;



7.多数元素

给定一个大小为 n 的数组&＃xff0c;找到其中的多数元素。多数元素是指在数组中出现次数 大于 n/2 的元素。你可以假设数组是非空的&＃xff0c;并且给定的数组总是存在多数元素。

示例 1&＃xff1a;  输入&＃xff1a;[3,2,3]                输出&＃xff1a;3

示例 2&＃xff1a; 输入&＃xff1a;[2,2,1,1,1,2,2]     输出&＃xff1a;2

import java.util.Arrays;
public class array
public static void main(String[] args)
System.out.print("arr1的多数元素为&＃xff1a;");
int[] arr1 &＃61; 3,2,3;
System.out.print(searchMost(arr1));
System.out.print("\\narr2的多数元素为&＃xff1a;");
int[] arr2 &＃61; 2,2,1,1,1,2,2;
System.out.print(searchMost(arr2));

//给定一个大小为 n的数组&＃xff0c;找到其中的多数元素。多数元素是指在数组中出现次数
//大于n/2的元素。你可以假设数组是非空的&＃xff0c;并且给定的数组总是存在多数元素。
/**
* 将数组排序&＃xff0c;则中间的那个元素一定是多数元素
* 该代码的时间复杂度为O&＃xff08;NlogN&＃xff09;
* &＃64;param arr 整形数组
* &＃64;return
*/
public static int searchMost(int[] arr)
Arrays.sort(arr); //对数组元素排序
return arr[arr.length/2];



8.只出现一次的数字

给定一个非空整数数组&＃xff0c;除了某个元素只出现一次以外&＃xff0c;其余每个元素均出现两次。找出那个只出现了一次的元素。

&＃xfeff;示例 1:  输入: [2,2,1]              输出: 1

示例 2:  输入: [4,1,2,1,2]        输出: 4

public class array
public static void main(String[] args)
int[] arr1 &＃61; 2,2,1;
System.out.println(searchOne(arr1));
int[] arr2 &＃61; 4,1,2,1,2;
System.out.println(searchOne(arr2));

//8.给定一个非空整数数组&＃xff0c;除了某个元素只出现一次以外&＃xff0c;其余每个元素均
//出现两次。找出那个只出现了一次的元素。
//异或操作 —— 任何数异或0都等于任何数
public static int searchOne(int[] arr)
int temp &＃61; 0;
for (int i &＃61; 0; i temp^&＃61;arr[i];

return temp;



9.两数之和

给定一个整数数组 nums 和一个整数目标值 target&＃xff0c;请你在该数组中找出 和为目标值 target 的那 两个 整数&＃xff0c;并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是&＃xff0c;数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例 &＃xff1a;

输入&＃xff1a;nums &＃61; [2,7,11,15], target &＃61; 9    输出&＃xff1a;[0,1]

解释&＃xff1a;因为 nums[0] &＃43; nums[1] &＃61;&＃61; 9 &＃xff0c;返回 [0, 1] 。

public class array
public static void main(String[] args)
int[] nums &＃61; 2,7,11,15;
searchSum(nums,9);

//9.给定一个整数数组 nums 和一个整数目标值 target&＃xff0c;请你在该数组中找出
// 和为目标值 target的那两个整数&＃xff0c;并返回它们的数组下标。你可以假设每种
// 输入只会对应一个答案。但是&＃xff0c;数组中同一个元素在答案里不能重复出现。你可
// 以按任意顺序返回答案。
// target &＃61; nums[i] &＃43; nums[j] ——>return i , j
public static int searchSum(int[] nums, int target)
for (int i &＃61; 0; i for (int j &＃61; 1; j if (target &＃61;&＃61; nums[i]&＃43;nums[j])
System.out.print("["&＃43;i&＃43;","&＃43;j&＃43;"]");//单纯的控制输出格式



return target;



10.冒泡排序

给定一个整型数组, 实现冒泡排序(升序排序)

public class array
public static void main(String[] args)
//10.冒泡排序 升序排序
//双重循环
int[] arr &＃61; 1, 8, 5, 0, 3, 7, 4;
// 外层循环控制 冒的轮数
for (int i &＃61; 0; i // 内层循环控制相邻两个数&＃xff0c;若前一个数大于后一个数 则交换两数
// PS: j的越界问题
for (int j &＃61; 0; j if (arr[j] > arr[j &＃43; 1])
int temp &＃61; arr[j];
arr[j] &＃61; arr[j&＃43;1];
arr[j&＃43;1] &＃61; temp;



System.out.println("升序排序为&＃xff1a;");
for (int i &＃61; 0; i System.out.print(arr[i]&＃43;" "); //0 1 3 4 5 7 8




 11.数组是否有序

给定一个整型数组, 判定数组是否有序&＃xff08;递增&＃xff09;

public class array
public static void main(String[] args)
int[] arr1 &＃61; 1,2,3,4,5,6,7;
System.out.println(arryJudge(arr1));
int[] arr2 &＃61; 3,6,2,5,1,4;
System.out.print(arryJudge(arr2));

//给定一个整型数组, 判定数组是否有序&＃xff08;递增&＃xff09;
public static boolean arryJudge(int[] arr)
for (int i &＃61; 0; i if (arr[i] > arr[i&＃43;1])
return false;


return true;



12.二分查找

给定一个有序整型数组, 实现二分查找

public class array
public static void main(String[] args)
int[] arr &＃61; 1,3,5,7,9,11,13,17;
System.out.println(searchBinary(arr,2)); //-1
System.out.println(searchBinary(arr,17)); //17

// 12.二分查找
/**
* 有序整型数组, 实现二分查找
* &＃64;param arr
* &＃64;param target 要找的数
* &＃64;return
*/
public static int searchBinary(int[] arr,int target)
int left &＃61; 0;
int right &＃61; arr.length-1;
while(left <&＃61; right)
int middle &＃61; (left&＃43;right)>>1;
if (target &＃61;&＃61; arr[middle])
return arr[middle]; //返回要找的那个数值
else if (target right &＃61; middle-1;
else
left &＃61; middle&＃43;1;


return -1;//未找到



13.数组的拷贝

实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.

import java.util.Arrays;
public class array
public static void main(String[] args)
// 13.
int[] arr &＃61; 3,7,2,4,8;
int[] newarr &＃61; arryCopy(arr);//调用方法arryCopy
System.out.println(Arrays.toString(newarr));//Arrays.toString将数组转换成String类型输出

//13.实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组。
public static int[] arryCopy(int[] arr)
int[] ret &＃61; new int[arr.length];//保持数组大小不变
for (int i &＃61; 0; i ret[i] &＃61; arr[i];

return ret;



14.数组转字符串

实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 1, 2, 3 , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.

public class array
public static void main(String[] args)
int[] arr &＃61; 3,7,2,4,8;
System.out.println(arrToStr(arr));

// 14.实现一个方法 toString, 把一个整型数组转换成字符串.
// 例如数组 1, 2, 3 , 返回的字符串为 "[1, 2, 3]", 注意逗号的位置和数量.
public static String arrToStr(int[] arr)
String ret &＃61; "[";
for (int i &＃61; 0; i ret &＃43;&＃61; arr[i];
if (i ret &＃43;&＃61; ",";


ret &＃43;&＃61; "]";
return ret;



本小节完^_^