Java基础05-一维数组

后端 Java基础
Created At :
Count:2.3k Views 👀 :
  1. 一维数组
    1. Demo1_Array
    2. Demo2_Array
    3. Demo3_Array
    4. ArrayDemo01
    6. Demo5_Array
    7. Demo6_Array
    8. Demo7_Exception
    9. Demo8_Array
    10. Demo9_Array
    11. Demo10_Array
    12. Demo11_Array
    13. ArrayDemo02

一维数组

主要以代码的形式分析

Demo1_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
* A:为什么要有数组(容器)
	* 为了存储同种数据类型的多个值
* B:数组概念
	* 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
	* 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式
	数据类型[] 数组名 = new 数据类型[数组的长度];
*/
class Demo1_Array {
	public static void main(String[] args) {
		int x = 10;
		x = 20;
		System.out.println("x = " + x);  //x = 20
		//数据类型[] 数组名 = new 数据类型[数组的长度];
		int[] arr = new int[5];				//可以存储五个int类型的数据

		/*
		左边:
		int:数据类型
		[]:代表的数组,几个中括号就代表几维数组
		arr:合法的标识符

		右边:
		new:创建新的实体或对象
		int:数据类型
		[]:代表的数组
		5:代表数组的长度
		*/
	}
}

Demo2_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
* A:什么是数组的初始化
	* 就是为数组开辟连续的内存空间，并为每个数组元素赋予值 
* B:如何对数组进行初始化
	* a:动态初始化 只指定长度，由系统给出初始化值
		* int[] arr = new int[5]; 	
	* b:静态初始化 给出初始化值，由系统决定长度	
* C:动态初始化的格式：
	* 数据类型[] 数组名 = new 数据类型[数组长度];
* D:案例演示
	* 输出数组名称和数组元素

	整数类型:byte,short,int,long默认初始化值都是0
	浮点类型:float,double默认初始化值都是0.0
	布尔类型:boolean默认初始化值false
	字符类型:char默认初始化值'\u0000'
	char在内存中占的两个字节,是16个二进制位
	\u0000,每一个0其实代表的是16进制的0,那么四个0就是代表16个二进制位

	[I@19bb25a

	[代表是数组,几个就代表几维
	I代表是int类型
	@是固定的
	19bb25a代表的是数组的地址值
*/
class Demo2_Array {
	public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[数组长度];
		int[] arr = new int[5];				//动态初始化,在内存中开辟连续的5块空间

		System.out.println(arr[0]);			//系统给出默认初始化值,整数类型的都是0						
		arr[0] = 10;

		System.out.println(arr[0]);	

		System.out.println(arr);			//[I@19bb25a
	}
}

Demo3_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
* A:栈(掌握)
	* 存储局部变量 
	局部变量:定义在方法声明上和方法中的变量
* B:堆(掌握)
	* 存储new出来的数组或对象 
* C:方法区
	* 面向对象部分讲解 
* D:本地方法区
	* 和系统相关 
* E:寄存器
	* 给CPU使用
*/
class Demo3_Array {
	public static void main(String[] args) {
		int[] arr = new int[3];						//动态初始化,创建3块连续的空间
		System.out.println(arr);    //[I@7852e922  一维数组的地址值
		arr[0] = 10;
		arr[1] = 20;

		System.out.println(arr[0]);     //10
		System.out.println(arr[1]);     //20
	}
}

ArrayDemo01

1
2
3
4
5
6
7
8
9
10
11
12
13
class ArrayDemo01 {
	public static void main(String[] args) {
		//定义一个数组,静态初始化
		int[] arr = {10,20,13,15,25,10,15};
		//数组遍历: 遍历是什么意思? 把数组中的每个元素一个个拿出来看一下
		//System.out.println(arr[0]);
		//arr.length 属性:数组名.length
		for (int i = 0;i < arr.length ;i++ ){  //数组中有多少个元素,我就帮你一个个打印出来 //细节 别写=号
			System.out.println(arr[i]); //
		}

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Demo4_Array {
	public static void main(String[] args) {
		int[] arr1 = new int[3];				//创建数组,长度为3
		int[] arr2 = new int[3];				//创建数组,长度为3

		System.out.println(arr1);	//	[I@7852e922		//打印数组的地址值
		System.out.println(arr2);   //  [I@4e25154f

		arr1[0] = 10;							//给第一个数组中第一个元素赋值
		arr2[1] = 20;							//给第二个数组中第二个元素赋值

		System.out.println(arr1[0]);    10
		System.out.println(arr1[1]);    0
		System.out.println(arr1[2]);    0

		System.out.println("--------------------------------------");

		System.out.println(arr2[0]);    0
		System.out.println(arr2[1]);    20
		System.out.println(arr2[2]);    0
	}
}

Demo5_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//三个引用两个数组
class Demo5_Array {
	public static void main(String[] args) {
		int[] arr1 = new int[3];
		int[] arr2 = new int[5];
		int[] arr3 = arr2;

		System.out.println(arr1);   //[I@7852e922
		System.out.println(arr2);   //[I@4e25154f
		System.out.println(arr3);   //[I@70dea4e

		arr1[0] = 10;
		arr1[1] = 20;

		arr2[1] = 30;
		arr3[1] = 40;
		arr3[2] = 50;

		System.out.println(arr1[0]);    10
		System.out.println(arr1[1]);    20
		System.out.println(arr1[2]);    0
		System.out.println("-------------------------------");
		System.out.println(arr2[0]);    0
		System.out.println(arr2[1]);    40
		System.out.println(arr2[2]);    50
		System.out.println(arr2[3]);    0
		System.out.println(arr2[4]);    0
		System.out.println("-------------------------------");
		System.out.println(arr3[0]);    0
		System.out.println(arr3[1]);    40
		System.out.println(arr3[2]);    50
		System.out.println(arr3[3]);    0
		System.out.println(arr3[4]);    0
	}
}

Demo6_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
* A:静态初始化的格式：
	* 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
	* 简化格式：
		* 数据类型[] 数组名 = {元素1,元素2,…};
* B:案例演示
	* 对数组的解释
	* 输出数组名称和数组元素
* C:画图演示
	* 一个数组
*/
class Demo6_Array {
	public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
		//int[] arr = new int[5]{11,22,33,44,55};	//不允许动静结合
		int[] arr2 = {11,22,33,44,55};			//静态初始化的简写形式

		//int[] arr;								//声明数组引用
		//arr = new int[]{11,22,33,44,55};

		//int[] arr2;
		//arr2 = {11,22,33,44,55};				//简写形式声明和赋值在同一行

		System.out.println(arr2);
		System.out.println(arr2[4]);
	}
}

Demo7_Exception

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
* A:案例演示
	* a:ArrayIndexOutOfBoundsException:数组索引越界异常
		* 原因：你访问了不存在的索引。
	* b:NullPointerException:空指针异常
		* 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
		* int[] arr = {1,2,3};
		* arr = null;
		* System.out.println(arr[0]);
*/
class Demo7_Exception {
	public static void main(String[] args) {
		int[] arr = new int[5];						//0x0011
		//System.out.println(arr[-1]);				//当访问数组中不存在的索引,会出现索引越界异常

		arr = null;
		System.out.println(arr[0]);					//当数组引用赋值为null,再去调用数组中的元素就会出现空指针异常
	}
}

Demo8_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
* A:案例演示
	* 数组遍历：就是依次输出数组中的每一个元素。
	* 数组的属性:arr.length数组的长度
	* 数组的最大索引:arr.length - 1;
*/
class Demo8_Array {
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55};

		/*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]);*/
		
		for (int i = 0;i < 5 ;i++ ) {
			System.out.println(arr[i]);
		}
		System.out.println("---------------");
		//arr.length 代表的是数组的长度
		System.out.println(arr.length);
		for (int i = 0;i < arr.length ;i++ ) {
			System.out.println(arr[i]);
		}

		int[] arr2 = {3,4,5};
		print(arr2);
	}

	/*
	数组的遍历
	1,返回值类型void
	2,参数列表int[] arr
	*/

	public static void print(int[] arr) {
		for (int i = 0;i < arr.length ;i++ ) {
			System.out.print(arr[i] + " ");
		}
	}
}

Demo9_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
* A:案例演示
	* 数组获取最值(获取数组中的最大值最小值)
*/
class Demo9_Array {
	public static void main(String[] args) {
		int[] arr = {33,77,22,44,55};
		int max = getMax(arr);
		System.out.println(max);
	}

	/*
	获取数组中最大值
	1,返回值类型int
	2,参数列表int[] arr
	*/

	public static int getMax(int[] arr) {
		int max = arr[0];
		for (int i = 1;i < arr.length ;i++ ) {			//从数组的第二个元素开始遍历
			if (max < arr[i]) {							//如果max记录的值小于的数组中的元素
				max = arr[i];							//max记录住较大的
			}
		}

		return max;
	}
}

Demo10_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
* A:案例演示
	* 数组元素反转(就是把元素对调)
*/
class Demo10_Array {
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55};
		reverseArray(arr);
		print(arr);
	}

	/*
	数组元素反转
	1,明确返回值类型void
	2,明确参数列表int[] arr
	*/

	public static void reverseArray(int[] arr) {
		for (int i = 0;i < arr.length / 2 ; i++) {
			//arr[0]和arr[arr.length-1-0]交换
			//arr[1]和arr[arr.length-1-1]交换
			//arr[2]和arr[arr.lentth-1-2]
			//...

			int temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = temp;
		}
	}

	/*
	数组遍历
	1,明确返回值类型void
	2,明确参数列表int[] arr
	*/

	public static void print(int[] arr) {
		for (int i = 0;i < arr.length ;i++ ) {				//遍历数组中的每一个元素
			System.out.print(arr[i] + " ");					//打印在控制台
		}
	}
}

Demo11_Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
* A:案例演示
	* 数组查表法(根据键盘录入索引,查找对应星期)
*/
import java.util.Scanner;
class Demo11_Array {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入对应的星期范围在1-7");
		int week = sc.nextInt();

		System.out.println("星期" + getWeek(week));
	}

	/*
	根据索引返回对应的星期
	1,返回值类型char
	2,参数列表int week
	*/

	public static char getWeek(int week) {
		char[] arr = {' ','一','二','三','四','五','六','日'};		//定义了一张星期表
		return arr[week];											//通过索引获取表中的元素
	}
}

ArrayDemo02

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
* A:案例演示
	* 数组元素查找(查找指定元素第一次在数组中出现的索引)
*/
class Demo12_Array {
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66,77};
		int index = getIndex(arr,88);
		System.out.println(index);
	}

	/*
	查找元素索引
	1,返回值类型int
	2,明确参数列表,int[] arr,int value
	*/

	public static int getIndex(int[] arr,int value) {
		for (int i = 0;i < arr.length ;i++ ) {				//数组的遍历
			if (arr[i] == value) {							//如果数组中的元素与查找的元素匹配
				return i;
			}

		}
		return -1;
		
	}
}

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 1210331079@qq.com

💰

Title:Java基础05-一维数组

Count:2.3k

Author:千 羽

Created At:2020-05-22, 15:49:45

Updated At:2020-10-12, 08:34:48

Url:https://nateshao.github.io/2020/05/22/Java%E5%9F%BA%E7%A1%8005-%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84/

Copyright: 'Attribution-non-commercial-shared in the same way 4.0' Reprint please keep the original link and author.

©2016-2020 千羽

Built with Hexo and 3-hexo theme

×

donation.headline

// 底部音乐
//右上角Github图标