数组的特点：
(1)可以存储多个数据
(2)多个数据的类型必须保持一致
(3)数组的长度一旦确定,将永远不可以发生改变
1.数组变量定义格式一： 推荐使用
数据类型[] 数组名称;
2.数组变量定义格式二： 不推荐使用的
数据类型 数组名称[];
数组的第一种初始化方式(动态初始化: 指定数组长度)
1.格式:
数据类型[] 数组名称 = new 数据类型[长度];
2.格式解释:
(1)左侧数据类型: 表示该数组容器中可以存储什么类型的数据
(2)左侧[]: 代表数组的意思
(3)数组名称: 就是一个标识符,方便使用数组
(4)=: 表示赋值的意思,把=号右侧的数组容器在内存中的地址值,赋值给=号左侧的数组变量
(5)new: JVM在内部创建数组的过程
(6)右侧数据类型: 和左侧保持一致
(7)长度: 规定了数组容器中可以存储多少个数据
public class Demo03ArrayInit {
public static void main(String[] args) {
//(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
int[] arrayA = new int[3];
//(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
double[] arrayB = new double[7];
//(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC
char[] arrayC = new char[5];
}
}
数组的第二种初始化方式(标准格式静态初始化: 指定元素)
1.格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...,元素n};
2.注意:
(1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
(2)右侧[]中不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
(3)int类型的数组元素可以有字符char 如int[] a = new int[]{1,2,3,‘a‘} 这里的a输出的是97
public class Demo04ArrayInit {
public static void main(String[] args) {
//(1) 创建一个int类型的数组, 存储多个int数据100, 200, 300, 给该数组起个名称叫做arrayA
int[] arrayA = new int[]{100, 200, 300};
//(2) 创建一个double类型的数组, 存储多个double数据1.1, 2.2, 3.3, 4.4, 给该数组起个名称叫做arrayB
double[] arrayB = new double[]{1.1, 2.2, 3.3, 4.4};
//(3) 创建一个char类型的数组, 存储多个char数据 ‘真‘, ‘的‘, ‘好‘, ‘想‘, ‘你‘, 给该数组起个名称叫做arrayC
char[] arrayC = new char[]{‘真‘, ‘的‘, ‘好‘, ‘想‘, ‘你‘};
}
}
数组的第三种初始化方式(简化格式静态初始化: 指定元素)
1.格式:
数据类型[] 数组名称 = {元素1,元素2,...,元素n};
2.注意:
(1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
(2)不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
(3)虽然没有写new,但是底层仍然有new的过程,完成数组的创建
(4)动态初始化和标准格式的静态初始化数组,可以分成两步完成
(5)简化格式静态初始化,只能一步完成,不可以分成两步(java中的用法规定)
public class Demo05ArrayInit {
public static void main(String[] args) {
//(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
int[] arrayA = {100, 200, 300};
//(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
double[] arrayB = {1.1, 2.2, 3.3, 4.4};
//(3)创建一个char类型的数组,存储多个char数据‘真‘,‘的‘,‘好‘,‘想‘,‘你‘,给该数组起个名称叫做arrayC
char[] arrayC = {‘真‘, ‘的‘, ‘好‘, ‘想‘, ‘你‘};
int num;
num = 100;
System.out.println(num);
num = 200;
System.out.println(num);
//----------------以下内容作为了解--------------------
//(4)动态初始化和标准格式的静态初始化数组,可以分成两步完成
int[] arr;
arr = new int[3];//动态初始化
//....
arr = new int[]{10,20,30,50,80};//标准格式静态初始化
//arr = {100,200,300,500};//错误的: 不允许
int[] arr2 = {100,200,300,500};
}
}
数组的使用:
1.数组名称: 代表数组在内存空间中的地址值,是一个十六进制的int数字
2.索引编号:
(1)数组中的每个数据,称为数组元素
(2)数组为其内部的每个元素进行编号,专业术语叫做索引(角标),从0开始到数组长度减1
(3)索引编号必须是一个>=0的int数据
3.数组元素的访问: 数组名称[索引编号];
array[0]: 代表数组array中索引编号为0的元素
array[2]: 代表数组array中索引编号为2的元素
4.获取数组长度(数组中可以存储元素的个数)
每个数组内部都有一个length属性,其实就是一个int变量,记录了该数组中可以存储的元素的数量
使用格式:
数组名称.length: 获取数组长度,其实一个int数字
注意:
length后面没有(),添加()是错误的
2.1 java中的内存分配
1.方法区: 存储可以运行的class文件。
2.方法栈: 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
3.堆内存 存储对象或者数组，new来创建的，都存储在堆内存。
4.寄存器 给CPU使用，和我们开发无关 不关心
5.本地方法栈 JVM在使用操作系统功能的时候使用，和我们开发无关。 不关心
今天主要使用:
1.栈内存: 运行方法的,存储方法中定义的变量的
2.堆内存: 存储的是所有new出来的内容
/*
一个数组内存图
1.动态初始化数组,元素有默认值
(1)基本类型
整数数组: 0
小数数组: 0.0
布尔数组: false
字符数组: 空白字符
(2)引用类型
所有引用类型数组: null
2.注意
(1)数组变量保存数组在堆内存空间的地址值
(2)通过数组变量中保存的地址值,找到堆内存空间的具体的数组
(3)再通过索引编号,找到要操作的该数组中的具体的某个元素
*/
public class Demo01OneArray {
public static void main(String[] args) {
//定义int数组one,并动态初始化
int[] one = new int[3];
System.out.println(one);//地址值
System.out.println(one[0]);//默认值:0
System.out.println(one[1]);//默认值:0
System.out.println(one[2]);//默认值:0
one[0] = 100;
one[1] = 200;
one[2] = 300;
System.out.println(one);//地址值
System.out.println(one[0]);//100
System.out.println(one[1]);//200
System.out.println(one[2]);//300
}
}
数组遍历：
就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
注意for循环的结束条件的两种写法:
<=array.length - 1
<array.length
/*
需求:
求int数组元素最大值
实现步骤:
1.定义int数组array,并根据题目需求进行初始化
2.假设索引为0的元素是最大的,保存到int变量max中
3.使用for循环依次获取后面(从索引1开始)的每个元素
3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
3.2 把当前元素值,赋值给max
4.for循环结束后,打印max的值
注意:
1.求数组最大值/最小值/求和/计数,这些变量必须在for循环的前面定义
2.for循环内部完成计算
3.for循环的后面进行打印输出
*/
public class Demo03ArrayMax {
public static void main(String[] args) {
//1.定义int数组array,并根据题目需求进行初始化
int[] array = {5, 15, 2000, 10000, 100, 4000};
//2.假设索引为0的元素是最大的,保存到int变量max中
int max = array[0];
//3.使用for循环依次获取后面(从索引1开始)的每个元素
for (int i = 1; i < array.length; i++) {
//3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
if (array[i] > max) {
//3.2 把当前元素值,赋值给max
max = array[i];
}
}
//4.for循环结束后,打印max的值
System.out.println("最大值: "+max);
}
}
import java.util.Random;
public class Demo08 {
public static void main(String[] args) {
Random a =new Random();
int[] array01 = new int[5]; //初始化一个数组
int b =0; //while步进计数
int count =0; //数组计数
boolean flag =false;
while (b<5) {
b++;
int num = a.nextInt(100); //获得随机数0~99的随机数
num =num+1; //获得1~100之间的随机数
for (int i = 0; i < array01.length; i++) {
if (num == array01[i]) { //判断获得的随机数在array01数组中是否已存在
b = b - 1;
flag = true;
break;
}
}
if (flag) {
flag =false;
continue;
} else {
array01[count]=num;
count++;
}
}
for (int i = 0; i < array01.length; i++) {
System.out.println(array01[i]);
}
}
}
int[] array = new int[]{1, 2, 4, 6, 4, 2, 1, 3, 0, 9};
int count = 0;
boolean flag = false;
int[] a = new int[array.length]; // 临时存储的数组
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] == array[j]) {
flag = true;
break;
}
}
if (flag) {
flag = false;
continue;
} else {
a[count] = array[i];
count++;
}
}
int[] after_array = new int[count];
System.arraycopy(a, 0, after_array, 0, count);
for (int i = 0; i < after_array.length; i++) {
System.out.print(after_array[i] + " ");
}
数组操作的常见问题一:
数组索引越界(超出了范围)异常
1.问题描述:
java中使用java.lang.ArrayIndexOutOfBoundsException类用来描述索引越界问题的
2.产生原因:
当使用int数字作为索引获取数组元素时,索引值已经超出了数组的索引范围,无法获取该索引对应的元素
(1)打印异常信息
(2)停止程序的执行
3.解决方案:
(1)不使用超出索引范围的int数字来获取数组元素
(2)修改索引越界的数字,让它在数组索引范围内
数组操作的常见问题二:
空指针异常
1.问题描述:
java中使用java.lang.NullPointerException类,来描述空指针异常
2.产生原因:
null是引用类型的空常量,可以给任意引用类型的变量赋值,但是一旦引用变量的值是null时,说明该引用变量已经不再执行堆内存的任何空间,也就不能范围堆内存空间中的元素了数组变量的值是null时,说明该数组变量已经不再执行堆内存空间的任何数组了,所以就无法通过索引的方式访问数组元素了,只要访问,就会报出空指针异常
(1)打印异常信息
(2)停止程序的执行
3.解决方案:
(1)不使用值是null的数组变量来获取数组元素
(2)找到数组变量值是null的地方,给数组变量重新赋值,让改数组变量重新指向一个新的数组空间
break的作用:
1.可以使用在循环和switch语句中,其它位置不可用
2.break是用来结束所在的循环的
(1)一旦执行break,本次循环的循环体的后续代码不再执行
(2)一旦执行break,剩余次数的循环也不再执行
(3)相当于从执行break的位置,直接跳转到break所在的循环的后面执行
public class Demo04Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 5 == 0) {
break;
}
System.out.println("HelloWorld....." + i);
}
System.out.println("main....end....");
}
}
continue的作用:
1.提前结束本次循环,继续进行下一次循环
2.continue只影响本次循环,break影响所有循环
3.continue只能使用在循环语句中
public class Demo05Continue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 5 == 0) {
continue;
}
System.out.println("HelloWorld....." + i);
}
System.out.println("main....end....");
}
}
/*
题目：将1~100之间不包括7和7的倍数的数字打印出来
字包含7或者是7的倍数:
包含7: 个位是7 或者 十位是7
7的倍数: 数字%7 == 0
实现步骤:
1.使用for循环遍历获取1到100之间的数字
2.计算当前数字的个位和十位,分别保存到int变量ge和shi中
3.判断: 如果 个位是7 或者 十位是7 或者 当前数字是7的倍数,执行continue
4.如果不满足以上条件: 输出该数字
*/
public class Test06ContinueFQG {
public static void main(String[] args) {
//1.使用for循环遍历获取1到100之间的数字
for (int num = 1; num <= 100; num++) {
//2.计算当前数字的个位和十位,分别保存到int变量ge和shi中
int ge = num%10;//个位
int shi = num/10%10;//十位
//3.判断: 如果 个位是7 或者 十位是7 或者 当前数字是7的倍数,执行continue
if ((ge == 7 || shi == 7) || (num % 7 == 0)) {
continue;
}
//4.如果不满足以上条件: 输出该数字
System.out.println(num);
}
}
}
原文：https://www.cnblogs.com/uoi123/p/14979832.html