数组(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