数组（Array）
计算机专业的小伙伴对这个词都不陌生，不是计算机专业的小伙伴也不用怕书源会为大家介绍清楚数组(Array)这个概念
1、数组是数据结构的一种，那么什么是数据结构呢？
简单理解数据结构就是带有结构特性的数据元素的集合。
2、那么回头看数组数组有什么结构特性呢？
数组它就是将具有相同类型的若干变量有序地组织在一起的集合。
数组可以分为整型数组、字符型数组、浮点型数组、指针数组和结构数组等。
数组还可以有一维、二维以及多维等表现形式，之后我会出一期介绍数据结构的文章。
！！！！当然在Java并没有那么麻烦，试想存储班上58个人的年龄，需要定义58个变量。
(1) 没有数组的时候，age1=10,age2=20,age3=30,age4=23…age58=22;
(2) 有了数组 int[] ages = {10,20,30,23…22}
懂了吧？这也是数组的好处。
一、初始化
存储数据类型一致的数据，而且数组是一个定长的容器，必须指定数组的大小，代表存储元素的个数
1.动态初始化
创建时数组没有赋值元素 程序运行的过程中，对数组元素进行赋值
举例：
-
int[] arr = new int[3]; 定义一个数组arr，可以存储3个整数
(1) 初始化：定义赋值的方式
(2) 标准格式：动态初始化 （动态初始化适用于，只知道元素的个数，但是不知道每个元素的值）
数据类型 数组名[]= new 数据类型[数组长度];
2、详细解释：
(1) 数据类型: 创建的数组容器可以存储什么类型
(2) []:一维数组
(3) 数组名称：数组本身也是一个变量，用于存储数组的地址的一个变量名
(4) =：赋值运算符，将数组的地址，赋值给变量名存储
(5) new：关键字，在堆内存中开辟空间存储数据
(6) 数据类型：和前面保持一致
(7) 数组长度：表示数组的容器可以存储多少个元素
4、数组的使用：
(1) 赋值：数组名[索引] = 元素值;
(2) 索引: 数组的元素在数组中存储的位置的编号，索引范围0数组长度-1，如果长度为3，索引范围02，数组的长度可以通过数组名.length的方式获取
5、数组中的元素时有默认值的：
(1) 当定义一个数字的时候，jvm虚拟机默认为数组中的每一个元素进行默认初始化赋值，根据不同的数组存储的数据类型的不同，初始值也不同
① 整数 0
② 小数 0.0
③ 字符 \u0000
④ 布尔 false
⑤ 引用数据类型 null 表示地址为空，不指向任何类型
6、数组的索引的别称：角标，下标、脚标
class Demo1 {
public static void main(String[] args) {
//定义一个整数类型的数组，元素个数为3，可以存储3个整数
int[] arr = new int[3];
//arr中存储的是地址
System.out.println(arr);
/*
[I@15db9742
[:表示是一维数组
I:表示是int类型的数组
@:普通的间隔符，没有特殊含义
15db9742:十六进制数，数组中的地址值转换成对应的十六进制的数字
数组中的元素，没有赋值是可以使用的，有默认值
数组此时的大小为3，索引范围0~2
*/
//数组的使用 数组名[索引值]
System.out.println(arr[0]);
System.out.println(arr[1]);//1代表第二个元素
System.out.println(arr[2]);
//索引从0开始
//数组的赋值
//数组名[索引值] = 元素值;
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
//在程序运行的过程中，才给每一个元素赋值，被称为数组的动态初始化
System.out.println(arr[0]);
System.out.println(arr[1]);//1代表第二个元素
System.out.println(arr[2]);
}
}
2.静态初始化
1、格式：
(1) 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…元素n};
(2) 注意事项：
① 第二个中括号内，不能写元素的个数
② 元素值的罗列，元素和元素之间使用逗号间隔
③ 必须和数组的数据类型一致
④ 此时数组创建完毕，就已经给每一个元素赋值了
⑤ 适合明确知道每个元素时什么值的情况
2、简化格式：
(1) 数据类型[] 数组名 = {元素1,元素2,元素3…元素n};
(2) 简化格式定义和赋值不能分离
class Demo2 {
public static void main(String[] args) {
//静态初始化
//使数组在定义的同时就已经有了具体的值
int[] arr = new int[]{11,33,22,21};
//此时数组有4个元素，每个值分别为11,33,22,21
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
//数组的长度 获取可以通过数组名.lengtn
System.out.println(arr.length);
//也可以定义和赋值分离
int[] arr2;//数组的定义
arr2 = new int[]{1,2,3,4,5};
//简化版 不能分离
//数据类型[] 数组名 = {元素值的罗列};
int[] arr3 = {1,2,3,4,6,11};
int[] arr4;
//arr4 = {1,2,3};不可以
arr4 = new int[]{1,2,3};//可以
System.out.println(arr4);//数组的元素不赋值有默认值，但是数组本身一定要创建出来才能访问
}
}
3、数组的异常
异常：
java中对程序中出现的问题，进行了封装，把常见的问题，抽象成了异常类，当程序出现问题的时候，就会把问题给抛出，问题出现在哪里，是什么样的问题，并把程序终止掉
在程序运行过程中，出现了问题，jvm认为你出现问题的程序没有必要执行下去了，就会将程序终止掉
(1) 数组索引越界异常
访问了数组中不存在的索引，超出了0~arr.length-1的范围
(2) 空指针异常
数组被赋值为null，还想要访问数组的内容
//数组名赋值
class Demo3 {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
System.out.println(arr[0]);
System.out.println(arr[1]);
int[] arr2 = arr;
arr2[0] = 10;
arr2[1] = 20;
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr[0]);
System.out.println(arr[1]);
}
}
4、数组的遍历
- 遍历的含义：一个一个将数组中的元素取出，打印对应的值 提示：借助数组名.length解决该问题
1、数组获取最值，获取数组中的最大值
(1) 擂台思想：设置一个擂台，将将指定元素放置擂台上，然后和台下的元素一一比较，如果大的就留在擂台上，小的则失败
class Demo4 {
public static void main(String[] args) {
//数组的遍历
int[] arr = new int[]{1,2,3,4,5};
// i < 5
for(int i = 0; i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
class Demo5 {
public static void main(String[] args) {
//3、数组元素的交换，交换两个元素的值
int[] arr = {1,2,3,44};
//希望索引为1和3的交换位置
//定义临时变量
int temp = arr[1];
arr[1] = arr[3];
arr[3] = temp;
}
}
5、数组的反转:
int[] arr = {1,2,3,4,5};反转之后{5,4,3,2,1};
(1) 原理:将第一个元素和最后一个元素交换位置，第二个和倒数第二个交换，一共有5个元素，到第三个元素就不再交换了
class Demo6 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for(int i = 0,j = arr.length-1;i < j; i++,j--){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
for(int i = 0; i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
6、冒泡排序
(1) 通过合适的方式将数组中的元素进行升序排列(从小到大)
(2) 原理，比较相邻两个元素的值，将大的值，交换至右侧
class Demo7 {
public static void main(String[] args) {
int[] arr = {55,29,13,6};
//比较arr.length-1轮 也就是3轮
//i < 3; 0 1 2
//此时定义的i代表的是轮数
for(int i = 0; i < arr.length-1;i++){
//循环体中，定义每一轮比较的次数
//第一轮比较元素个数-1次 - 0 次
//当arr.length=4 j < 3 0 1 2比较三次
//第二轮比较元素个数-1 - 1次
//第三轮比较元素个数-1 - 2次
for(int j = 0; j < arr.length-1-i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j + 1] = temp;
}
}
}
//最后查看排序结果
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
7、补充
import java.util.Arrays;
//数组工具类JAVA.util.Arrays
//由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，
//从而可以对数据对象进行一些基本的操作
//查看JDK帮助文档
//Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，
//而“不用”使用对象来调用（注意；是“不用”而不是“不能”）
//Arrays类具有以下常用功能
//给数组赋值：通过fill方法。
//给数组排序；通过sort方法，按升序。
//比较数组；通过equals方法比较数组中的元素值是否相等。
//查找素组元素；通过binarySearch方法能等于排序好的数组进行二分查找法操作。
public class ArraysDemo {
public static void main(String[] args) {
int[] a = {1,3,5,7,666,8};
Arrays.toString(a);//打印数组元素
System.out.println(Arrays.toString(a));
Arrays.sort(a);//排序数组元素
System.out.println(Arrays.toString(a));
Arrays.fill(a,1,4,0);//填充
System.out.println(Arrays.toString(a));
printA(a);
}//重复造轮子
public static void printA(int[] a){
for (int i = 0; i < a.length; i++) {
if(i==0){
System.out.print("[");
}
if (i==a.length-1){
System.out.print(a[i]+" ]");
}else {
System.out.print(a[i]+",");
}
}
}
}
public class Demo8 {
//变量的类型 变量的名字 = 变量的值；
//数组是相同数据类型的有序集合（可以是任意类型）
//数组也是对象。元素相当于变量
//长度是确定的，不可变的。如果越界：
// ArrayIndexOutOfBoundsException 数组下标越界异常！
public static void main(String[] args) {
//动态初始化数组
int[] nums;//1.声明一个数组
nums = new int[5];//这里面可以存放5个int类型的 2.创建一个数组
//3.给数组中元素赋值
nums[0] =1;
nums[1] =2;
nums[2] =3;
nums[3] =4;
nums[4] =5;
//计算所以元素的和
int sum =0;
//获取数组的长度; arrays.length
for (int i=0; i<nums.length;i++ ){
sum =sum+nums[i];
}
System.out.println("总和为"+sum);
}
}
//三种初始化状态
//静态初始化
//int[] a = {1,2,3};
//PS[] man = {new PS(1,1),new PS(2,2)）}
//动态初始化
// int[] a= new int[2];
//a[0]=1;
//a[1]=2;
//默认初始化
//数组是引用类型。他的元素相当于类的实例变量，因此数组一旦分配空间，
// 其中的每个元素也被按照实例变量同样的方式被隐式初始化、
public class Demo9 {
public static void main(String[] args) {
//静态初始化 创建+赋值
int[] a = {1,2,3,4,5};
System.out.println(a[8]);
//动态初始化 Demo1
//数组对象本身是在堆中的
//对象都是在堆中的
//ArrayIndexOutOfBoundsException 数组下标越界异常！
}
}
public class Demo10 {
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5};
//打印全部的数组元素
for (int i = 0; i <arrays.length ; i++) {
System.out.println(arrays[i]);
}
System.out.println("======================================");
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
System.out.println("sum="+sum);
System.out.println("======================================");
//查找最大元素
int max= arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (arrays[i]>max){
max=arrays[i];
}
}
System.out.println("max="+max);
}
}
public class Demo11 {
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5};
// //JDK1.5 没有下标
// for (int array : arrays) {
// System.out.println(array);
// }
//printArray(arrays);
int[] reverse = reverse(arrays);
System.out.println();
printArray(reverse);
}
//打印数组元素方法
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
return ;
}
public static int[] reverse(int[] arrays){//反转 reverse
int[] result =new int[arrays.length];
//反转的操作
for (int i = 0,j =result.length-1; i < arrays.length; i++,j--) {
// result[] = arrays[i];
result[j] =arrays[i];
}
return result;
}
}
//多维数组，数组的数组
public class Demo12 {
public static void main(String[] args) {
int[][] array ={{1,2},{2,3},{3,4},{4,5}};
printArray(array[0]);
System.out.println("======================================");
System.out.println(array[1][0]);
System.out.println(array[1][1]);
System.out.println("======================================");
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array [i].length ; j++) {
System.out.println(array[i][j]);
}
}
}
//打印方法
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
return ;
}
}
//冒泡排序算法 时间复杂度为 0（n2）
//1.比较数组中，两个相邻的元素，如果第一个比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生出一个最大，或者一个最小的数字
//3.下一轮可以少一次排序！
//4.依次循环，直到结束。
public class Demo6 {
public static void main(String[] args) {
int[ ] a={1,4,5,7,8};
int[] sort= sort(a);//调用我们自己写的排序方法，返回一个数组
System.out.println(Arrays.toString(a));
}
public static int[] sort(int[] array){
int temp = 0;
//外层循环，判断我们要走多少次
for (int i = 0; i < array.length-1; i++) {
boolean flag =false;//通过flag标识位减少没有意义的比较
//内层循环，判断两个数，如果第一个数，比第一个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]>array[j]){
temp = array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag = true;
}
}
if (flag==false){
break;
}
}
return array;
}
}
//稀疏数组
public class Demo13 {
public static void main(String[] args) {
//打印一个二维数组11*11 0没有棋子 1黑旗 2白棋
int [][] array1 = new int[11][11];
array1[1][2] =1;
array1[2][3] =2;
//输出原始的数组
System.out.println("输出原始的数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
System.out.println("===============================");
//转换为稀疏数组保存
//获取有效值的个数
int sum =0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的个数"+sum);
//2.创建一个稀疏数组的数组
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//便利二维数组，把非0的值，存放进稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组");
for (int i=0;i<array2.length;i++){
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
System.out.println("===============================");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3=new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原他的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] =array2[i][2];
}
//3.打印还原的数组
System.out.println("输出还原的数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
1、方法可以嵌套几层定义、方法可以嵌套几层调用
方法不能嵌套定义 ：方法需要类作为载体
方法可以嵌套调用，甚至可以自己调用自己，慎用递归会造成栈溢出
2、方法的形式参数和实际参数有什么区别
形式参数 方法定义时使用。只有形，没有值。需要使用实际参数的值，
实际参数 方法调用时使用只有值，使用形势参数的变量类型。
3、jvm内存区域分为哪些，分别什么用途
五个区域
方法区(常用):存储类文件，包含了一个类中的所有内容，加载类时
堆内存(常用):存储对象和数组，new来创建都是存储在堆内存中
栈内存(常用):执行方法的区域，方法运行时进入栈内存，方法运行结束，出栈内存，栈内存管理数据的特点，先进后出
程序计数器：控制程序的执行流程
本地方法区：底层引用了c和c++的方法
4、什么样的方法算重载的方法
在同一个类中。方法名相同，参数列表不同，与返回值无关
5、数组的初始化分为哪两种
静态初始化 ：声明的同时已经知道数组的每个元素，此时创建出的数组是已经赋值的
动态初始化 ：声明的时候只知道元素的个数，数组是一个定长的容器一旦创建就无法更改大小
6、数组元素不赋值可以使用吗
可以
7、默认值分别为什么
有默认值，整数 0，小数0.0字符、字符\u0000、布尔false
8、数组中的new关键字作用是什么
在堆内存中开辟空间
10、数组中有两个异常，分别是什么，产生的原因是什么
索引越界异常，空指针异常
int[] arr;
System.out.println(arr[1]);
11、定义方法，求数组中元素的平均值，数组元素个数获取方式 数组名.length
例：int[] arr = {1,2,3};
//此时arr.length的值就是3
12、定义方法，给一个任意大小的整数类型数组赋值，每个元素的值为随机数，要求10-50之前的随机数
13、定义一个方法，可以将指定int数组的i和j位置的元素进行交换
14、定义一个方法，可以将任意int类型的数组进行反转
15、定义一个方法，可以将任意int类型的数组进行升序排序
import java.util.Random;
class Demo01 {
public static void main(String[] args) {
int[] arr = {1,2,3,3,4,5};
System.out.println(getAvg(arr));
int[] arr2 = new int[5];
getNumber(arr2);
print(arr2);
System.out.println("~~~~~~~");
swap(arr2,2,4);
print(arr2);
reverse(arr2);
print(arr2);
sort(arr2);
print(arr2);
}
//11、定义方法，求数组中元素的平均值，数组元素个数获取方式
//数组名.length
//例：int[] arr = {1,2,3};
//此时arr.length的值就是3
//修饰符 public static
//返回值类型 int
//方法名称 getAvg
//参数列表 求出数组元素，需要外界一个数组 int[] arr
//方法体语句，遍历获取每一个元素，求和 再除以元素个数
//return语句 返回最终的平均值
public static int getAvg(int[] arr){
int sum = 0;
for(int i = 0; i < arr.length;i++){
sum += arr[i];
}
return sum / arr.length;
}
//12、定义方法，给一个任意大小的整数类型数组赋值，
//每个元素的值为随机数，要求10-50之前的随机数
public static void getNumber(int[] arr){
Random r = new Random();
for(int i = 0; i < arr.length; i++){
arr[i] = r.nextInt(41)+10;
}
}
public static void print(int[] arr){
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
//13、定义一个方法，可以将指定int数组的i和j位置的元素进行交换
public static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//14、定义一个方法，可以将任意int类型的数组进行反转
public static void reverse(int[] arr){
for(int i = 0,j = arr.length-1; i < j; i++,j--){
swap(arr,i,j);
}
}
//15、定义一个方法，可以将任意int类型的数组进行升序排序
public static void sort(int[] arr){
//外层循环定义比较的轮数
//内层循环定义比较的次数
for(int i = 0; i < arr.length-1; i++){
for(int j = 0; j < arr.length-1-i; j++){
if(arr[j] > arr[j+1]){
swap(arr,j,j+1);
}
}
}
}
}
下一篇文章给大家介绍一下常用的编辑器Idea
