Java第5天学习内容：
数组(array)
一、数组的定义和使用
理解：数组是用来存储多个元素的容器。
特点：
1)数组是一种引用数据类型
2)同一数组中元素的数据类型是一致的
3)数组在堆内存中一旦被创建其长度就不可改变
数组的3种定义格式
构造出的数组都存放在堆内存中
1.数组的格式1(动态初始化-只告诉数组长度，数组的元素在具体应用中才知晓):
数据类型[] 数组名=new 数据类型[长度值];
//定义一个数组，存储5个int类型的元素
int[] arrayA=new int[5];
//定义一个数组，存储3个字符串的元素
String[] arrayB=new String[3];
//自定义一个数组，存储2个“萝卜”类型的元素
萝卜[] arrayC=new 萝卜[2];
2.数组的格式2(静态初始化-直接指定数组内的元素并且通过元素个数可知数组长度)
数据类型[] 数组名=new 数据类型[]{元素1,元素2...};
//定义一个数组，元素分别为 "张三","李四","王五"
String[] arrayA=new String[]{"张三","李四","王五"};
//定义一个数组，元素分别为 100,200,300
int[] arrayB=new int[]{100,200,300};
3.数组的格式3(简化的静态初始化-比较常用)
数据类型[] 数组名={元素1,元素2...};
//定义一个数组，元素分别为 "张三","李四","王五"
String[] arrayA={"张三","李四","王五"};
//定义一个数组，元素分别为 100,200,300
int[] arrayB={100,200,300};
数组的元素访问
索引：
数组为每一个元素分配的了一个编号，这个编号专业术语叫做【索引】，索引从0开始。
访问元素格式：数组名[索引]//同过这个索引访问到对应的元素
int[] array=new int[]{100,200,300};
System.out.println(array[0]); //100
System.out.println(array[1]); //200
System.out.println(array[2]); //300
array[1]=500; //把500赋值给 1索引的元素
System.out.println(array[0]); //100
System.out.println(array[1]); //500
System.out.println(array[2]); //300
二、Java的内存分配
Java虚拟机把内存划分为5个区域（栈、堆、方法区、本地方法栈、寄存器）
我们重点了解3个数据存放区域
栈：存储局部变量(即在方法中的变量)
堆：new出来的数据(都存放在堆内存中)
堆内存中的数据有一些特点
* 都有地址值
* 都有默认值(在静态创建数组时也有一个默认值的过程，只不过快速的被你新定义的值覆盖了)
各种数据类型的默认值：
整数 0
浮点数 0.0
字符 ‘\u0000’ (字符的默认值在unicode编码中表示为:0000)
布尔 false
引用数据类型(比如String类型) null
- 当没有引用指向堆内存中的数据时，堆内存中的数据就会变成垃圾，会被垃圾回收器(GC)在空闲时自动回收。
数组在内存中的分配：
堆内存的地址(0x666)
多个数组的内存分配：
数组之间的赋值-就是变量存储数组在堆内存中的地址
原理图：
方法区：字节码(.class文件)的相关信息
数组的常见问题
1.java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常
原因：索引超过了最小值或者最大值
2.java.lang.NullPointerException 空指针异常
原因：当一个变量的值为null时（这个变量没有引用任何堆内存中的数据）
而使用这个变量，就会出现空指针异常
在面向对象中如果一个对象为空，但通过这个对象引用该类的方法就会报空指针异常
获取数组的长度：数组名.length
(size 和 length都是长度的意思，size在list集合里面用，length多用数组里面(是数组的属性/方法)
size()方法：
List，Set和Map也有size()方法，所以准确说size()方法是针对集合而言，用来查看容器中有多少个元素。
length():
String提供length()方法来计算字符串的长度)
int[] array={1,2,3,4,5,6,7,8};
System.out.println(array.length); //8
三、数组的练习
1.遍历数组的元素
int[] array={100,200,300,400,500,600};
//i表示数组的索引
for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
2.求数组中元素的和(String类型的数组是不能求和的，最大值最小值也不能求)
/*
步骤：
1)定义求和变量sum，默认(初始)为0
2)遍历数组中的元素
3)把元素和sum累加起来
*/
int[] array={1,2,3,4,5};
//1) 定义求和变量
int sum=0;
//2） 遍历数组
for (int i = 0; i < array.length; i++) {
//3)把数组中的元素累加求和sum
sum+=array[i];//通过索引实现把每个索引所对应的元素求和
}
System.out.println("元素的和为："+sum);
3.求出数组中的最大值和最小值
步骤：
1)假设数组中0索引的元素为最大值max
2)遍历其他的元素和max比较
3)把较大的值重新赋值max
int[] array={1,-2,3,8,4,5};
//1)假设数组中0索引的元素为最大值max（或最小值min）
int max=array[0];//通过索引实现把每个索引的元素赋值给变量max
int min = array[0];
//2)遍历其他的元素和max比较
for(int i=1;i<array.length;i++){
//3)把较大的值重新赋值max
if(array[i]>max){
max=array[i];
}
}
//2)遍历其他的元素和min比较
for(int i=1;i<array.length;i++){
//3)把较大的值重新赋值min
if(array[i]<min){
min=array[i];
}
}
//循环结束之后，max存储的就是最大值
System.out.println("最大值为："+max);
//循环结束之后，max存储的就是最小值
System.out.println("最小值为："+min);
4.把一个数组中的元素翻转
核心思想是，从数组的两端向中间遍历
/*
步骤：
1)定义开始和结束的索引
int start=0; //开始索引
int end=array.length-1; //结束索引
2)从数组的两头往中间进行遍历
循环条件：start<end
每次循环之后：start++ , end--
3)每次循环，需要对array[start]和array[end]进行互换
采用第三方变量实现
*/
int[] array={1,2,3,4,5};
//1) 2)从数组的两头往中间进行遍历
for(int start=0,end=array.length-1;start<end;start++,end--){//for循环的条件，括号中必须有两个;
//每次循环，需要对array[start]和array[end]进行互换
//通过索引实现其对应的元素的互换
int temp=array[start];
array[start]=array[end];
array[end]=temp;
}
//再对数组进行遍历，打印就是翻转后的元素
for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
数组作为参数的内存图解：
5.数组的合并(merge)
内存图解：
public static void merge(){
int[] arrayA={1,3,4,5,53,534};
int[] arrayB = {32,121,42,332};
System.out.println("数组A的长度为："+arrayA.length);
System.out.println("数组B的长度为："+arrayB.length);
System.out.println("------------------------------");
int[] arrayC = new int[arrayA.length+arrayB.length];//动态new一个数组C其长度为数组A和B的长度和
for (int i = 0; i < arrayA.length; i++) {
arrayC[i] = arrayA[i];//通过索引把arrayA数组各索引所对应的元素赋值给arrayC数组各索引（arrayC数组从索引为0处存储接受赋值）
}
for (int i = 0; i < arrayB.length; i++) {
arrayC[i+arrayA.length] = arrayB[i];//通过索引把arrayB数组各索引所对应的元素赋值给arrayC数组各索引（arrayC数组从索引为i+arrayA.length处存储接受arrayB的赋值）
}
System.out.println("数组C的长度为："+arrayC.length+" 分别是：");
for (int i = 0; i < arrayC.length; i++) {
System.out.print(arrayC[i]+" ");//通过循环打印出数组索引所对应的元素
}
}
小练习
第一题:
在main方法中定义3个变量：int a = 50; int b = 30; int c = 80;
并依次完成以下要求：
定义方法getMin()利用三元运算符求出a、b、c中最小的数并打印到控制台上；
package com.exam;
/**
* 通过三元运算符求出三个数的最小值
*/
public class ExamTest01 {
public static void main(String[] args) {
getMin();
}
public static void getMin(){
int a = 50;
int b = 30;
int c = 80;
int Min = (a<b?a:b)<c?(a<b?a:b):c;//通过三元运算符的嵌套应用判断3个数是最值
System.out.println("最小值："+Min);
}
}
运行结果：
最小值：30
第二题:
定义一个swap(int[] array,int x,int y)方法 把array数组中x和y位置的元素互换位置。并在main方法中测试 （测试数组自己定义）
package com.exam;
import java.util.Scanner;
/*
把数组中指定位置的元素互换
*/
public class ExamTest02 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7,8};
Scanner input = new Scanner(System.in);
String str;
do{
str = "";
System.out.println("请输入x,y[0,"+(array.length-1)+"]");
System.out.print("请输入x:");
int x =input.nextInt();//得到键盘录入的数,将他储存在x变量中
System.out.print("请输入y:");
int y = input.nextInt();//得到键盘录入的数,将他储存在y变量中
//逻辑判断语句不要全部写在同一条语句中，这样代码的可读性差，不易快速找出程序错误
if(x<0 || x>=array.length){//x只能有一种情况所以用短路或
System.out.println("数据x不合法,请重新输入：");
}else if(y<0 || y>=array.length){//只能有一种情况所以用短路或
System.out.println("数据y不合法,请重新输入：");
}else {
System.out.println("数据正确，结果如下：");
swap(array,x,y);
break;
}
str = "数据不合法";
}while(str.equals("数据不合法"));
System.out.println("\n再见！");
}
public static void swap(int[] array,int x,int y) {//一般是void类型的方法，其方法体中都有输出语句
System.out.println("原数组");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println("\n----------------");
int temp = array[x];
array[x] = array[y];
array[y] = temp;
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
运行结果：
请输入x,y[0,7]
请输入x:3
请输入y:6
数据正确，结果如下：
原数组
1 2 3 4 5 6 7 8
----------------
1 2 3 7 5 6 4 8
再见！
第三题:
定义五个方法分别求数组的最大值 ,最小值, 总和, 平均值
在主方法中定义数组{23,55,32,18,67,75,97,12,78,89}, 调用每个方法完成测试
package com.exam;
//定义五个方法分别求数组的最大值 ,最小值, 总和, 平均值
public class ExamTest03 {
public static void main(String[] args) {
int[] array = {23,55,32,18,67,75,97,12,78,89};
getMax(array);
getMin(array);
getArraySum(array);
arrayAvg(array);
}
//1.求数组元素的最大值
public static void getMax(int[] array){
int Max = array[0];
for (int i = 0; i < array.length; i++) {
if(array[i]>Max){
Max = array[i];
}
}
System.out.println("数组array中最大元素是："+Max);
}
//2.求数组元素的最小值
public static void getMin(int[] array){
int Min = array[0];
for (int i = 0; i < array.length; i++) {
if(array[i]<Min){
Min = array[i];
}
}
System.out.println("数组array中最小元素是："+Min);
}
//3.求数组元素的总和
public static void getArraySum(int[] array){
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
System.out.println("数组array中元素的总和是："+sum);
return ;
}
//4.求数组中元素的平均值
public static void arrayAvg(int[] array){
int sum = 0;
double avg;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
//两个int类型的数做运算得到的是int类型的结果，但结果不一定准确，需要把其中一个数值转为浮点类型
avg = (double)sum/array.length;//把其中一个数值转为double类型，运算的结果也是double类型
System.out.println("数组array的元素平均值是："+avg);
}
}
运行结果：
数组array中最大元素是：97
数组array中最小元素是：12
数组array中元素的总和是：546
数组array的元素平均值是：54.6
第四题:
定义一个方法printNum, 打印1-500(包含1和500)能同时被2，5，7整除的所有数 ,并统计满足条件的个数, 在主方法中调用此方法完成测试.
package com.exam;
/*
打印1-500(包含1和500)能同时被2，5，7整除的所有数
,并统计满足条件的个数
*/
public class ExamTest04 {
public static void main(String[] args) {
test();
}
public static void test(){
int count = 0;
for (int i = 1; i <= 500; i++) {
if(i%2==0 && i%5==0 && i%7==0){
count++;
System.out.println("符合条件的数有-->"+i);
}
}
System.out.println("符合条件的数总共有："+count+"个");
}
}
运行结果：
符合条件的数有-->70
符合条件的数有-->140
符合条件的数有-->210
符合条件的数有-->280
符合条件的数有-->350
符合条件的数有-->420
符合条件的数有-->490
符合条件的数总共有：7个
第五题:
1.定义一个方法union()，传入两个数组，方法的功能是将两个数组的元素合并到一个新数组中, 并返回这个新数组
public static int[] union(int[] arr1, int[] arr2){
功能: 将两个数组的元素存入到一个新数组中并返回
}
package com.exam;
/*
数组的合并
*/
public class ExamTest05 {
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5};
int[] arr2 = {6,7,8,9,10};
union(arr1,arr2);
}
public static int[] union(int[] arr1,int[] arr2){
int[] arr3 = new int[arr1.length+arr2.length];
for (int i = 0; i < arr1.length; i++) {
arr3[i] = arr1[i];
}
for (int i = 0; i < arr2.length; i++) {
arr3[i+arr1.length] = arr2[i];
}
System.out.println("新数组的元素有：");
for (int i = 0; i < arr3.length; i++) {
System.out.print(+arr3[i]+" ");
}
return arr3;
}
}
运行结果：
新数组的元素有：
1 2 3 4 5 6 7 8 9 10
Java第六天学习内容链接：
535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
