Java基础_数组_数组元素的最值，查询，添加和删除_Arrays工具类_二维数组_9
来源于马士兵教育赵珊珊老师的笔记
数组引入
练习：键盘录入十个学生的成绩，求和，求平均数：
import java.util.Scanner;
public class TestArray01{
public static void main(String[] args){
//功能：键盘录入十个学生的成绩，求和，求平均数：
//定义一个求和的变量：
int sum = 0;
Scanner sc = new Scanner(System.in);
for(int i=1;i<=10;i++){//i:控制循环次数
System.out.print("请录入第"+i+"个学生的成绩：");
int score = sc.nextInt();
sum += score;
}
System.out.println("十个学生的成绩之和为："+sum);
System.out.println("十个学生的成绩平均数为："+sum/10);
}
}
//本题的缺点：就是不能求每个学生的成绩具体是多少
数组的作用：数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干数据组织起来。这个若干数据的集合我们称之为数组。
数组的定义，创建，初始化
数组的含义：数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
- 定义数组 int[] array;或int array[]
- 创建数组 arr = new int[4];//给数组开辟了一个长度为4的空间
编译期声明和创建会被合为一句话: int[] arr = new int[4]; - 数组的初始化： 总共有三种：静态初始化、动态初始化、默认初始化。
静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; —> 数组有默认的初始化值
各个数据类型默认的初始化值如下表：
| 数据类型 | 初始化值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0 |
| float | 0.0 |
| double | 0.0 |
| char | ‘\u0000’ (相当于一个空格) |
| boolean | false |
| String等引用数据类型 | null |
数组的特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
#练习：键盘录入十个学生的成绩，求和，求平均数：
public static void main(String[] args){
//功能：键盘录入十个学生的成绩，求和，求平均数：
//定义一个int类型的数组，长度为10 ：
int[] scores = new int[10];
//定义一个求和的变量：
int sum = 0;
Scanner sc = new Scanner(System.in);
for(int i=1;i<=10;i++){
//i:控制循环次数
System.out.print("请录入第"+i+"个学生的成绩：");
int score = sc.nextInt();
scores[i-1] = score;
sum += score;
}
System.out.println("十个学生的成绩之和为："+sum);
System.out.println("十个学生的成绩平均数为："+sum/10);
//将数组中的每个元素进行查看--》数组的遍历：
//方式1：普通for循环---》正向遍历：
for(int i=0;i<=9;i++){
System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
}
//方式2：增强for循环:
//对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
int count = 0;
for(int num:scores){
count++;
//每次都将num在控制台输出
System.out.println("第"+count+"个学生的成绩为："+num);
}
/*
增强for循环：
优点：代码简单
缺点：单纯的增强for循环不能涉及跟索引相关的操作
*/
//方式3：利用普通for循环： 逆向遍历：
for(int i=9;i>=0;i--){
System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
}
}
数组基础操作：
1. 实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
public static void main(String[] args){
//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
//1.给定一个数组
int[] arr = {
12,3,7,4,8,125,9,45,666,36};
//2.求出数组中的最大值：
//先找一个数上擂台，假定认为这个数最大：
int maxNum = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>maxNum){
maxNum = arr[i];
}
}
System.out.println("当前数组中最大的数为："+maxNum);
}
2. 将求最大值的方法提取出来：
```java
public static void main(String[] args){
//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
//1.给定一个数组
int[] arr = {
12,3,7,4,8,725,9,45,666,36};
//2.求出数组中的最大值：
//调用方法：
int num = getMaxNum(arr);
System.out.println("当前数组中最大的数为："+num);
}
/*
想提取一个方法：求数组中的最大值
求哪个数组中的最大值 ---》不确定因素：哪个数组 (形参)---》返回值：最大值
*/
public static int getMaxNum(int[] arr){
//先找一个数上擂台，假定认为这个数最大：
int maxNum = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>maxNum){
maxNum = arr[i];
}
}
return maxNum;
}
3. 查询指定位置的元素
public static void main(String[] args){
//查询指定位置的元素
//给定一个数组：
int[] arr = {
12,34,56,7,3,10};
//查找索引为2的位置上对应的元素是什么？
System.out.println(arr[2]);
}
4. 查询指定元素的位置—>找出元素对应的索引
public static void main(String[] args){
//查询指定元素的位置--》找出元素对应的索引
//给定一个数组：
int[] arr = {
12,34,56,7,3,56};
// 0 1 2 3 4 5
//功能：查询元素888对应的索引：
int index = -1; //这个初始值只要不是数组的索引即可
for(int i=0;i<arr.length;i++){
if(arr[i]==12){
index = i;//只要找到了元素，那么index就变成为i
break;//只要找到这个元素，循环就停止
}
}
if(index!=-1){
System.out.println("元素对应的索引："+index);
}else{
//index==-1
System.out.println("查无此数！");
}
}
5. 将查指定元素对应的索引的功能提取为方法：
public static void main(String[] args){
//查询指定元素的位置--》找出元素对应的索引
//给定一个数组：
int[] arr = {
12,34,56,7,3,56};
// 0 1 2 3 4 5
//功能：查询元素888对应的索引：
//调用方法：
int index = getIndex(arr,999);
//后续对index的值进行判断：
if(index!=-1){
System.out.println("元素对应的索引："+index);
}else{
//index==-1
System.out.println("查无次数！");
}
}
/*
定义一个方法：查询数组中指定的元素对应的索引：
不确定因素：哪个数组，哪个指定元素 （形参）
返回值：索引
*/
public static int getIndex(int[] arr,int ele){
int index = -1; //这个初始值只要不是数组的索引即可
for(int i=0;i<arr.length;i++){
if(arr[i]==ele){
index = i;//只要找到了元素，那么index就变成为i
break;//只要找到这个元素，循环就停止
}
}
return index;
}
6. 给定一个数组,在数组下标为？的位置上添加一个数
public static void main(String[] args){
//功能：给定一个数组,在数组下标为2的位置上添加一个元素91
//1.给定一个数组：
int[] arr = {
12,34,56,7,3,10,55,66,77,88,999,89};
// 0 1 2 3 4 5
//2.输出增加元素前的数组：
System.out.print("增加元素前的数组：");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
System.out.print(arr[i]+",");
}else{
//i==arr.length-1 最后一个元素不用加,
System.out.print(arr[i]);
}
}
//3.增加元素
int index = 1;//在这个指定位置添加 元素
for(int i=arr.length-1;i>=(index+1);i--){
arr[i] = arr[i-1];
}
arr[index] = 666;
//4.输出增加元素后的数组：
System.out.print("\n增加元素后的数组：");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
System.out.print(arr[i]+",");
}else{
//i==arr.length-1 最后一个元素不用加,
System.out.print(arr[i]);
}
}
}
7. 将添加功能提取为一个 方法：
import java.util.Scanner;
public class TestArray07{
public static void main(String[] args){
//功能：给定一个数组,在数组下标为2的位置上添加一个元素91
//1.给定一个数组：
int[] arr = {
12,34,56,7,3,10,55,66,77,88,999,89};
// 0 1 2 3 4 5
//2.输出增加元素前的数组：
/*
System.out.print("增加元素前的数组：");
for(int i=0;i
System.out.println();
//从键盘接收数据：
Scanner sc = new Scanner(System.in);
System.out.println("请录入你要添加元素的指定下标：");
int index = sc.nextInt();
System.out.println("请录入你要添加的元素：");
int ele = sc.nextInt();
//3.增加元素
//调用方法：
insertEle(arr,index,ele);
//4.输出增加元素后的数组：
System.out.print("\n增加元素后的数组：");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
System.out.print(arr[i]+",");
}else{
//i==arr.length-1 最后一个元素不用加,
System.out.print(arr[i]);
}
}
}
/*
提取一个添加元素的方法：
在数组的指定位置上添加一个指定的元素。
在哪个数组的哪个位置添加哪个元素！
不确定因素：形参：哪个数组，哪个位置，哪个元素
返回值：无
*/
public static void insertEle(int[] arr,int index,int ele){
for(int i=arr.length-1;i>=(index+1);i--){
arr[i] = arr[i-1];
}
arr[index] = ele;
}
}
8. 删除指定位置（索引）上的元素
import java.util.Arrays;
public class TestArray08{
public static void main(String[] args){
//功能：给定一个数组,删除下标为2元素
//1.给定一个数组：
int[] arr = {
12,34,56,7,3,10,34,45,56,7,666};
// 0 1 2 3 4 5
//2.输出删除前的数组：
System.out.println("删除元素前的数组："+Arrays.toString(arr));
//3.删除
/*
arr[2] = arr[3];
arr[3] = arr[4];
arr[4] = arr[5];
*/
int index = 0;
for(int i=index;i<=arr.length-2;i++){
arr[i] = arr[i+1];
}
arr[arr.length-1] = 0;
//4.输出删除后的数组：
System.out.println("删除元素后的数组："+Arrays.toString(arr));
}
}
9. 删除指定元素（数）
import java.util.Arrays;
public class TestArray09{
public static void main(String[] args){
//功能：给定一个数组,删除元素3：
//1.给定一个数组：
int[] arr = {
12,34,56,7,3,10,34,45,56,7,666};
//2.输出删除前的数组：
System.out.println("删除元素前的数组："+Arrays.toString(arr));
//找到要删除的元素对应的索引即可：
int index = -1 ;
for(int i=0;i<arr.length;i++){
if(arr[i]==1200){
index = i;
break;
}
}
//3.删除
if(index!=-1){
for(int i=index;i<=arr.length-2;i++){
arr[i] = arr[i+1];
}
arr[arr.length-1] = 0;
}else{
//index==-1
System.out.println("根本没有你要删除的元素！");
}
//4.输出删除后的数组：
System.out.println("删除元素后的数组："+Arrays.toString(arr));
}
}
Main方法
同一个类中，如果存在多个方法，则虚拟机自动识别main方法，作为程序的入口。
main方法严格要求：public static void main(String[] args){}
同一个方法中可以存在另一个main方法，叫做方法的重载。
形参为String[] 那么实参到底是什么？
public class TestArray10{
public static void main(String[] args){
//从侧面验证：
//int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。
//int[] arr2 = null;
//System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException
//int[] arr3 = new int[0];
//System.out.println(arr3.length);
//int[] arr4 = new int[4];
//System.out.println(arr4.length);
//System.out.println(args.length);//0
//从这个结果证明，参数是String[],实参是 new String[0]
//默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组
System.out.println(args.length);
for(String str:args){
System.out.println(str);
}
}
}
可变参数
-
作用：提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
格式：int…num
double…num
boolean…num -
可变参数在JDK1.5之后加入的新特性
-
方法的内部对可变参数的处理跟数组是一样
-
可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
-
我们自己在写代码的时候，建议不要使用可变参数。
public static void main(String[] args){
//method01(10);
//method01();
//method01(20,30,40);
method01(30,40,50,60,70);
//method01(new int[]{11,22,33,44});
}
public static void method01(int num2,int...num){
System.out.println("-----1");
for(int i:num){
System.out.print(i+"\t");
}
System.out.println();
System.out.println(num2);
}
Arrays工具类
binarySearch:二分法查找
- 找出指定数组中的指定元素对应的索引：
- 这个方法的使用前提：一定要查看的是一个有序的数组：
- 使用binarySearch必须对数组进行排序
- 使用sort方法升序对数组排序
int[] arr = {
1,3,7,2,4,8};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.binarySearch(arr,4));
copeOf：完成数组的复制
int[] arr2 = {
1,3,7,2,4,8};
int[] newArr = Arrays.copyOf(arr2,4);
System.out.println(Arrays.toString(newArr));
toString：对数组进行遍历查看的，返回的是一个字符串
int[] arr = {
1,3,7,2,4,8};
System.out.println(Arrays.toString(arr));
copyOfRange:区间复制
int[] arr2 = {
1,3,7,2,4,8};
int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->只复制1,2,3位置，而不复制4位置
System.out.println(Arrays.toString(newArr2));
equals:比较两个数组的值是否一样：
int[] arr3 = {
1,3,7,2,4,8};
int[] arr4 = {
1,3,7,2,4,8};
System.out.println(Arrays.equals(arr3,arr4));//true
System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
fill：数组的填充
int[] arr5 = {
1,3,7,2,4,8};
Arrays.fill(arr5,10);
System.out.println(Arrays.toString(arr5));//将数组中所有的数填充为10
System类下数组的复制：arraycopy方法
public static void arraycopy(Object src, //源数组
int srcPos, //源数组中的起始位置
Object dest, // 目标数组
int destPos, //目标数组中的起始位置
int length) //要复制数组元素的数量
如：
import java.util.Arrays;
public class TestArray14{
public static void main(String[] args){
//给一个源数组：
int[] srcArr = {
11,22,33,44,55,66,77,88};
//给一个目标数组：
int[] destArr = new int[10];
//复制：
System.arraycopy(srcArr,1,destArr,3,3);
//遍历查看目标数组：
System.out.println(Arrays.toString(destArr));
}//输出[0，0，0，11，22，33，0，0，0，0]
}
二维数组
直接为每一维分配空间，格式如下：
type[][] typeName = new type[typeLength1][typeLength2];
type 可以为基本数据类型和复合数据类型，arraylength1 和 arraylength2 必须为正整数，arraylength1 为行数，arraylength2 为列数。
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {
1,2,3};
arr[0] = a1;
arr[1] = new int[]{
4,5,6,7};
arr[2] = new int[]{
9,10};
}
}
二维数组的四种遍历方式
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {
1,2,3};
arr[0] = a1;
arr[1] = new int[]{
4,5,6,7};
arr[2] = new int[]{
9,10};
//读取6这个元素：
//System.out.println(arr[1][2]);
//对二维数组遍历：
//方式1：外层普通for循环+内层普通for循环：
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
//方式2：外层普通for循环+内层增强for循环：
for(int i=0;i<arr.length;i++){
for(int num:arr[i]){
System.out.print(num+"\t");
}
System.out.println();
}
//方式3：外层增强for循环+内层增强for循环：
for(int[] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
//方式4：外层增强for循环+内层普通for循环：
for(int[] a:arr){
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
System.out.println();
}
}
}
二维数组的初始化
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[][] arr = { {1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] { {1,2},{4,5,6},{4,5,6,7,8,9,9}};
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
arr[0] = {
1,2};
arr[1] = {
3,4,5,6};
arr[2] = {
34,45,56};
public class TestArray16{
public static void main(String[] args){
int[][] arr = new int[3][2];
//本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：
arr[1] = new int[]{
1,2,3,4};
//数组遍历：
for(int[] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
}
}
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
~
有不懂的地方可以私信~
内容来源于马士兵教育赵珊珊老师的Java笔记。