一、知识点（必做）:
1. ArrayDemo1.java（重点）
需求：定义数组和数组的静态初始化操作
步骤：
（1）先定义后初始化数组（不能使用简写方式）
（2）定义数组，同时初始化
（3）打印数组长度
（4）数组赋值为空，并演示空指针错误
代码:
public class ArrayDemo1 {
public static void main(String[] args) {
// 需求:定义数组和数组的静态初始化操作
/** 步骤
* 1.先定义初始化数组 (不能使用简写方式)
* 2.定义数组,同时初始化
* 3.打印数组长度
* 4.数组赋值为空,并演示指针错误
*/
// 1.先定义初始化数组 (不能使用简写方式)
int[] arr = new int[]{1, 2, 3, 4}; // 定义数组,同时初始化
// int[] arr = {1,2,3,4,5}; 为了基础牢固,还是写一下简写方式
// 2.打印数组长度
System.out.println(arr.length); // 输出4
// 数组赋值为空,并演示空指针错误
int[] arr1 = null;
System.out.println(arr1.length); // NullPointerException
/** NullPointerException: 空指针异常 (空引用异常)
* 操作了一个尚未初始化或者没有分配内存空间的数组
*/
}
}
输出结果为：
4
Exception in thread "main" java.lang.NullPointerException
at ArrayDemo1.main(ArrayDemo1.java:18)
（5）请在纸上画出以上代码的内存分析图
2. ArrayDemo2.java（重点）
需求：数组的动态初始化和内存分析
步骤：
（1）动态初始化数组，并打印数组长度
（2）重新初始化数组，并打印数组长度
代码：
public class ArrayDemo2 {
public static void main(String[] args) {
// 需求：数组的动态初始化和内存分析
/** 步骤
* 1.动态初始化数组，并打印数组长度
* 2.重新初始化数组，并打印数组长度
*/
// 动态初始化数组
int[] arr = new int[3];
// 打印数组长度
System.out.println(arr.length);
// 重新初始化数组
arr = new int[5];
// 打印数组长度
System.out.println(arr.length);
}
}
执行结果：
3
5
（3）请在纸上画出以上代码的内存分析图
3. ArrayDemo3.java（重点）
需求：数组的基本操作
步骤：
（1）定义一个数组nums,并静态初始化该数组
（2）定义一个变量size获取nums的数组长度
（3）获取数组元素
（4）设置数组元素
（5）遍历数组
public class ArrayDemo3 {
public static void main(String[] args) {
// 需求: 数组的基本操作
/** 步骤
* 1.定义一个数组nums,并静态初始化数组
* 2.定义一个变量size获取nums的数组长度
* 3.获取数组元素
* 4.设置数组元素
* 5.遍历数组
*/
// 定义一个数组nums,并静态初始化数组
int[] nums = new int[]{1, 2, 3, 4};
// int[] nums = {1,2,3,4}; 简写方式
// 定义一个变量size获取nums的数组长度
int size = nums.length;
// 获取数组元素,第一个元素
int first = nums[0];
System.out.println(first);
// 设置数组元素,把第二个元素设置为6
nums[1] = 6;
// 遍历数组
for (int index = 1; index < size; index++) {
System.out.print(nums[index] + " ");
}
}
}
输出结果为
第一个元素1
1 6 3 4
4. ArrayDemo4.java（重点）
需求：找出数组值元素22,在数组中第一次出现的索引位置
步骤：
（1）定义一个数组nums，并初始化该数组
（2）定义一个变量key，表示被搜索的元素
（3）遍历数组
（4）判断如果当前元素和key相等，证明找到元素，打印并结束循环
public class ArrayDemo4 {
public static void main(String[] args) {
// 需求: 找出数组值元素22,在数组中第一次出现的索引位置
/** 步骤
* 1.定义一个数组nums,并初始化数组
* 2.定义一个变量key,表示被搜索的元素
* 3.遍历数组
* 4.判断如果当前元素和key相等,证明找到元素,打印并结束循环
*/
// 定义一个数组nums,并初始化数组
int[] nums = new int[]{11, 22, 33, 22, 33, 44, 55};
// int[] nums = {11,22,33,22,33,44,55}; 简写方式
// 定义一个变量key,表示被搜索的元素
int key = 22;
boolean has = false;
// 遍历数组
for (int i = 0; i < nums.length; i++) {
// 判断如果当前元素和key相等,证明找到元素,打印并结束循环
if (nums[i] == key) {
has = true;
System.out.println(key + "第一次出现的索引位置为" + i);
break; // 目的达到,撤退
}
}
if (!has) {
System.out.println(key + "不存在数组中");
}
}
}
输出结果为
22第一次出现的索引位置为1
5. ArrayDemo5.java（重点）
需求：求出int类型数组中最大元素值
步骤：
（1）定义并初始化数组nums
（2）定义一个变量max表示最大的元素，并假设nums的第一个元素为最大值
（3）使用foreach循环遍历nums数组
（4）判断如果遍历的元素和max比较，遍历的元素比较大，就将当前元素赋值给max
（5）遍历完成打印max
import java.util.Arrays;
public class ArrayDemo5 {
public static void main(String[] args) {
// 需求：求出int类型数组中最大元素值
/** 步骤
* 1.定义并初始化数组
* 2.定义一个变量max表示最大的元素,并假设nums的第一个元素为最大值
* 3.使用foreach循环遍历nums数组
* 4.判断如果遍历的元素和max比较,遍历的元素比较大,就将当前元素赋值给max
* 5.遍历完成打印max
*/
// 定义并初始化数组
int[] nums = {1, 3, 7, 2, 4, 9, 22, 11};
// 定义一个变量max表示最大的元素,并假设nums的第一个元素为最大值
int max = nums[0];
/*// 使用for循环遍历nums数组
for(int index = 0;index<nums.length;index++){
if(nums[index]>max){
max=nums[index];
}
}
System.out.println("数组中最大元素值为" + max);*/
// 使用foreach循环遍历nums数组
for (int ele : nums) { // ele表示数组中的每一个元素
if (ele > max) {
max = ele;
}
}
// 遍历完成打印max
System.out.println("数组中最大元素值为" + max);
/** 思路2:个人认为这种思路,要更清晰简单点
* 1.直接对nums数组进行升序排序
* 2.排序完成后,获取数组最后一个元素,最后一个元素即数组中最大元素值
* 最后一个元素的索引为nums.length-1
* 3.打印最大元素值
*/
Arrays.sort(nums);
int lastEle = nums[nums.length - 1];
System.out.println("nums数组中最大元素值为" + lastEle);
}
}
输出结果为
数组中最大元素值为22
nums数组中最大元素值为22
6.ArrayDemo6.java（重点）
需求：按照某种格式来打印出数组中的元素，打印效果为：[11,22,33,44,22,55]
步骤：
（1）定义并初始化数组nums
（2）定义一个字符串类型的变量str，用于拼接字符串
（3）遍历数组并拼接元素到str
（4）判断为最后一个元素拼接“]”，否则拼接“，”
（5）打印str
public class ArrayDemo6 {
public static void main(String[] args) {
// 需求：按照某种格式来打印出数组中的元素，打印效果为[11,22,33,44,22,55]
/** 步骤
* 1.定义并初始化数组nums
* 2.定义一个字符串类型的变量str,用于拼接字符串
* 3.遍历数组并拼接元素到str
* 4.判断为最后一个元素拼接"]",否则拼接","
* 5.打印str
*/
// 定义并初始化数组nums
int[] nums = {11, 22, 33, 44, 22, 55};
// 定义一个字符串类型的遍历str,用于拼接字符串
String str = "[";
// 遍历数组并拼接元素到str
for (int ele : nums) {
// 判断为最后一个元素拼接"]",否则拼接","
if (ele == nums[nums.length - 1]) {
str += (ele+"]");
} else {
str += (ele + ",");
}
}
// 打印str
System.out.println(str);
}
}
输出结果为
[11,22,33,44,22,55]
7. ArrayInArrayDemo.java
需求：演示二维数组的基本操作
步骤：
（1）定义一个二维数组
（2）静态初始化二维数组
（3）动态初始化二维数组
（4）获取二维数组的元素
（5）设置二维数组的元素
（6）for循环遍历并打印二维数组的元素
（7）foreach循环遍历并打印二维数组的元素
public class ArrayInArrayDemo {
public static void main(String[] args) {
// 演示二维数组的基本曹祖
/** 步骤
* 1.定义一个二维数组
* 2.静态化初始二维数组
* 3.动态化初始二维数组
* 4.获取二维数组的元素
* 5.设置二维数组的元素
* 6.for循环遍历并打印二维数组的元素
* 7.foreach循环遍历并打印二维数组的元素
*/
// 定义一个二维数组
int[][] nums = new int[][]{};
// 静态初始化二维数组
int[][] arr = {
{1, 2, 3},
{4, 5},
{6}
};
// 动态初始化二维数组
int[][] arr1 = new int[2][3];
// 获取二维数组arr中的元素
// for
for (int i = 0; i < arr.length; i++) {
// 取出每一个一维数组
int[] Arr = arr[i];
// 遍历一维数组
for (int j = 0; j < Arr.length; j++) {
int ele = Arr[j];
System.out.print(ele + " ");
}
System.out.println();
System.out.println("------------");
}
// foreach
for (int[] Arr : arr) { // Arr为每一个一维数组
for (int ele : Arr) { // ele为每个一位数组中的每一个元素
System.out.print(ele + " ");
}
System.out.println();
System.out.println("================");
}
// 设置二位数组中的元素arr[0][2],重新赋值为10
arr[0][2] = 10;
System.out.println(arr[0][2]);
}
}
输出结果为
1 2 3
------------
4 5
------------
6
------------
1 2 3
================
4 5
================
6
================
10
二、综合练习（必做）：
1. LocationDemo.java
需求：定义一个 int 类型数组,求出该数组索引是偶数的元素之和
思路：注意区分索引和元素
public class LocationDemo {
public static void main(String[] args) {
// 需求：定义一个int类型数组，求出该数组索引式偶数的元素之和
// 思路：注意区分索引和元素
// 定义一个静态数组并初始化
int[] arr = {11, 22, 33, 44, 55};
// 定义sum变量接收数组中所有偶数之和,初始化为0
int sum = 0;
// for循环遍历
for (int index = 0; index < arr.length; index++) {
// 当索引为偶数时，让索引为偶数位置上的数与sum累加
if (index % 2 == 0) {
sum += arr[index];
}
}
// 打印索引位置为偶数上的数之和
System.out.println("索引位置为偶数上的数之和" + sum);
}
}
输出结果为
索引位置为偶数上的数之和99
2.ReversedDemo.java
需求：定义一个元素为String类型数组，按照格式逆序打印该数组的元素，例如
数组内容为：{“A”，”B”，”C”，”D”},打印效果为：[D,C,B,A]
思路：
（1）索引从大到小逆序遍历
（2）字符串拼接
int a = 10;
String s = "";
public class ReversedDemo {
public static void main(String[] args) {
/** 需求：定义一个元素为String类型数组，按照格式逆序打印该数组的元素 ，例如
* 数组内容为：{"A","B","C","D"},打印效果为: [D,C,B,A]
*/
/** 思路
* 1.索引从大到小逆序遍历
* 2.字符串拼接
*/
String[] arr = {"A", "B", "C", "D"};
String str = "[";
// 索引从大到小遍历
for (int index = arr.length - 1; index >= 0; index--) {
// 字符串拼接
if (index == 0) {
str += (arr[index] + "]");
} else {
str += (arr[index] + ",");
}
}
// 打印str
System.out.println(str);
}
}
输出结果为
[D,C,B,A]
3. StatisticsDemo1.java
需求：定义一个 int 类型,长度为2的数组，其索引 0 位置存放指定数组索引为偶数的元素之和，索引 1 位置存放指定数组索引为奇数元素之和。
[1,2,3,4,5,6,7,8,9]
思路：
public class StatisticsDemo1 {
public static void main(String[] args) {
/*
需求：定义一个int类型,长度为2的数组,其索引0位置存放指定
数组索引为偶数的元素之和,索引1位置存放指定数组索引为奇数
元素之和
*/
// 静态初始化一个数组
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
// 动态初始化一个数组
int[] arr1 = new int[2];
// 给定两个变量,oddSum存放奇数和,evenSum存放偶数和
int oddSum = 0;
int evenSum = 0;
// for循环遍历数组arr
for (int index = 0; index < arr.length; index++) {
if (arr[index] % 2 == 0) {
evenSum += arr[index];
} else {
oddSum += arr[index];
}
}
System.out.println("偶数之和" + evenSum);
System.out.println("奇数之和" + oddSum);
// 把oddSum,evenSum存放在数组arr1中
arr1[0] = evenSum; // 存放偶数和
arr1[1] = oddSum; // 存放奇数和
String str = "{";
for (int i = 0; i < arr1.length; i++) {
if (i == arr1.length - 1) {
str += (arr1[i] + "}");
} else {
str += (arr1[i] + ",");
}
}
// 打印数组arr1
System.out.println("数组arr1为" + str);
}
}
输出结果为
偶数之和20
奇数之和25
数组arr1为{20,25}
4. StatisticsDemo2.java
需求：定义一个 int 类型的二维数组，统计数组元素值是 0 的的元素个数。
例如：二维数组：{{1,2,0,4,0}，{0,3,5}}, 0的个数为3
public class StatisticsDemo2 {
public static void main(String[] args) {
// 需求：定义一个int类型的二维数组，统计数组元素值是0的元素个数
// 例如：二位数组：{{1,2,0,4,0},{0,3,5}},0的个数为3
// 定义一个int类型的二维数组
int[][] arr = {
{1, 2, 0, 4, 0},
{0, 3, 5}
};
// 定义count变量记录0出现的次数，初始化为0
int count = 0;
// 利用嵌套循环对二维数组每个元素遍历
for (int[] arr1 : arr) { // arr1表示每个一维数组
for (int ele : arr1) { // ele表示每个一维数组的每一个元素
if (ele == 0) {
count++;
}
}
}
System.out.println("0在二维数组arr中出现的次数为" + count);
}
}
输出结果为
0在二维数组arr中出现的次数为3
5.StatisticsDemo3.java(选做)
需求：定义一个整型数组，将数组中的0去掉后返回一个新数组。
例如：数组为 int[] arr={1,13,45,5,0,0,16,6,0,25,4,17,6,7,0,15}; 要求将以上数组中为0的元素去掉，将不为0的值存入一个新数组，生成新的数组作为返回值: int[] newArr={1,13,45,5,16,6,25,4,17,6,7,15};
思路:
- 统计数组中元素不为0的元素个数length
- 定义一个新数组, 将上面统计得到的length作为新数组的长度
- 遍历原数组,将不为0的元素添加到新数组中(注意索引的控制)
public class StatisticsDemo3 {
public static void main(String[] args) {
/* 需求:定义一个整型数组,将数组中的0去掉后返回一个新数组
例如:数组为 int[] arr={1,13,45,5,0,0,16,6,0,25,4,17,6,7,0,15};
要求将以上数组中为0的元素去掉,将不为0的值存入一个新数组,生成新的数组作为
返回值: int[] newArr = {1,13,45,5,16,6,25,4,17,6,7,15};
*/
/** 思路
* 1.统计数组中元素不为0的元素个数length
* 2.定义一个新数组,将上面统计得到的length作为新数组的长度
* 3.遍历原数组,将不为0的元素添加到新数组中(注意索引的控制)
*/
// 给定一个数组arr
int[] arr = {1, 13, 45, 5, 0, 0, 16, 6, 0, 25, 4, 17, 6, 7, 0, 15};
// 定义变量length用来统计不为0的元素个数,初始化为0
int length = 0;
// foreach循环遍历数组arr
for (int ele : arr) {
// 判断不为0的元素,并统计个数
if (ele != 0) {
length++;
}
}
System.out.println("数组arr中不为0的元素个数为" + length);
System.out.println("将设置新数组newArr的长度为" + length);
// 动态初始化一个新数组newArr,并设置长度为length
int[] newArr = new int[length];
// 定义变量j用来控制数组newArr的索引
int j = 0;
// 遍历数组arr
for (int i = 0; i < arr.length; i++) {
if (arr[i] != 0) {
// 将数组arr中每个不为0的元素丢到数组newArr中
newArr[j] = arr[i];
j++;
}
}
// 通过字符串的方式在控制台输出新数组的格式: int[] newArr={1,13,45,5,16,6,25,4,17,6,7,15}
String str = "int[] newArr={";
for (int arrEle : newArr) {
System.out.print(arrEle + " ");
if (arrEle == newArr[newArr.length - 1]) {
str += arrEle + "}";
} else {
str += arrEle + ",";
}
}
System.out.println();
System.out.println("新数组为" + str);
}
}
输出结果为
数组arr中不为0的元素个数为12
将设置新数组newArr的长度为12
1 13 45 5 16 6 25 4 17 6 7 15
新数组为int[] newArr={1,13,45,5,16,6,25,4,17,6,7,15}
\
