Java数组概述
数组
数组是什么
数组就是用来存储一批同种类型数据的内存区域（可以理解成容器)。
例子
// 20,10,80,60,90
int[] arr = {20,10,80,60,90};
// 牛二，西门，狗蛋
String[] name={"牛二","西门","狗蛋"}假如用变量存储这些名字，然后完成随机点名功能，怎么实现?存在有什么问题?
String name1 =“张誉";
string name2 = "刘疏桐";
string name3 ="田启峰";
...
...
string name68="张学颖";
string name69="李沁霖";
String name70=“陈侃";
代码繁琐:大量变量的定义。
业务功能实现麻烦。
使用数组完成：
String[] names ={"张誉","刘疏桐","田启峰"，...,"张学颖","李沁霖","陈侃"};
结论:数组适合做一批同种类型数据的存储。
关于数组同学们需要学会什么
一.数组的定义
1.静态初始化数组
静态初始化数组
定义数组的时候直接给数组赋值。
静态初始化数组的格式:
//完整格式
数据类型[] 数组名= new 数据类型[]{元素1，元素2，元素3... };
double[] scores = new double[]{89.9,99.5，59.5，88.0};
int[] ages = new int[]{12，24，36};//简化格式
数据类型[]数组名= {元素1，元素2，元素3，... };
int[] ages = {12，24，36};
package com.wjh.array;
public class arrayDemo {
public static void main(String[] args) {
//学会使用静态初始化的方式定义数组
//数据类型[] 数组名 = {元素1，元素2，元素3，... };
//double[] sores = new double[]{99.5,88.0,75.5}; //完整写法
double[] sores = new double[]{99.5,88.0,75.5}; //简化写法
//int[] ages = new int[]{12,24,36}; //完整写法
int[] ages = new int[]{12,24,36}; //简化写法
//String[] names = new String[]{"潘金莲","武松","西门庆"}; //完整写法
String[] names = new String[]{"潘金莲","武松","西门庆"}; //简化写法
}
}
数组的基本原理
//double[] sores = new double[]{99.5,88.0,75.5}; //完整写法
double[] sores = new double[]{99.5,88.0,75.5}; //简化写法
System.out.println(sores); //[D@4eec7777注意:数组变量名中存储的是数组在内存中的地址，数组是引用类型。
（1）数组的访问
数组名称[索引]//取值
system.out. println( arr[0]); // 12
//赋值
arr[2] = 100;
system.out.println(arr[2]); // 100数组的长度属性:length
获取数组的长度（就是数组元素的个数)system. out.print1n(arr.length); // 3问题:数组的最大索引可以怎么表示?
数组名.length - 1; //前提:元素个数大于0,比如3就是0,1,2package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*
* 访问数组的元素
* */
int[] ages = {12,24,36};
//取值，数组名称[索引]
System.out.println(ages[0]); //12
System.out.println(ages[1]); //24
System.out.println(ages[2]); //36
//赋值 数组名称[索引] = 数据;
ages[2] = 100;
System.out.println(ages[2]); //100
//访问数组的长度
System.out.println(ages.length); //length意为长度 //3
int[] arr = {};
System.out.println(arr.length);
}
}
（2）数组的几个注意事项
数组的几个注意事项:
“数据类型[ ] 数组名”也可以写成“数据类型 数组名 []”。
int[] ages =.. .;
int ages[] =...;
double[] scores = ...;
double scores[] = ...;
什么类型的数组存放什么类型的数据，否则报错。
int[] arrs = new int[]{30，40，"狗蛋"}; //报错
数组一旦定义出来，程序执行的过程中，长度、类型就固定了。
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 理解数组的注意事项
* */
//1.“数据类型[] 数组名”也可以写成“数据类型 数组名 []”。
int[] ages = {11,23,45};
int ages1[] = {11,23,45};
//什么类型的数组存放什么类型的数据，否则报错。
//String[] names = {"武松","潘金莲",23}; //报错；原因，类型不同
//3.数组一旦定义出来，程序执行的过程中，长度、类型就固定了
int[] ages2 = {11,23,45};
System.out.println(ages2[3]); //报错;原因：长度越界
}
}
2.动态初始化数组
数组的动态初始化
定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。
数组的动态初始化格式:
数据类型[]数组名= new 数据类型[长度];
int[] arr = new int[3];//后赋值
arr[0] = 10;
system.out.println(arr[0]); // 10
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 数组的动态初始化的定义与使用
* */
double[] scores = new double[3]; //[0.0 , 0.0 , 0.0]
//赋值
scores[0] =99.5;
System.out.println(scores[0]); //99.5
System.out.println(scores[2]); //0 //默认值为0
String[] names = new String[90];
names[0] = "潘金莲";
names[2] = "疾风剑豪";
System.out.println(names[0]); //潘金莲
System.out.println(names[1]); //null //String数组的默认值是null
System.out.println(names[2]); //疾风剑豪
}
}
（1）动态初始化数组的元素默认值
元素默认值规则:
两种初始化的的使用场景总结、注意事项说明:
①动态初始化:只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
②静态初始化:开始就存入元素值，适合一开始就能确定元素值的业务场景。
③两种格式的写法是独立的严，不可以混用。
int[] arrs = new int[3]{30,40,50}; //错误package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 掌握动态初始化数组的元素默认值的规则
* */
//1.整型的元素默认值都是0
int[] arr = new int[10];
System.out.println(arr[0]); //0
System.out.println(arr[9]); //0
//2.字符型的元素默认值也都是0？
char[] chars = new char[100];
System.out.println((int)chars[0]); // 0
System.out.println((int)chars[99]); // 0
//3.浮点型的元素默认值都是0.0
double[] scores = new double[90];
System.out.println(scores[0]); //0.0
System.out.println(scores[89]); //0.0
//4.布尔类型的数组默认值
boolean[] booleans = new boolean[100];
System.out.println(booleans[0]); //false
System.out.println(booleans[99]); //false
//5.引用类型数组的默认值
String[] names = new String[90];
System.out.println(names[0]); //null
System.out.println(names[89]); //null
}
}
二.数组的遍历
数组遍历介绍
遍历:就是一个一个数据的访问。
为什么要遍历?搜索、数据统计等等都需要用到遍历。
int[] ages - {20，30，40，50};
for (int i = 0; i < ages.length; i++) {
system.out.println( ages[i]);
}
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 学会数组元素数组的遍历
* */
int[] arr = {12,24,36,12,98};
// 0 1 2 3 4
System.out.println("----原始遍历方式----");
//原始遍历方式
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("-------");
for(int i = 0;i<5;i++){
System.out.println(arr[i]);
}
System.out.println("----终极数组遍历形式---");
//终极数组遍历形式
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
//快捷键 arr.for+名+回车快速生成
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
三.数组的案例
1.数组元素求和
案例 数组遍历-求和
需求:某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额。
分析:
把这5个数据拿到程序中去--->使用数组
int[ ] money = {16，26，36，6，100};
遍历数组中的每个数据，然后在外面定义求和变量把他们累加起来。
int sum = 0;
for (int i = o; i < money. length; i++) {
// i =0 1 2 3 4
sum += money[i];package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额
* */
int sum=0; //2.定义一个累计的元素
int[] money = {16,26,36,6,100}; //1.把这些数据用到程序中用数组记住
for(int i=0;i
案例
数组元素求最大值
颜值:15 颜值:9000 颜值:10000 颜值:20000 颜值:9500 颜值:-5
分析:
①把颜值数据拿到程序中去，用数组装起来。
int[] faceScores = {15, 9000，10000，20000，9500,-5};
② 重点：定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。
int max = facescores[0];
③遍历数组的元素，如架该元素大于变量存储的元素，则替换变量存储的值为该元素。
for (int i = 1; i < faceScores . length; i++) {
if(faceScores[i] > max){
//替换
max= facescores[i];
}
}
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 数组元素求最大值
* */
int[] yz ={15,9000,10000,20000,9500,-5}; //①把颜值数据拿到程序中去，用数组装起来。
// 0 1 2 3 4 5
int max = yz[0]; //②定义一个变量用于记录最大值，
// *重点*：这个变量建议默认存储第一个元素值作为参照。
for(int i = 0;i < yz.length;i++){ //③遍历数组的元素
if(yz[i] > max){ //如架该元素大于变量存储的元素
max = yz[i]; //则替换变量存储的值为该元素。
}
}
System.out.println(max);
}
}
3.猜数字游戏
需求
开发一个幸运小游戏，游戏规则如下:
游戏后台随机生成1-20之间的5个数（无所谓是否重复)，然后让大家来猜数字
(1)未猜中提示:“未命中”，并继续猜测
(2)猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置且输出全部5个数据，最
终结束本游戏。
分析：
① 随机生成5个1-20之间的数据存储起来--->使用数组
② 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，
进行对应提示并结束死循环;如果没有猜中，提示继续猜测直到猜中为止。
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 开发一个幸运小游戏，游戏规则如下:
游戏后台随机生成1-20之间的5个数（无所谓是否重复)，然后让大家来猜数字
(1)未猜中提示:“未命中”，并继续猜测
(2)猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置且输出全部5个数据，最终结束本游戏。
* */
//1.定义一个动态初始化的数组存储5个随机的1-20之间的数据
int[] nums = new int[5];
//2.动态的生成5个1-20之间的随机数并存入数据中
for(int i=0;i< nums.length;i++){
// i=0 1 2 3 4 5
nums[i] = r.nextInt(20) + 1;
}
OUT:
//3.使用一个死循环让用户进行猜测
while(true){
System.out.println("请输入1-20之间的1个整数猜测：");
int guessNum = sc.nextInt();
//4.遍历数组中的每个数据，看是否有数据相同，给出提示
for(int i=0;i
4.随机排名
需求：
某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
分析
①在程序中录入5名员工的工号存储起来--->使用数组。
②依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
* 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
* */
//1.动态初始化一个数组，存储5个工号
int[] id = new int[5];
//2.定义一个循环，循环5次，一次录入一个工号存入对应的位置
for (int i = 0; i < id.length; i++) {
//正式录入工号
System.out.println("请输入第"+(i+1)+"名员工的工号：");
int idInt = sc.nextInt();
//存入到数组中去
id[i] = idInt;
}
//4.遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机的索引位置处的元素进行交换（本节的重点）
//id = {12,25,30,29,56}
for (int i = 0; i < id.length; i++) {
//当前遍历的元素值：id[i]
//随机一个索引位置出来
int index = r.nextInt(id.length); //0-max最大长度：0-4
//定义一个临时变量存储index的值
int temp = id[index];
id[index] = id[i];
id[i] = temp;
//4.遍历数组元素输出就是随机排名的结果
for (i = 0; i < id.length; i++) {
System.out.print(id[i]+" ");
}
}
}
}
5.数组排序
数组排序
就是对数组中的元素，进行升序(由小到大)或者降序（由大到小）的操作。
数组排序的技术
冒泡排序：
冒泡排序的思想
每次从数组中找出最大值放在数组的后面去。
实现冒泡排序的关键步骤分析
确定总共需要做几轮:数组的长度-1
每轮比较几次:
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
* 冒泡排序 5 4 6 2 1
* */
//定义一个数组，存储一些数据
int[] nums = {5,4,6,2};
// 0 1 2 3
//2.定义一个循环控制比较的轮数
for (int i = 0;i < nums.length-1; i++) {
//i == 1 比较的次数3 j = 0 1 2 位置
//i == 2 比较的次数2 j = 0 1
//i == 3 比较的次数1 j = 0
//3.定义一个循环控制每轮比较的次数,占位
for(int j=0;j nums[j+1]){
int temp = nums[j+1];
nums[j+1] = nums[j];
nums[j] = temp;
}
}
}
//遍历数组内容输出
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i]+" ");
}
}
}
选择排序
快速排序
插入排序
数组搜索相关的技术
二分搜索
分块查找
哈希表查找
四.数组的内存图
1.Java内存分配、数组内存图
Java 内存分配介绍
栈
堆
方法区
本地方法栈
寄存器
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
int a = 12;
System.out.println(a); //12
int[] arr= {11,22,33};
System.out.println(arr); //[I@12edcd21 //访问的是 地址
arr[0] = 44;
arr[1] = 55;
arr[2] = 66;
System.out.println(arr[0]); //44
System.out.println(arr[1]); //55
System.out.println(arr[2]); //66
}
}
2.两个变量指向同一个数组
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
*
* */
int[] arr1 = {11,22,33};
int[] arr2 = arr1;
System.out.println(arr1); //[I@4eec7777
System.out.println(arr2); //[I@4eec7777
arr2[1] = 99;
System.out.println(arr1[1]); //99
System.out.println(arr2[0]); //11
System.out.println(arr2[1]); //99
System.out.println(arr2[2]); //33
}
}
五.数组使用的常见问题
问题1∶如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)
问题2 : 如果数组变量中没有存储数组的地址，而是null,，在访问数组信息时会出现NullPointerException(空指针异常)
package com.wjh.array;
import java.util.Random;
import java.util.Scanner;
public class arrayDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*目标：
*
* */
int[] arr = {11,22,33};
arr = null;
System.out.println(arr.length); //报错，null没有指向任何东西
System.out.println(arr); //报错，null没有指向任何东西
System.out.println(arr[1]); //报错，null没有指向任何东西
System.out.println("程序结束");
}
}
六.Debug工具的使用
Debug工具
IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
DEBUG工具基本使用步骤:
①在需要控制的代码行左侧，点击一下，形成断点
②选择使用Debug方式启动程序，启动后程序会在断点暂停
③控制代码一行一行的往下执行
