本文详细介绍了Java中的数组，包括数组的定义、声明、分配空间、赋值、遍历等基本操作，以及动态参数、数组排序、二维数组的使用和特性。特别强调了数组的索引范围、默认值以及如何通过工具类如Arrays进行操作。此外，还涵盖了二维数组的声明、分配、赋值和遍历，以及动态参数的使用和异常处理的概念。
1.数组:
在内存内开辟一组连续空间来存值叫数组.
1.1 数组也是一种变量,也是一种引用数据类型.
1.2 数组由四个组成部分
数组名,数据类型,元素,索引(下标).
1.3 类型
同一个数组中,元素的数据类型相同的;不同的数组数据类型可以是java中任意类型.
1.4 索引
数组的索引从0开始.
1.5 访问数组中某个空间元素
数组名[索引].
1.6 空间
数组一但分配了空间,它的长度是固定的.
1.7长度
数组的长度:数组名.length
1.8 范围
数组的索引范围在:0~数组名.length-1
数组的索引如果超过范围报:ArrayIndexOutOfBoundsException
1.9 使用
数组只要分配空间就可以使用.
1.10 默认值
数组如果分配空间后,不赋值有默认值:
String类型数组,默认值null
int类型数组,默认值0
double类型数组,默认值0.0
char类型数组,默认值/u0000,在window系统上看着像空格
boolean类型数组,默认值false
1.11 输出
数组如果直接输出,输出的是内存地址.
2.数组的使用:
2.1:声明数组语法:
数据类型[] 数组名;(推荐)
数据类型 数组名[];
eg://声明数组,存学生姓名
String[] studentNames;
//声明数组,存学生年龄
int studentAges[];
2.2:给数组分配空间:
语法:
-
给已经声明的数组分配空间:
数组名=new 数据类型[长度];
-
在声明数组的同时分配空间语法:
数据类型[] 数组名=new 数据类型[长度];
数据类型 数组名[]=new 数据类型[长度];
//eg://给已经声明的数组分配空间
studentNames=new String[3];
studentAges=new int[3];
//在声明数组的同时赋值,存学生身高
double[] studentHeight=new double[4];
2.3:给数组赋值:
2.3.1:动态赋值
适用于所有数组.
注意: 只有分配空间的数组,才可以使用动态赋值.
动态赋值的语法:数组名[索引]=值;
//eg://给数组动态赋值
studentNames1[0]="张三";
studentNames1[1]="李四";
studentNames1[2]="王五";
2.3.2:静态赋值
适用于对数组中元素已知的情况.
2.3.2.1:静态赋值的第一种语法,在声明数组的同时给数组赋值:
数据类型[] 数组名=new 数据类型[]{值1,值2…};
可以写成:
数据类型[] 数组名;
数组=new 数据类型[]{值1,值2…};
eg://声明数组的同时,静态赋值
String[] studentNames2=new String[] {"赵六","钱七","老王","马云"};
int[] studentAges2;
studentAges2=new int[] {17,18,19};
2.3.2.2:静态赋值的第二种语法,在声明数组的同时给数组赋值:
数据类型[] 数组名={值1,值2…};
eg:double[] studentHeight2= {1.7,1.8,1.9};
2.4:遍历数组:
遍历:访问数组中每个空间的元素的值.
2.4.1:用for循环遍历
//eg://用for循环遍历数组
for(int i=0;i<studentNames1.length;i++) {
System.out.println("姓名为:"+studentNames1[i]);
}
2.4.2:(扩展)用增强版for循环(foreach循环)遍历:
只用于访问数组和集合中每个元素.
语法:
for(数据类型 别名:数组/集合){
}
注意: 别名指代当前遍历集合中当前元素.数据类型指代遍历每个元素的类型.
eg://用增强for循环遍历
for (String stu : studentNames2) {
System.out.println(stu);
}
3.数组的扩容
3.1:自定义数组:
声明一个新数组,长度大于原数组,将原数组的元素复制过来.
//eg:/*第一种:将原数组长度扩容到5*/
//声明一个长度为5新数组
int[] nums2=new int[5];
//将原数组的元素复制新数组中
for (int i = 0; i < nums1.length; i++) {
nums2[i]=nums1[i];
}
3.2:工具类1
Arrays.copyOfRange(原数组,起始索引,终止索引);不包含终止索引
//将原数组的元素复制到新数组,复制时原数组的长度不够,补默认值.
int[] nums3=Arrays.copyOfRange(nums1, 0, 5);
3.3:工具类2
Arrays.copyOf(原数组, 长度);
/*第三种:将原数组长度扩容到5*/
int[] nums4=Arrays.copyOf(nums1, 5);
4.动态参数(可变长参数)
参数个数可以是0个到多个.
语法:
数据类型…参数;
- 动态参数的实参可以0个到多个参数.
- 动态参数在方法中当作数组来用.
- 动态参数的实参可以直接传数组.
- 一个方法中只能有一个动态参数.
- 动态参数只能作方法的最后一个参数.
//eg:
public class VariableElement {
public static void main(String[] args) {
//调用方法
double result1=sum();
double result2=sum(11.1,3.14,33);
//动态参数的实参可以直接传数组
double[] count= {33,11,77};
double result3=sum("aa",count);
System.out.println("结果为:"+result3);
}
/**
* 动态参数的使用方法
* @param num 动态参数
* @return 数字之和
*/
public static double sum(double...num) {
//声明一个变量存总和
double sum=0;
//在方法中将动态参数作为数组用
for (int i = 0; i < num.length; i++) {
sum=sum+num[i];
}
return sum;
}
/**
* 动态参数的使用方法
* @param num 动态参数
* @return 数字之和
*/
public static double sum(String name,double...num) {
System.out.println(name+"正在计算中...");
//声明一个变量存总和
double sum=0;
//在方法中将动态参数作为数组用
for (int i = 0; i < num.length; i++) {
sum=sum+num[i];
}
return sum;
}
}
5.数组排序
5.1:求最大值和最小值
//eg:
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
//声明一个变量存最大值,默认数组第一个空间是最大值
int max=nums[0];
//声明一个变量存最小值,默认数组第一个空间是最小值
int min=nums[0];
//数组中其他元素依次与最大值或最小值比较
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);
}
5.2:冒泡排序:
第一轮从第一个元素开始两两比较,比到最后一个数,每轮比出当前所有数中最大值或最小值,下一轮又从第一个元素开始两两比较,比出剩下数中最大值或最小值,依次类推.
//eg:
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前原数组为:");
for (int n: nums) {
System.out.print(n+",");
}
System.out.println();
/*冒泡排序*/
//外层循环控制比较轮数
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("排序后原数组为:");
for (int n: nums) {
System.out.print(n+",");
}
System.out.println();
}
5.3:选择排序
第一轮从第一个元素开始依次与后面每个元素比较,比到最后一个数,每轮比出当前所有数中最大值或最小值,下一轮又从剩下数中第一个元素开始依次与后面每个元素比较,比到最后一个数,比出剩下数中最大值或最小值,依次类推.
//eg:
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前原数组为:");
for (int n: nums) {
System.out.print(n+",");
}
System.out.println();
/*选择排序*/
//外层循环控制轮数,i表达轮数
for(int i=0;i<nums.length-1;i++) {
//内层循环控制比较次数,num[i]表示剩下数列中第一个数,num[j]表示每一个要与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("排序前原数组为:");
for (int n: nums) {
System.out.print(n+",");
}
System.out.println();
}
5.4:jdk排序
Arrays.sort(数组名);默认升序排序.
6.(扩展)Arrays:数组的工具类.
- 给数组进行升序排序:Arrays.sort(数组名);
- 复制原数组中指定长度生成一个新数组
Arrays.copyOf(原数组名, 长度); - 复制原数组中从指定起始索引,复制到终止索引
Arrays.copyOfRange(原数组名, int from, int to) - 将数组转换为字符串:Arrays.toString(数组名);
- 对已经排好序的数组进行二分查找:Arrays.binarySearch(数组名,要查找的数);
- 对数组统一赋相同的值:Arrays.fill(数组名, 值);
eg:public static void main(String[] args) {
// 准备一个数组
int[] nums = {5, 2,5,5, 8, 1, 7, 6, 3 };
//将数组转换为字符串输出
System.out.println("排序前原数组为:"+Arrays.toString(nums));
//jdk中Arrays自带的方法排序
Arrays.sort(nums);
//将数组转换为字符串输出
System.out.println("排序后数组为:"+Arrays.toString(nums));
//获得具有从键盘上接收数据的能力
Scanner input=new Scanner(System.in);
System.out.println("请输入一个正整数:");
int find=input.nextInt();
//用二分查找法判断已经排好序的数组中是否包含输入要查找的数
//将当前数列中mid= (最大索引+最小索引)/2
//如果find>nums[mid],下次(最大索引+mid+1)/2
//如果find<nums[mid],下次(mid-1+最小索引)/2
int index=Arrays.binarySearch(nums,find);
if (index>=0) {
System.out.println("数组中包含要查找的数:"+find+",它在数组中位置为:"+index);
}else {
System.out.println("数组中查无此数!");
}
//声明一个数组,给数组统一赋值
int[] nums2=new int[5];
Arrays.fill(nums2, 6);
System.out.println("数组为:"+Arrays.toString(nums2));
}
题目:随机生成一个两位数,从键盘上接收你猜的数,如果猜对了,就不用再猜,如果猜错了,告诉猜大了,还是猜小了,然后接着猜,直到猜对了就不用再猜?
注意://生成随机两位数
int num=(int)(Math.random()*90+10);
二维数组
1.一维数组
在内存开辟一段连续的空间,每个空间存一个数.
2.二维数组
在内存开辟一段连续的空间,每个空间存一个一维数组.
n维数组
在内存开辟一段连续的空间,每个空间存一个(n-1)维数组.
3.二维数组的特征:
- 1:二维数组也是一种变量,也是一种引用数据类型.
- 2:二数组由四个组成部分:数组名,数据类型,元素(一维数组),索引(下标,二维数组的索引, 每个空间中一维数组的索引).
- 3:同一个二维数组中,元素的数据类型相同的;不同的二维数组数据类型可以是java中任意类型.
- 4:二维数组的索引从0开始,且每个空间的一维数组的索引也是从0开始.
- 5:访问二数组中某个空间元素:数组名[二维数组的索引],如果要访问二维数组中每个空间一维数组中每个值:数组名[二维数组的索引][一维数组的索引]
- 6:二维数组一但分配了空间,它的长度是固定的.
- 7:二维数组的长度:数组名.length
- 8:二维数组的索引范围在:0~数组名.length-1
数组的索引如果超过范围报:ArrayIndexOutOfBoundsException - 9:二维数组只要分配空间就可以使用.
- 10:二维数组如果分配空间后,不赋值有默认值,都是null.
二维数组中每个一维数组如果分配了空间不赋值:
String类型数组,默认值null
int类型数组,默认值0
double类型数组,默认值0.0
char类型数组,默认值/u0000,在window系统上看着像空格
boolean类型数组,默认值false
- 11:二维数组如果直接输出,输出的是内存地址.
4.二维数组的使用
4.1:二维数组的声明的语法:
数据类型[][] 数组名;(推荐)
数据类型 数组名[][];
eg://声明二维数组
String[][] studentNames1;
int studentAges1[][];
4.2:二维数组分配空间
二维数组的空间的长度一定要分配,每个一维数组的长度可以统一分 配,也可单独分配(当二维数组中每个一维数组的长度不相同).
4.2.1:对已经声明的二维数组分配空间:
- 数组名=new 数据类型[二维数组的长度][一维数组的长度]
(二维数组中每个一维数组的长度相同且固定.)
eg://对已声明二维数组分配空间
studentNames1=new String[3][2];
- 数组名=new 数据类型[二维数组的长度][]
(二维数组中每具一维数组的长度没分配,可以手动分配)
//eg:studentAges1=new int[3][];
//给二维数组的每个一维数组单独分配空间
//studentAges1[0]就是一维数组
studentAges1[0]=new int[3];
studentAges1[1]=new int[2];
studentAges1[2]=new int[1];
4.2.1:在声明二维数组的同时分配空间的语法
- 数据类型[][] 数组名=new 数据类型[二维数组的长度][一维数组的长度]
(二维数组中每个一维数组的长度相同且固定.)
eg;//声明二维数组的同时分配空间
String[][] studentNames2=new String[2][3];
- 数据类型[][] 数组名=new 数据类型[二维数组的长度][]
(二维数组中每具一维数组的长度没分配,可以手动分配)
//eg://给二维数组分配空间
int[][] studentAge2=new int[3][];
//单独为每一个一维数组分配空间
studentAge2[0]=new int[1];
studentAge2[1]=new int[2];
studentAge2[2]=new int[3];
4.3:二维数组赋值
4.3.1:静态赋值
当数组中元素已知
4.3.1.1:语法
-
数据类型[][] 数组名=new 数据类型[][]{{值11,值12},{值21}…};
-
数据类型[][] 数组名={{值11,值12},{值21}…};
//eg://声明数组的同时静态赋值
String[][] studentNames3=new String[][] {{"黄国栋","赖盛豪"},{"陈健"}};
int[][] studentAges3= {{18,16},{15}};
4.3.2:动态赋值
适用于所有情况.
- 语法:二维数组名[二维索引][一维索引]=值;
//eg://给数组动态赋值
studentNames2[0][0]="张三1";
studentNames2[0][1]="张三2";
studentNames2[1][0]="李四1";
studentNames2[1][1]="李四2";
4.4:二维数组遍历
eg:/*用嵌套for循环遍历*/
//外层循环遍历二维数组,i二维数组的索引
for (int i = 0; i < studentNames3.length; i++) {
//内层循环遍历每个一维数组每个空间,j一维数组的索引
for (int j = 0; j < studentNames3[i].length; j++) {
System.out.print(studentNames3[i][j]+",");
}
System.out.println();
}
System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
/*用嵌套增强版for循环遍历*/
//外层遍历的二维数组
for (int[] ages : studentAges3) {
//内层循环遍历每个一维数组
for (int a : ages) {
System.out.print(a+",");
}
System.out.println();
}
System.out.println("---------------------------------------------");
/*用for循环配合Arrays.toString()历*/
for (int i = 0; i < studentAges3.length; i++) {
System.out.println(Arrays.toString(studentAges3[i]));
}
5.二维数组的练习(杨辉三角)
//eg:
public static void main(String[] args) {
//获得具有从键盘上接收数据的能力
Scanner input=new Scanner(System.in);
System.out.println("请输入杨辉三角行数:");
int row=input.nextInt();
if (row>0) {
//声明一个二维数组存杨辉三角
int[][] nums=new int[row][];
/*初始化杨辉三角*/
//外层循环控制行数
for (int i = 0; i < nums.length; i++) {
//先给二维数组每个一维数组分配空间
nums[i]=new int[i+1];
//内层循环控制一维数组中每个值
for (int j = 0; j < nums[i].length; j++) {
//如果是当前行的第一个数或最后一个数,值为1
if (j==0||j==nums[i].length-1) {
nums[i][j]=1;
}else{
nums[i][j]=nums[i-1][j]+nums[i-1][j-1];
}
}
}
//输出杨辉三角
for (int[] ns : nums) {
for (int n : ns) {
System.out.print(n+"\t");
}
System.out.println();
}
} else {
System.out.println("你输入的行数有误!");
}
}
6.(扩展)文档注释
/**注释内容 */,只能用类,方法成员变量的前面.
6.1:解释说明作用
说明这个类,这个方法,这个变量的作用.
6.2:根据文档注释生成javadoc文档
生成javadoc文档:package explore中选中项目-》鼠标右键-》export-》java/javadoc-》下步-》选中要生成文档注释的项目，同时在destination后面选择 文档生成的目的地-》下一步，下一步-》在vm option选择下写字符编码-encoding UTF-8 -charset UTF-8 -》下一步，点完成。
6.3:方便调用时说明.
7.(扩展)代码出错
java中运行出错叫异常,bug,调试错误叫debug.
- 1:代码一写完,编辑器就报红色X或者一条红色线,也编译出错.
原因:代码语法有问题或者标点符号有问题. - 2:代码写完后编辑器不报错,但是运行后报错或者输出的结果不是想要的结果.
原因:程序代码逻辑写得有问题. - 3:程序调试(debug):解决运行出错.
- 3.1:代码调试:
原理:代码从main方法开始由上到下执行.
做法:在认为出错的地方输出一条语句.
System.out.println(); - 3.2:断点调试:
作用:调试bug;观察代码执行流程.
步骤：
3.2.1:在认为在错误的代码前设置断点.
3.2.2:启动调试运行.(虫子按纽)
3.2.3:程序执行到断点会停止下来,让你一步一步执行,观察代码执行流程以及变量变化.
按F5:单步跳入,跳转到代码的底层去执行.
按F6:单步跳过,执行完当前行的代码,再执行下一行代码
3.2.4:通过观察代码执行流程和变量变化,找到错误的地方,解决bug.
3.2.5:取消断点.
- 3.1:代码调试:
个人笔记，思路，仅供参考
扫一扫
5922
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
