8、数组
1、数组的概念
变量一次只能存放一个值。
数组的概念:是一种容器,可以同时存放多个数据值。
数组的特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一(比如全是int)
3.数组的长度在程序运行期间不可改变
public class Demo01Array {
public static void main(String[] args) {
int score1 = 100;
int score2 = 98;
int score3 = 99;
System.out.println(score3);//99
score3 = 100;
System.out.println(score3);//100
}
}
2、数组的定义格式一_动态初始化
package com.itheima.array;
public class Demo1Array{
/*
数组的定义格式:
1:数据类[]数组名;
2:数据类型数组含[];
*/
public static void main(String[] args) {
//数据类型[]数组名;
//定义了一个int类型的数组,数组名叫arr
//这里虽然是定义了一个数组,但也仅仅只是一个数组类型的[变量],变量没有进行初始化或赋值,就直接使用了,这就是错误原因。
arr int[] arr;
//System.out.println(arr);//错误
//定义了一个char类型的数绍,数组名叫cAarr
cArr char[] cArr;
//System.out.println(cArr);//错误
}
}
数组的初始化:在内存当中创建一个数组,并且向其中赋子一些默认值。
两种常见的初始化方式:
1.动态初始化(指定长度)
2.静态初始化(指定内容)
动态初始化数组的格式:
数据类型[] 数组名称= new 数据类型 [数组长度];
解析含义:
左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型
左侧的中括号:代表我是一个数组
左侧数组名称:给数组取一个名字
右侧的new:代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持一致右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字
package com.itheima.array;
public class Demo02Array{
/*
数组的动态初始化:
在初始化的时候,需要手动指定数组的长度,系统会为数组容器分配初始值。
动态初始化格式:
数据类型[ ]数组名=new数据类型【数组的长度】;
注意:
打印数组变量的时候,会打印出数组的内存地址
[I010f87f48:
@:分隔符
[:当前的到间是一个数组类型
I:当前数细容器中所存储的数据类型
10f87f48:十六进制内存地址
0123456789abcdef
*/
public static void main(String[] args) {
//格式:数据类型[] 数组名称 =new 数据类型 [数组长度]
//通过new关键字创建了一个int类型的数组容器,该容器可以存储5个int类型的整数,该容器被arr数组变量所记录
int[] arr = new int[5];
System.out.println(arr);//[I@10f87f48
byte[] bArr = new byte[3];
System.out.println(bArr);//[B@b4c966a
}
}
public class Demo0lArray{
public static void main(String[] args) {
//创建一个数组,里面可以存放300个int数据
//格式:数据类型[] 数组名称 =new 数据类型 [数组长度]
int[] arrayA = new int[300];
//创建一个数组,能存放10个double类型的数据
double[] arrayB = new double[10];
//创建一个数组,能存放5个字符串
String[] arrayC = new String[5];
}
}
3、数组的定义格式二_静态初始化
package com.itheima.array2;
public class Demo1Array{
/*
数组静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度
完整格式:
数据类型[]数组名=new 数据类型[]{数据1,数据2,数据3.…};
简化格式:
数据类型[]数组名={数据1,数据2,数据3.…};
*/
public static void main(String[] args) {
//数据类型[]数组名=new 数据类型[]{数据1,数据2,数据3.…};
int[] arr = new int[]{11, 22, 33};
System.out.println(arr[0]); //11
System.out.println(arr[1]); //22
System.out.println(arr[2]); //33
//数据类型[]数组名={数据1,数据2,数据3.…};
int[] arr2 = {44, 55, 66}; //简化格式一样可以在内存空间开辟出地址
System.out.println(arr2[0]); //44
System.out.println(arr2[1]); //55
System.out.println(arr2[2]); //66
}
}
public class Demo02Array{
public static void main(String[] args) {
//直接创建一个数组,里面装的全都是int数字,具体为:5、15、25
int[] arrayA = new int[]{5, 15, 25, 40};
//创建一个数组,用来装字符串:"Hello”、"World”、"Java”
String[] arrayB = new String[]{"Hello", "World", "Java"};
}
4、数组的定义格式三_省略的静态初始化
使用静态初始化数组的时候,格式还可以省略一下。
标准格式:
数据类型 [ ] 数组名称 = new 数据类型 [ ] {元素1,元素2,.};
省略格式:
数据类型 [ ] 数组名称 = {元素1,元素2,…};
注意事项:
1.静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
2.静态初始化标准格式可以拆分成为两个步骤。
3.动态初始化也可以拆分成为两个步骤。
4.静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。
使用建议:
如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。
public class Demo03Array{
public static void main(String[] args) {
//省略格式的静态初始化
int[] arrayA = {10, 20, 30};
//静态初始化的标准格式,可以拆分成为两个步骤i
int[] arrayB;
arrayB = new int[]{11, 21, 31};
//动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayC = new int[5];
//静态初始化的省略格式,不能拆分成为两个步骤。
//int[]arrayD;
//arrayD={10,20,30};
}
}
5、访问数组元素进行获取
package com.itheima.array;
public class Demo03Index{
/*
数组动态初始化:
初始化的时候,手动指定数组长度,系统会为数组容器分配初始值。
数组的元素访问格式:
数组名[索引]
索引:数组中数据的编号方式,编号从0开始
作用:访问数组容器中的空间位置
注意:
数组在创建完毕后,即使没有赋值,也可以取出,但取出的元素都是默认初始化值.
*/
public static void main(String[] args) {
//格式:数据类型[] 数组名称 =new 数据类型 [数组长度]
//通过new关键字创建了一个int类型的数组容器,该容器可以存储5个int类型的整数,该容器被arr数组变量所记录
int[] arr = new int[3];//0 1 2
System.out.println(arr);//[I@10f87f48
//数组名[索引] 访问数组容器中的空间位置
System.out.println(arr[0]); //0 系统自动分配的默认初始化值
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
System.out.println(----------------);
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
System.out.println(arr[0]); //11
System.out.println(arr[1]); //22
System.out.println(arr[2]); //33
}
}
直接打印数组名称,得到的是数组对应的;内存地址哈希值。
二进制:01
十进制:0123456789
16进制:0123456789abcdef
访问数组元素的格式:数组名称[索引值]
索引值:就是一个int教字,代表数组当中元素的编号。
【注意】索引值从0开始,一直到“数组的长度-1”为止。
public class Demo04ArrayUse{
public static void main(String[] args){
//静态初始化的省略格式
int[] array = {10,20,30};//索引值分别为0号元素,1号元素和3号元素
System.out.println(array);//[I@75412c2f 内存地址哈希值 16进制的
//直接打印数组当中的元素
//格式:数组名称[索引值]
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30
System.out.println("=============");
//也可以将数组当中的某一个单个元素,赋值交给变量
int num = array[1];
System.out.println(num);//20
}
}
6、访问数组元素进行赋值
使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。
规则如下:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为‘\u0000’;
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null。
注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
public class Demo05ArrayUse{
public static void main(String[] args) {
//动态初始化一个数组
int[] array = new int[3];
System.out.println(array);//内存地址值
System.out.println(array[0]);//0,默认值是整数类型,那么默认为0
System.out.println(array[1]);//0,默认值是整数类型,那么默认为0
System.out.println(array[2]);//0,默认值是整数类型,那么默认为0
System.out.println("==============");
//将数据123赋值交给数组array当中的1号元素
array[1] = 123;
System.out.println(array[0]);//0
System.out.println(array[1]);//123
System.out.println(array[2]);//0
}
}
7、JAVA中的内存划分
Java的内存需要划分成为5个部分:
1.栈(Stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量:方法的参数,或者是方法{}内部的变量
作用域:一旦超出作用域,立刻从栈内存当中消失。
2.堆(Heap):凡是new出来的东西,都在堆当中。
堆内存里面的东西都有一个地址值:16进制堆内存里面的数据,都有默认值。规则:
如果是整数 默认为0
如果是浮点数 默认为0.0
如果是字符 默认为"\u0000’
如果是布尔 默认为false
如果是引用类型 默认为null
3.方法区(Method Area):存储.class相关信息,包含方法的信息。
4.本地方法栈(Native Method Stack):与操作系统相关。
5.寄存器(pcRegister):与CPU相关。
8、一个数组的内存图
public class Demo01ArrayOne(
public static void main(String[] args) {
int[] array = new int[3];//动态初始化
System.out.println(array);//地址值
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
System.out.println("==============");
//改变数组当中元素的内容
array[1] = 10;
array[2] = 20;
System.out.println(array);//地址值
System.out.println(array[0]);//0
System.out.println(array[1]);//10
System.out.println(array[2]);//20
}
}
9、两个数组的内存图
shift+F6 修改所有同类
10、两个引用指向同一个数组的内存图
11、常见问题_数组索引越界异常
数组的索引编号从0开始,一直到“数组的长度-1为止。
如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常
ArrayIndexOutOfBoundsException
原因:索引编号写错了。
解决:修改成为存在的正确索引编号。
public class Demo01ArrayIndex{
public static void main(String[] args) {
int[] array = {15, 25, 35};
System.out.println(array[0]);//15
System.out.println(array[1]);//25
System.out.println(array[2]);//35
//错误写法
//并不存在3号元素,所以发生异常
System.out.println(array[3]);
}
}
12、常见问题_空指针异常
所有的引用类型变量,都可以赋值为一个null值。但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。
如果只是赋值了一个null,没有进行new创建,
那么将会发生:
空指针异常 NullPointerException
原因:忘了new
解决:补上new
public class Demo02ArrayNul1{
public static void main(String[] args) {
int[] array = null;//赋值为一个null值。但是代表其中什么都没有。
array = new int[3]; //忘了写,补上new
System.out.println(array[0]);
}
}
13、获取数组的长度
如何获取数组的长度,格式:
数组名称.Length
可以简写为len
这将会得到一个int数字,代表数组的长度。
数组一旦创建,程序运行期间,长度不可改变
public class Demo03ArrayLength{
public static void main(String[] args) {
int[] arrayA = new int[3];
int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6, 7, 8, 8, 65, 4};
//数组名称.Length
int len = arrayB.length;
System.out.println("arrayB数组的长度是:"+len);
System.out.println("=============");
int[] arrayC = new int[3];
System.out.println(arrayC.length);//3
arrayC = new int[5];
System.out.println(arrayC.length);//5
}
}
14、数组的遍历输出
遍历数组,说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。
public class Test1Array{
/*
数组的遍历:通过循环获取数组中的所有元素(数)
动态获取数组元素个数:数组名.Length
*/
public static void main(String[] args) {
int[] array = {11, 22, 33, 44, 55, 11, 22, 33, 44, 55, 11, 22, 33, 44, 55};
//数组名.Length
System.out.println("arr数组中的元素个数为:" + array.length);
/*
for (int i = 0; i < 5; i++) {//手动写死了,不严谨,不推荐
System.out.println(array[i]);
}
*/
//array.Length;//长度
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
public class Demo04Array{
public static void main(String[] args) {
int[] array = {15, 25, 30, 40, 50};
//首先使用原始方式
System.out.println(array[0]);//15
System.out.println(array[1]);//25
System.out.println(array[2]);//30
System.out.println(array[3]);//40
System.out.println(array[4]);//50
System.out.println("=================");
//使用循环,次数其实就是数组的长度。
for (int i = 0; i < 5; i++) {
System.out.println(array[i]);
}
//int len=array.Length;//长度
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
int len= array.length;
for (int i = 0; i < len; i++) {
System.out.println(array[i]);
}
}
}
15、求出数组中的最值
public static void main(String[] args) {
/*
需求:从数组中查找最大值
int[] arr = {12,45,98,73,60};
实现步骤:
1.假设数组中的第一个元素为最大值
2.遍历数组,获取每一个元素,准备进行比较
3.如果比较的过程中,出现了比max更大的,让max记录更大的值
4.循环结束后,打印最大值。
*/
int[] arr = {12, 45, 98, 73, 60};
//1.假设数组中的第一个元素为最大值
int max = arr[0];
//2.遍历数组,获取每一个元素,准备进行比较
for (int i = 1; i < arr.length; i++) {
//3.如果比较的过程中,出现了比max更大的,让max记录更大的值
if (arr[i] > max) {
max = arr[i];
}
}
//4.循环结束后,打印最大值
System.out.println("最大值:" + max);
}
}
public static void main(String[] args) {
int[] array = {5, 15, 30, 20, 10000};
int max = array[0];//比武擂台
for (int i = 1; i < array.length; i++) {
//如果当前元素,比max更大,则换人
if (array[i] > max) {
max = array[i];
}
}
//谁最后最厉害,就能在max当中留下谁的战斗力
System.out.println("最大值:" + max);
}
}
16、数组元素反转
数组元素的反转:
本来的样子:[1,2,3,4]
之后的样子:[4,3,2,1]
要求不能使用新数组,就用原来的唯一一个数组。
public class Demo07ArrayReverse{
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};
//遍历打印数组本来的样子
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("============");
/*初始化语句:int min=0,max=array.length-1
条件判断:min<max
步进表达式:min++,max--
循环体:用第三个变量倒手
*/
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
//再次打印遍历输出数组后来的样子
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
17、数组作为方法参数_传递地址
任何数据类型都能作为方法的参数。
/*
数组可以作为方法的参数。
当调用方法的时候,向方法的小括号进行传参,
传递进去的其实是数组的地址值。
*/
public class Demo0lArrayParam{
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};
System.out.println(array);//地址值
printArray(array);//传递进去的就是array当中保存的地址值
System.out.println("==========AAA==========");
printArray(array);
System.out.println("==========BBB==========");
printArray(array);
}
/*
三要素
返回值类型:只是进行打印而已,不需要进行计算,也没有结果,用void
方法名称:printArray
参数列表:必须给我数组,我才能打印其中的元素。int[]array
*/
public static void printArray(int[] array) {
System.out.println("printArray方法收到的参数是:");
System.out.println(array);//地址值
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
18、数组作为方法返回值_返回地址
一个方法可以有0、1、多个参数;但是只能有0或者1个返回值,不能有多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回,怎么办?
解决方案:使用一个数组作为返回值类型即可。
任何数据类型都能作为方法的参数类型,或者返回值类型。
数组作为方法的参数,传递进去的其实是数组的地址值。
数组作为方法的返回值,返回的其实也是数组的地址值。
public class Demo02ArrayReturn{
public static void main(String[] args) {
int[] result = calculate(10, 20, 30);
System.out.println("main方法接收到的返回值数组是:");
System.out.println(result);
System.out.println("总和:" + result[0]);
System.out.println("平均数:" + result[1]);
}
public static int[] calculate(int a, int b, int c) {
int sum = a + b + c;//总和
int avg = sum / 3;//平均数
//两个结果都希望进行返回
//需要一个数组,也就是一个塑料兜,数组可以保存多个结果
/*
int[]array=new int[2];
array[e] = sum;//总和
array[1] = avg;//平均数
*/
int[] array = {sum, avg};
System.out.println("calculate方法内部数组是:");
System.out.println(array);//地址值
return array;
}
}
19、数组元素求和
import java.util.Scanner
public class Test3Array{
/*
需求:键盘录5个整数,存储到数组中,并对数组求和
思路:
1.创建键盘录入对象,准备键盘录入
2.定义一个求和交量,准备记录累加后的结果
3.动态初始化一个长度为5的int数组,准备存谢健盘录人的数值
4.将键盘录人的数值存能到数组中
5.遍历数组,取出每一个元素,并求和
6.输出总和
*/
public static void main(String[] args) {
//1.创建键盘录入对象,准备键盘录入
Scanner sc = new Scanner(System.in);
//2.定义一个求和交量,准备记录累加后的结果
int sum = 0;
//3.动态初始化一个长度为5的int数组,准备存谢健盘录人的数值
int[] arr = new int[5];
//4.将键盘录人的数值存能到数组中
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第" + (i + 1) + "个整数:");
//arr[i]=10;
arr[i] = sc.nextInt();
}
//5.遍历数组,取出每一个元素,并求和
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
//6.输出总和
System.out.println("sum:" + sum);
}
}
20、数组基本查找
/*
需求:
已知一个数组arr={19,28,37,46,5e};
键盘录入一个数据,查找该数据在数组中的索引,并在控制台输出找到的索引值。
思路:
1.定义一个数组,用静态初始化完成数组元素的初始化
2.键盘录人要查找的数据,用一个变量接收
3.定义一个索引变量,初始值为-1
4.遍历数组,获取到数组中的每一个元素
5.拿建盘录人的数据和数组中的每一个元素进行比较,如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
6.输出索引变量
*/
import java.util.Scanner;
public class Demo01Array {
public static void main(String[] args) {
// 1.定义一个数组,用静态初始化完成数组元素的初始化
int[] arr = {19, 28, 37, 46, 50};
// 2.键盘录入要查找的数据,用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要查找的元素:");
int num = sc.nextInt();
// 3.定义一个索引变量,初始值为-1
// 假设要查找的数据, 在数组中就是不存在的
int index = -1;
// 4.遍历数组,获取到数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
// 5.拿键盘录入的数据和数组中的每一个元素进行比较,如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
if (num == arr[i]) {
// 如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
index = i;
break;
}
}
// 6.输出索引变量
System.out.println(index);
}
}
21、评委打分
/*
需求:在编程竞赛中,有6个评委为参赛的选手打分,分数为0-100的整数分。
选手的最后得分为:去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。
思路:
1.定义一个数组,用动态初始化完成数组元素的初始化,长度为6
2.键盘录入评委分数
3.由于是6个评委打分,所以,接收评委分数的操作,用循环
4.求出数组最大值
5.求出数组最小值
6.求出数组总和
7.按照计算规则进行计算得到平均分 8.输出平均分
*/
import java.util.Scanner;
public class Demo01Array {
public static void main(String[] args) {
// 1.定义一个数组,用动态初始化完成数组元素的初始化,长度为6
int[] arr = new int[6];
// 2.键盘录入评委分数
Scanner sc = new Scanner(System.in);
// 3.由于是6个评委打分,所以,接收评委分数的操作,用循环
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第" + (i + 1) + "个评委的打分:");
int score = sc.nextInt();
if (score >= 0 && score <= 100) {
// 合法的分值
arr[i] = score;
} else {
// 非法的分值
System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
i--;
}
}
// 4.求出数组最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
// 5.求出数组最小值
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (min > arr[i]) {
min = arr[i];
}
}
// 6.求出数组总和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
// 7.按照计算规则进行计算得到平均分
int avg = (sum - max - min) / 4;
// 8.输出平均分
System.out.println(avg);
}
}