1.数组:在内存中开辟一段连续的空间存值就叫数组.
1.1:数组是引用数据类型.
1.2:数组的四个组成部分(四要素):数据类型,数组名,元素,索引(下标).
1.3:同一个数组中,元素的数据类型相同,不同的数组数据类型可不同.
1.4:访问数组中每个空间:数组名[索引]
1.5:数组的长度:数组名.length
1.6:数组的索引范围:0~数组名.length-1.
1.7:数组的索引不能超过索引范围,如果超过就报ArrayIndexOutOfBoundsException
1.8:数组一但分配了空间,它的长度是固定.
1.9:数组不赋初值,系统会默认分配初始值
数组类型 默认初始值
int 0
double 0.0
char \u0000,在window系统下解析是空格
String null
boolean false
1.10:数组一但分配了空间,就可以使用.
1.11:数组直接输出,输出的是内存地址.
2.数组的使用
2.1:声明数组语法:
2.1.1:数据类型[] 数组名;(推荐)
数据类型 数组名[];
eg://第一种声明数组
String[] stuNames1;
int stuAges1[];
2.2:给数组分配空间
2.1.1:给已经声明过的数组分配空间的语法:数组名=new 数据类型[长度];
eg://给数组分配空间
stuNames1=new String[3];
stuAges1=new int[5];
2.1.2:声明数组的同时分配空间的语法:数据类型[] 数组名=new 数据类型[长度];
eg://声明数组的同时分配空间
double[] stuHeights1=new double[4];
2.3:给数组赋值
2.3.1:动态赋值:适用于所有情况
动态赋值的语法:数组名[索引]=值;
eg://给数组动态赋值,调出数组的每个空间一一赋值
stuNames1[0]="万鑫鑫";
stuNames1[1]="黄小平";
stuNames1[2]="辛灵";
2.3.2:静态赋值:对数组的元素已知
2.3.2.1:静态赋值的语法:数据类型[] 数组名=new 数据数据[]{值1,值2...};
2.3.2.2:静态赋值的语法:数据类型[] 数组名={值1,值2...};
eg://给数组静态赋值:将数组声明,分配空间和赋值合三为一
double[] stuWeights=new double[] {90.0,70.5,66.5};
//给数组静态赋值:将数组声明,分配空间和赋值合三为一
char[] stuSexs= {'男','女'};
2.4:数组的遍历
遍历:一一访问数组中每个空间的值
2.4.1:用for循环遍历数组:
eg://第一种:遍历数组
for (int i = 0; i < stuNames1.length; i++) {
System.out.println(stuNames1[i]);
}
2.4.2:增强版for循环(变态for循环,foreach循环):只能用遍历数组或集合.
语法:for(元素的数据类型 遍历每个元素的指代 :数组名/集合名){
}
//第二种:用增强版for循环来遍历数组,每次遍历每个空间的值存在变量a,a就指代每次遍历个元素的值
for (double a : stuHeights1) {
System.out.println(a);
}
3.排序和算法:
3.1:求最大值和最小值:(打擂台方法)
eg:public static void main(String[] args) {
//准备数组
int[] nums= {5,8,1,7,6,3};
//声明一个变量存最大值,假设数组第一个元素最大
int max=nums[0];
//声明一个变量存最小值,假设数组第一个元素最小
int min=nums[0];
//从第二个元素开始遍历数组,让遍历的每个元素与max比较
for (int i = 1; i < nums.length; i++) {
if (max<nums[i]) {
max=nums[i];
}
if (min>nums[i]) {
min=nums[i];
}
}
System.out.println("数组中最大值是:"+max);
System.out.println("数组中最小值是:"+min);
}
3.2:冒泡排序(重点):第一轮:从第一个元素开始,两两比较,比出最大值或最小值,最大值或最小值再不参加比较,剩下数列中,从第一个元素开始,两两比较,比出剩下数列最大值或最小值,依次类推.
eg:public static void main(String[] args) {
//准备数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前:");
for (int n1 : nums) {
System.out.print(n1+"\t");
}
/*冒泡排序*/
//外层循环控制比较轮数
for (int i = 0; i <nums.length-1; i++) {
//内层循环控制两两相邻比较
for (int j = 0; j < nums.length-1-i; j++) {
if (nums[j]>nums[j+1]) {
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}
System.out.println("\n排序后:");
for (int n1 : nums) {
System.out.print(n1+"\t");
}
}
3.3:选择排序:
eg:public static void main(String[] args) {
//准备数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前:");
for (int n1 : nums) {
System.out.print(n1+"\t");
}
/*选择排序*/
//外层循环控制数数
for (int i = 0; i < nums.length-1; i++) {
for (int j = i+1; j < nums.length; j++) {
if (nums[i]<nums[j]) {
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}
}
System.out.println("\n排序后:");
for (int n1 : nums) {
System.out.print(n1+"\t");
}
}
3.4:二分查找法:前提条件:对已经排好序数组进行查找某个元素.
eg:public static void main(String[] args) {
//准备一个数组
int[] nums= {1,3,5,6,7,8};
//获得具有从键盘上接收数据能力
Scanner input=new Scanner(System.in);
System.out.println("请输入你要在数组中查找的元素:");
int find=input.nextInt();
//声明一个变量存要查找元素在数组中索引位置
int index=-1;
//声明变量存数组最小索引和最大索引及中间索引
int min=0;
int max=nums.length-1;
int mid=(min+max)/2;
while (min<=max) {
if (find==nums[mid]) {//找到了,跳出循环结构
index=mid;
break;
}else if (find>nums[mid]) {
min=mid+1;
mid=(min+max)/2;
}else if (find<nums[mid]) {
max=mid-1;
mid=(min+max)/2;
}
}
//判断index,确认元素是否找到
if(index==-1) {
System.out.println("数组查无此元素");
}else {
System.out.println(find+"在数组中索引为:"+index);
}
}
4.Arrays:数组工具类,这个类中提供操作数组的常用方法.
4.1:将数组转换字符串:String result=Arrays.toString(数组名);
4.2:对数组进行升序排序:Arrays.sort(数组名);
4.3:对已经排序序的数组进行二分查找:int index=Arrays.binarySearch(数组名, 要查找元素);
4.4:将原数组中指定长度复制新数组中:数据类型[] 新数组名=Arrays.copyOf(原数组名,长度);
4.5:将原数组中从指定起始位置到指定终止位置的元素复制新数组中:
数据类型[] 新数组名=Arrays.copyOfRange(原数组名,formIndex,toIndex);
4.6:给数组赋统一值:Arrays.fill(数组名, 值);
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
// //将数组转换字符串输出
// System.out.println("原数组为:"+Arrays.toString(nums));
// //给数组排序
// Arrays.sort(nums);
// //将数组转换字符串输出
// System.out.println("排序后数组为:"+Arrays.toString(nums));
//
// //获得具有从键盘上接收数据的能力
// Scanner input=new Scanner(System.in);
// System.out.println("请输入你要查找的整数:");
// int find=input.nextInt();
// //用二分查找法查找已排好序数组中是否存某个元素,返回查找元素索引位置,负数没有找到
// int index=Arrays.binarySearch(nums, find);
// if (index>=0) {
// System.out.println(find+"在数组中索引位置为:"+index);
// }else {
// System.out.println("数组中查无此元素");
// }
// //声明一个新数组
// int[] nums2=new int[nums.length+2];
// //将新数组转换为字符串输出
// System.out.println("新数组为:"+Arrays.toString(nums2));
// //将原数组的元素复制新数组
// nums2=Arrays.copyOf(nums, 4);
// //将新数组转换为字符串输出
// System.out.println("复制后,新数组为:"+Arrays.toString(nums2));
// //声明一个新数组
// int[] nums3=new int[10];
// //将新数组转换为字符串输出
// System.out.println("新数组为:"+Arrays.toString(nums3)+",新数组内存地址"+nums3);
// //将原数组的元素复制新数组
// nums3=Arrays.copyOfRange(nums, 1, 3);//不包括索引3位置的元素
// //将新数组转换为字符串输出
// System.out.println("复制后,新数组为:"+Arrays.toString(nums3)+",新数组内存地址"+nums3);
//声明一个新数组
int[] nums4=new int[4];
//将新数组转换为字符串输出
System.out.println("新数组为:"+Arrays.toString(nums4));
//给数组统一赋值
Arrays.fill(nums4, 6);
//将新数组转换为字符串输出
System.out.println("赋值后,新数组为:"+Arrays.toString(nums4));
}
5.动态参数:参数类型一样,参数可以由0个到多个组成.语法:数据类型…参数名.
5.1:动态参数的实参可以传递0个到多个值.
5.2:动态参数名在方法中当已知数组来用.
5.3:动态参数的实参可以直接传递一个数组.
5.4:方法形参可以有普通参数也可以有动态参数,
但是动态参数只能作方法的最后一个参数.
5.5:一个方法中最多只能有一个动态参数.
eg:public class Test {
public static void main(String[] args) {
//调用方法
double result1=add("aa");
System.out.println("结果1为:"+result1);
double result2=add("bb",2,4.5,90);
System.out.println("结果2为:"+result2);
//声明一个数组
double[] nums1= {11,44,22};
double result3=add("cc",nums1);
System.out.println("结果3为:"+result3);
}
/**
* 动态参数的方法
* @param nums
* @return
*/
public static double add(String sname,double...nums) {
System.out.println(sname+"正在计算中...");
//声明一个变量存总和
double sum=0;
//在方法中将动态参数当作已知数组来用
for (int i = 0; i < nums.length; i++) {
sum=sum+nums[i];
}
return sum;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
