day02-main方法的参数+变长参数+数组的相关算法+Arrays类+对象数组
学习任务
1 了解main方法参数是String[]字符串数组
2 掌握变长参数的基础语法
3 了解数组的相关算法
4 记住Arrays类的常用方法
5 了解对象数组的基本操作
文章目录
main方法的参数
-
Java程序必须从main方法开始执行,并且main方法写法是固定的:public static void main(String [] args){}main方法的参数是String[] args字符串数组我们有时 运行JavaSE程序时, 会给程序传递参数
-
编译java源程序: javac 源文件 javac命令就是一个程序, 后面源文件就是这个程序的参数运行java程序: java 类名 java命令就是一个程序, 类名就是这个程序的参数将来在命令窗口中登录MySQL数据库服务器: mysql -uroot -p123 mysql命令就是一个程序 , -uroot -p123 就是这个程序的两个参数如果是使用java语言编写的程序,把程序的参数传递给main方法
* main方法参数是字符串数组 * 1) 在IDEA中, 打开Run->Edit configurations对话框,左侧选择程序Test01,在右侧Program arguments对话框中输入程序参数, 参数之间使用空格分隔 * 2) 当把一个类定义在一个包中之后 ,这个类的全限定类名(完整类名)就是 :包名.类名 * 即当前类的全限定类名是: com.bjpowernode.array.Test01MainArgs * String类的全限定类名是: java.lang.String * 在命令窗口中要执行当前类, 需要把当前目录切换到: D:\course\03-JavaSE\Code\out\production\Day02> * 运行java程序时: java 全限定类名 程序的参数列表,如: * D:\course\03-JavaSE\Code\out\production\Day02>java com.bjpowernode.array.Test01MainArgs feifei 666 * 用户名密码正确,是合法用户 public class Test01MainArgs { public static void main(String[] args) { //运行java程序后,给程序传递两个参数:用户名和密码 //在main方法中判断args参数数组中接收的用户名和密码字符串是否合法 if ( args.length != 2 ){ System.out.println("运行程序需要输入用户名和密码, 使用空格分隔"); return; } String username = args[0]; //获得程序接收的用户名参数 String pwd = args[1]; //获得程序接收的密码参数 if ("feifei".equals(username) && "666".equals(pwd) ){ System.out.println("用户名密码正确,是合法用户"); }else { System.out.println("用户名或密码不正确"); } } }
变长参数
-
在定义方法时, 有时会把方法参数定义为变长参数,格式为:修饰符 返回值类型 方法名( 参数类型 … 变长参数名){}说明:1) 在参数类型与参数名之间使用三个小 点表示变长参数2) 一个方法最多只能有一个变长参数3) 变长参数只能放在参数列表的最后4) 在调用方法时,可以给变长参数传递任意个数据5)在方法体中可以把变长参数当作数组使用
public class Test02VarArgs { public static void main(String[] args) { //在调用方法时,可以给变长参数传递任意个数据 sum(); sum(1); sum(1,2,3,4,5); sum(1,2,3,4,5,6,7,8,9,10); int [] ints = {11,22,33}; //给变长参数传递存储数据的数组 sum( ints ); } //定义方法,计算任意个整数的和, 通过参数接收任意个整数,可以把参数定义为变长参数 public static void sum(int ... data){ //在方法体中可以把变长参数当作数组使用 int sum = 0 ; //通过foreach循环遍历 变长参数接收的数据 for (int xx : data) { sum += xx; } System.out.println( sum ); } }
数组的相关算法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1PwLTBb3-1677677515480)(D:\course\03-JavaSE\Note\Day02\04 冒泡排序.png)]
1.冒泡排序(由小到大) 从前向后两两比较 ,如果前面的数大于后面的数就交换两个数组元素的位置
public class Test03BubbleSort {
public static void main(String[] args) {
int [] ints = {76,435,87,43,7,32,678,54};
//采用冒泡排序,实现由小到大排序, 思路从前向后两两比较,如果前面的数大于后面的数就交换, 数组有lenth个元素,需要比较 length-1 轮次, 通过循环控制比较的轮次
for( int x = 1; x < ints.length; x++){
//再通过内层循环控制第x轮需要比较的元素
for( int i = 0 ; i < ints.length - x ; i++){
if( ints[i] > ints[i+1] ) {
//如果前面的数大于后面的数就交换两个元素的位置
int t = ints[i];
ints[i] = ints[i+1];
ints[i+1] = t;
}
}
}
for (int anInt : ints) {
System.out.print(anInt +" ");
}
System.out.println();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-snXRwg0x-1677677515481)(D:\course\03-JavaSE\Note\Day02\05 选择排序.png)]
2.选择排序(由小到大) 选择数组当前元素中最小的元素交换到前面
public class Test04SelectSort {
public static void main(String[] args) {
int [] ints = {43,56,21,34,67,89,12};
//采用选择排序算法,实现数组元素由小到大排序, 从数组当前元素中选择最小的交换到前面, 数组 有length个元素,需要进行length-1轮次
//使用循环控制比较的轮次
for(int x = 0 ; x < ints.length - 1; x++){
//定义变量保存最小元素的索引值, 当x==0表示第1轮, 先假设 0 元素最小, 即第x轮时假设x元素最小
int min = x;
//从min+1 开始遍历数组后面的其他元素
for( int i = min + 1; i < ints.length; i++){
//如果有某个元素比min标识的元素还小,则这个元素就是当前最小的
if ( ints[i] < ints[min]){
min = i ; //把该元素索引值保存到min变量中
}
}
//上面for循环结束,找到这一轮次最小元素的索引值min, min标识的最小元素 与 x元素交换位置
if ( min != x ){
int t = ints[min];
ints[min] = ints[x];
ints[x] = t;
}
}
for (int anInt : ints) {
System.out.print(anInt + " ");
}
System.out.println();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BxOtYHMb-1677677515482)(D:\course\03-JavaSE\Note\Day02\06 二分查找.png)]
3.二分查找 前提是数组已经实现由小到大排序, 在数组中查找元素时, 始终与中间元素比较大小 ,相等则表示找到了, 如果比中间元素小则把范围缩小到左一半, 否则把范围缩小到右一半
public class Test05BinarySearch {
public static void main(String[] args) {
//二分查找前提是数组已经实现由小到大排序
int [] ints = {12,23,34,45,56,67, 67,76,78,89,90};
System.out.println( binarySearch(ints,12));
System.out.println( binarySearch(ints,90));
System.out.println( binarySearch(ints,67));
System.out.println( binarySearch(ints,50)); //-1表示不存在
}
//定义方法,采用二分查找算法, 返回数组中某个元素的索引值,如果数组中不存在这个元素则返回-1
private static int binarySearch( int [] array, int key ){
//返回key元素在数组中的索引值
int from = 0 ; //查找范围起始索引值
int to = array.length - 1; //查找范围结束索引值
int mid = (from + to )/2; //中间索引值
//当from起始索引值 <= to 结束索引值时就从数组中查找
while ( from <= to ){
//始终与中间元素比较
if ( key == array[mid]) {
return mid; //返回相等元素的索引值
}else if ( key < array[mid]){
//key值小于中间元素,把范围缩小到左一半
to = mid - 1;
}else {
//key值大于中间元素,把范围缩小到右一半
from = mid + 1;
}
//重新 计算mid
mid = (from + to )/2;
}
return -1;
}
}
Arrays类
-
在java.util包中定义了Arrays类, 该类提供一组操作数组的方法,常用的有:toString( 数组名 ) 可以把数组元素连接为字符串copyOf( src源数组, newLength新数组长度) 根据指定的新数组长度创建一个数组,把src源数组相应的数组元素复制到新数组中,并返回新的数组sort(数组) 对数组进行排序binarySearch( 数组名, 要查找的元素), 采用二分查找算法返回元素在数组中的索引值
public class Test06Arrays { public static void main(String[] args) { int [] ints = {54,23,76,34,76,12,65,78}; //1) toString(数组名)可以把数组元素连接为字符串 String s = Arrays.toString(ints); System.out.println( s ); //[54, 23, 76, 34, 76, 12, 65, 78] //2) static int[] copyOf(int[] original, int newLength) 根据指定的newLength长度创建一个新数组, 把original数组中相应的元素复制到新数组中, 返回这个新的数组 int[] bigger = Arrays.copyOf(ints, ints.length * 2); //新数组长度更大 System.out.println( Arrays.toString(bigger)); int[] smaller = Arrays.copyOf(ints, ints.length / 2); //新数组长度更小 System.out.println( Arrays.toString(smaller)); //[54, 23, 76, 34] //当新数组长度比原来数组长度更大 ,然后把方法返回的大数组再赋值给原来的数组就是数组扩容 ints = Arrays.copyOf(ints, ints.length + ints.length / 2); System.out.println( Arrays.toString(ints)); //3) sort(数组名)对象数组排序 Arrays.sort(ints); System.out.println( Arrays.toString(ints)); //[0, 0, 0, 0, 12, 23, 34, 54, 65, 76, 76, 78] //4) 二分查找 System.out.println( Arrays.binarySearch(ints,0)); System.out.println( Arrays.binarySearch(ints,12)); System.out.println( Arrays.binarySearch(ints,76)); System.out.println( Arrays.binarySearch(ints,55)); //-9, 负数表示不存在 } }
对象数组
如果在数组中存储引用 类型的对象,称数组为对象数组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NTsbVg0h-1677677515482)(D:\course\03-JavaSE\Note\Day02\07 对象数组.png)]
public class Student {
String name;
int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
public class Test07ObjectArray {
public static void main(String[] args) {
//定义可以存储 50 个Student对象的数组
Student[] data = new Student[50];
//一般情况下,在使用对象数组时,会定义变量记录数组中元素的数量
int size = 0 ;
//向数组中存储一组Student对象
//在使用数组时,一般采用顺序顺序,即按data[0], data[1], data[2], data[3]....
//每次向数组中存储了更多数据后, size计数器就加1
data[size++] = new Student("hanyi", 80); //size++; // 1
data[size++] = new Student("liuer", 60); //size++; // 2
data[size++] = new Student("zhangsan", 90); //size++; // 3
data[size++] = new Student("lisi", 30); //size++; // 4
data[size++] = new Student("wangwu", 40); //size++; // 5
data[size++] = new Student("zhaoliu", 70); //size++; // 6
data[size++] = new Student("chenqi", 80); //size++; // 7
//遍历数组所有 的元素,
/*for (Student student : data) {
System.out.println(student);
}*/
//data数组前7个元素保存了Student对象,data数组后面的其他元素默认初始化为null
//打印数组中保存的学生的姓名,不需要遍历所有 的数组元素,只需要遍历前面保存的 size 个元素即可
for (int i = 0; i < size; i++) {
System.out.println( data[i].name );
}
//统计数组中保存的Student对象不及格同学的数量
int count = 0 ; //定义计数器变量
//遍历data数组中保存的前size个元素
for (int i = 0; i < size; i++) {
//如果data[i]数组元素(Student对象)的成绩不及格就计数
if ( data[i].score < 60 ){
count++;
}
}
System.out.println("不及格同学的数量: " + count);
//删除zhangsan同学
//1) 确定zhangsan同学在数组中索引值index
int index = - 1; //定义变量保存zhangsan在数组中的索引值, 数组索引值大于等于0, 所以初始化-1
//遍历data数组前面保存的size个元素
for (int i = 0; i < size; i++) {
//如果存在某个元素(Student对象)的姓名是zhangsan,则把该元素索引值保存到index变量中
if ( "zhangsan".equals( data[i].name ) ){
index = i;
break;
}
}
if ( index >= 0 ) {
//2) 从 index + 1 开始,每个 元素逐个前移
/*for( int i = index; i < size - 1; i++){
data[i] = data[i+1];
}*/
//把data数组中从index+1开始的元素复制到data数组中从 index 开始的位置上, 复制size-index-1个元素
System.arraycopy(data,index+1,data,index,size - index - 1);
//3) 数组原来最后一个元素清空
data[size-1] = null;
//4) 数组中元素的数量size减1
size--;
}else {
System.out.println("数组不存在姓名为zhangsan的同学");
}
System.out.println("------------删除zhangsan后--------------");
for (Student student : data) {
System.out.println(student);
}
}
}
练习
1 有数组: int [] ints = {12,34,56,78,90};编写程序, 实现数组元素的逆序, 再从前向后遍历ints数组时, 顺序是: 90, 78, 56, 34, 12编写程序, 实现数组元素的乱序, 每次遍历ints数组, 数组中元素的存储位置都不一定
public class Test01 {
public static void main(String[] args) {
int[] ints = {12, 34, 56, 78, 90};
//调用方法,实现数组元素逆序
reverse(ints);
System.out.println(Arrays.toString(ints)); //[90, 78, 56, 34, 12]
//调用方法实现数组元素乱序
shuffle(ints);
System.out.println(Arrays.toString(ints));
}
//定义方法实现数组元素乱序
private static void shuffle(int[] array) {
//乱序就是把数组元素的存储位置打乱, 可以遍历数组的每个 元素, 这个元素与另外一个数组元素交换位置,另外一个数组元素的索引值随机生成
for (int i = 0; i < array.length; i++) {
//先生成随机索引值
int x = (int) (Math.random() * array.length);
//i位置元素与x位置元素交换
int tmp = array[i];
array[i] = array[x];
array[x] = tmp;
}
}
//定义方法,实现数组元素逆序, 通过参数接收数组
private static void reverse(int[] array) { //在调用方法时, 把实参ints传递给形参array,现在形参array与实参ints都引用了堆中同一个数组对象, 在方法体中修改了形参数组的元素,其实也是修改实参数组元素
//前一半与后一半交换位置
for (int i = 0; i < array.length / 2; i++) {
//i位置元素与 length-1-i 位置的元素交换位置
int tmp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = tmp;
}
//在方法体中对形参数组重新赋值, 形参数组指定了新的数组, 不再引用 实参数组了, 也可以把这个新的数组返回给实参 数组
}
}
2 有数组: int [] ints = { 10, 20 , 30 ,40 , 5, 15, 15, 10,10,5};编写程序, 找出数组的某个索引值index, 使得 index 左侧元素和 等于 index 右侧元素的和, 如果数组中不存在符合条件的索引值,则返回-1
public class Test02 {
public static void main(String[] args) {
int[] ints = {10, 20, 30, 40, 5, 15, 15, 10, 10, 5};
System.out.println(getMidIndex(ints));
}
//定义方法,返回数组的中间位置 ,使得左侧元素和等于右侧元素和
public static int getMidIndex(int[] array) {
//数组至少有3个元素
if (array.length < 3) {
return -1;
}
int begin = 0; //起始索引值
int end = array.length - 1; //结束索引值
int mid = (begin + end) / 2; //中间索引值
while (begin <= end) {
//计算mid左侧元素和
int sumLeft = 0;
for (int i = 0; i < mid; i++) {
sumLeft += array[i];
}
//计算mid右侧元素和
int sumRight = 0;
for (int i = mid + 1; i < array.length; i++) {
sumRight += array[i];
}
//判断相等
if (sumLeft == sumRight) {
return mid;
} else if (sumLeft < sumRight) {
//向右调整
begin = mid + 1;
} else {
//向左调整
end = mid - 1;
}
mid = (begin + end) / 2;
}
return -1;
}
public static int getMidIndex2(int[] array) {
//数组至少有3个元素
if (array.length < 3) {
return -1;
}
//先计算i==1左侧元素和
int sumLeft = array[0];
//再计算i==1时右侧元素和
int sumRight = 0;
for (int i = 2; i < array.length; i++) {
sumRight += array[i];
}
//从i==1开始逐个尝试
for (int i = 1; i < array.length - 1; i++) {
if (sumLeft == sumRight) {
return i;
} else {
sumLeft += array[i]; //修正左侧元素和
sumRight -= array[i + 1]; //修正右侧元素和
}
}
return -1; //不存在
}
public static int getMidIndex1(int[] array) {
//数组至少有3个元素
if (array.length < 3) {
return -1;
}
//从索引值为1的位置逐个尝试
for (int i = 1; i < array.length - 1; i++) {
//定义变量保存左侧元素和
int sumLeft = 0;
for (int j = 0; j < i; j++) {
sumLeft += array[j];
}
//定义变量保存i右侧元素和
int sumRight = 0;
for (int j = i + 1; j < array.length; j++) {
sumRight += array[j];
}
//判断是否相等
if (sumLeft == sumRight) {
return i;
}
}
return -1; //不存在符合条件的索引值
}
}
变量保存左侧元素和
int sumLeft = 0;
for (int j = 0; j < i; j++) {
sumLeft += array[j];
}
//定义变量保存i右侧元素和
int sumRight = 0;
for (int j = i + 1; j < array.length; j++) {
sumRight += array[j];
}
//判断是否相等
if (sumLeft == sumRight) {
return i;
}
}
return -1; //不存在符合条件的索引值
}
}
> 复习多态 方法形参是父类类型的参数, 在调用方法时,可以传递各种子类对象 方法形参是接口类型的参数, 在调用方法时,可以传递接口的实现类对象或者匿名内部类对象 方法返回值类型是父类类型, 在方法体中可以返回子类对象 方法返回值类型是接口, 在方法体中可以返回接口的实现类对象
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
