2021年7月20日
讲师：王博
Id：10.8.159.99
昨日回顾
方法的声明
无参数无返回值：public static void 方法名（）{}
无参数有返回值：public static 数据类型 方法名（）{}
有参数无返回值：public static void 方法名（数据类型 形参）{}
有参数有返回值：public static 数据类型 方法名(数据类型 形参){}
Break:终止的作用
Continue：跳出当前循环，继续下一次的循环
数组的声明：int [] arr = new int[8];
Int [] arr1 = {1,2,3,4};
Int [] arr2 = new int[] {4,5,6,7,8};
数组：
赋值
取值
今日内容
- 定义一个方法，找出int数组中最大值的索引下标
- 定义一个方法，找出int数组中最小值的索引下标
- 定义一个方法，找出数组中指定元素的下标
- 在一个数组中，找出所有指定数据的下标位置【*】
- 替换数组中数据为0的元素，使用指定的元素进行替换
- 删除指定下标的元素，要求从删除的位置开始，之后的元素前移一位
- 添加指定的元素，到指定的位置，后面的元素整体后移一位
- 冒泡排序
- 选择排序
- 找出数组中最大的元素，放到下标为0的位置
- 在上一道题的基础上，不考虑下标为0的元素，找出数组中最大的元素，放倒下标为1的位置
定义一个方法，找出int数组中最大值的索引下标
package com.liujinghe.app;
/**
* 封装方法的写法
* 返回int类型数组最大值下标
*/
public class Demo2 {
public static void main(String[] args) {
int[] arr = {2, 4, 5, 665, 4, 665, 66};
//问题：如果数组有两个最大值，怎么把两个最大值的索引打印
int i = maxIndexArray(arr);
System.out.println("最大值的索引" + i);
}
/**
* 方法的分析
* 方法的名字 maxIndexArray
* 形参：一个int类型的数组
* 返回值：int类型
*
* @param arr
* @return
*/
public static int maxIndexArray(int[] arr) {
int maxIndex = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] >= arr[maxIndex]) {
maxIndex = i;
}
}
return maxIndex;
}
}
定义一个方法，找出int数组中最小值的索引下标
package com.liujinghe.app;
/**
* 2.定义一个方法，找出int数组中最小值的索引下标
*/
public class Demo3 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int i = minIndexArray(arr);
System.out.println("最小值的索引为：" + i);
}
/**
* 方法分析
* 方法名：minIndexArray
* 形参：int 类型数组
* 返回值：int类型
*/
public static int minIndexArray(int[] arr) {
//假设最小值的索引为0
int minIndex = 0;
for (int i = 1; i < arr.length; i++) {
/**
* [1,2,3,4,5,6]
* i=1 1<6 true arr[1]<=arr[0] false i++
* i=2 2<6 true arr[2]<=arr[0] false i++
* i=3 3<6 true arr[3]<=arr[0] false i++
* i=4 4<6 true arr[4]<=arr[0] false i++
* i=5 5<6 true arr[5]<=arr[0] false i++
* i=6 <6 false 循环结束
*/
if (arr[i] <= arr[minIndex]) {
minIndex = i;
}
}
return minIndex;
}
}
定义一个方法，找出数组中指定元素的下标
package com.liujinghe.app;
public class Demo6 {
//定义一个方法，找出数组中指定元素的下标
public static void main(String[] args) {
int [] arr = {1,2,3,4,5,6};
int i = indexOf(arr, 3);
System.out.println("查找元素的索引为："+i);
}
/**
* 方法分析
* 方法的名字：indexOf
* 方法的参数：int类型数组，int类型数据
* 返回值：int
*/
public static int indexOf(int [] arr,int find){
int index = -1;
for (int i = 0; i < arr.length; i++) {
if(arr[i] == find){
index = i;
//数据找到，结束循环
break;
}
}
return index;
}
}
在一个数组中，找出所有指定数据的下标位置【*】
{1,2,3,1,2,3,1,2,3}
1 索引 0,3,6
package com.liujinghe.app;
import java.lang.reflect.Array;
public class Demo8 {
public static void main(String[] args) {
int[] arr = {1,2,3,1,2,3,1,2,3};
int[] indexex = new int[arr.length];
int[] allIndexes = findAllIndexes(arr, 2, indexex);
for (int i = 0; i < allIndexes.length; i++) {
System.out.print(allIndexes[i]+",");
}
}
/**
* 方法的分析
* 方法的名字：findAllIndexes
* 参数：
* int类型数组
* int类型数据
* int类型数组，一个空的数组来接收找到的索引值
* 返回值：int类型数组
*/
public static int[] findAllIndexes(int [] arr,int find,int[] indexes){
//判断参数的合法性
if(arr == null ){
System.out.println("参数不合法");
return new int[]{-1};
}
//定义一个变量进行计数
int count = 0;
//使用for循环进行查找
for (int i = 0; i < arr.length; i++) {
if(arr[i] == find){
indexes[count++] = i;
}
}
return indexes;
}
}
替换数组中数据为0的元素，使用指定的元素进行替换
package com.liujinghe.app;
import java.util.Arrays;
public class Demo10 {
public static void main(String[] args) {
int [] arr = {1,2,3,0,0,0,0,0,0,0,0};
boolean replace = replace(arr, 89);
System.out.println(replace);
System.out.println(Arrays.toString(arr));
}
//
//替换数组中数据为0的元素，使用指定的元素进行替换
//
/**
* 方法分析
* 方法名字：replace
* 形式参数
* 第一个参数：int类型数组
* 第二个参数：替换的数值int
* 返回值
* 布尔类型数据
*/
public static boolean replace(int [] arr,int newNumber){
//1.参数的合法性
if(arr == null){
System.out.println("参数不合法，数组不能为空");
return false;
}
//2.使用for循环进行替换
for (int i = 0; i < arr.length; i++) {
if(arr[i] == 0){
arr[i] = newNumber;
}
}
return true;
}
}
删除指定下标的元素，要求从删除的位置开始，之后的元素前移一位
添加指定的元素，到指定的位置，后面的元素整体后移一位
冒泡排序
选择排序
找出数组中最大的元素，放到下标为0的位置
在上一道题的基础上，不考虑下标为0的元素，找出数组中最大的元素，放倒下标为1的位置
