超详解“数组”基础知识点很全面（Java）_java数组基础知识

数组（是一种引用数据类型）

一，数组定义？：它是基础的线性储存结构，也可以有效的实现一组变量的关联

1.“数组名称.length”属性，可以直接得到数组的长度
2.数组属于引用数据类型，在代码中需要进行内存的分配
3.动态初始化后会发现数组中的每一个元素的内容都是其对应数据类型的默认值
4.静态初始化：在数组定义时就为其设置了具体的数据内容,这样就避免了先开辟后赋值的重复操作

二、数组引用传递分析？：在数组使用时需要关键字new开辟堆内存空 间，而一块堆内存空间可以被多个栈内存指向，自然也就能对它进行引用数据操作
注意：不能够直接使用未开辟堆内存空间的数组（因为一但使用就会出现空指向异常）

public class ArrayDemo{
	public static void main(String args[]){
		int data[] = new int {10,20,30};	//使用静态初始化数组
		int temp[] = data;	//这里用到的就是引用传递
		temp[0] = 99;	//修改原data数组中的内容
		for(int x = 0;x < data.length;x++){
			System.out.print(data[x] + "、");	//输出结果
		}
	}
}	
1
2
3
4
5
6
7
8
9
10

程序结果：

三、foreach输出？：他是一种加强型for循环，使用foreach结构可以实现数组数据的输出

如下：
for（数据类型 变量 ：数组 | 集合）{
//循环体代码，循环的次数为数组的长度
}

//范例：使用foreach结构输出数组内容
public class ArrayDemo{
	public static void main(String args[]){
		int data[] = new int [] {1,2,3,4,5,6,7,8,9,10};
		/*下面就是foreach结构的输出形式了*/
		for(int temp : data){
			System.out.print(temp + "、");
		}
	}
} 
1
2
3
4
5
6
7
8
9
10

程序的执行结果：

四、二维数组？：它是一种描述多行多列的数组结构

它也有俩种初始化的方式，分别是动态初始化和静态初始化（其实要区分动态和静态，就看初始化时有没有进行赋值操作，有的话就是静态的）
1.动态初始化：数据类型 数组名称[][] = new 数据类型[行的个数][列的个数]；
2.静态初始化：数据类型 数组名称[][] = new 数据类型[][]{{值，值，值}{值，值，值}}
关于多维数组：：二维及其以上的都可以称为多维数组，但维数越高，复杂度也就越高，在开发的过程中建议尽量不要使用多维数组

//范例：同样的这里也将用foreach结构对二维数组进行输出
public class ArrayDemo{
	public static void main(String argc[]){
		int data[][] = new int[][]{
			{1,2,3,4,5,6},{1,2,3,4,5},{6,7,8,9,10}};
		for(int temp [] : data){	//外层循环获取每一行数组
			for(int num : temp){	//内层循环获取数组内容
				System.out.print(num + "、");
			}吧
			System.out.println();	//换行
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

程序执行结果：

五、数组与方法：这里要讲的是如何利用方法接收数组和返回数组的操作

1.用方法接收一个数组：事先开辟好一个数组，然后通过引用传递，指向该数组的堆空间，这样就达到了接收的目的了
2.用方法返回一个数组：和接收差不多，只不过接收时对方法的类型没有强制的要求，返回时则必须要要求方法的类型与接收数组的类型一致
注：因为用的是引用传递只要有一个修改了堆空间里内容，其它的也会跟着改变，因为归根结底指向的都是同一块堆空间。

//范例：使用方法接收数组引用
class ArrayUtil{
	public static void printArray(int temp[]){
		for(int x = 0;x < temp.length;x++){
			System.out.print(temp[x] + "、");
		}
		System.out.println();
	}
}

public class ArrayDemo{
	public static void main(String argc[]){
		int data[] = new int[] {32,12,1,245,2,6,12,34,56};
		int dataB[] = new int[] {11,22,33,44,55,66,44,77,88,99};
		java.util.Arrays.sort(data);//可以自动排序，按照从小到大的顺序
		System.arraycopy(data,3,dataB,4,5);//数组复制
		ArrayUtil.printArray(data);
		ArrayUtil.printArray(dataB);//复制后会覆盖原数组中的内容
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

程序执行结果：

七、对象数组？：除了基本数据类型的数据定义为数组外，引用数据类型也可以定义数组，像这样的就是对象数组了

1.对象数组动态初始化：类 对象名称[] = new 类 [长度]；
2.对象数组静态初始化：类 对象名称[] = new 类 [实例化对象,实例化对象,…]；
类的定义和以前的差不多，只不过在实例化对象的时候用了数组的形式

//范例使用动态初始化定义对象数组
class Person{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getInfo(){
		return "姓名：" + this.name  + "、年龄：" + this.age;
	}
}
public class ArrayDemo{
	public static void main(String argc[]){
		Person per [] = new Person[3];	//动态初始化一个对象数组
		per[0] = new Person("张三",20);
		per[1] = new Person("李四",21);
		per[2] = new Person("王五",22);
		for(int x = 0;x < per.length;x++){
			System.out.println(per[x].getInfo());
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

程序执行结果：

八、类关联结构？：这里要说的是一个类可以关联其他类。根据引用关系依据某一个类对象，可以获取其相应的信息

详解：用于描述两个类之间的引用关系，在主类操作时首先根据两个类的关系设置引用关系，随后就可以根据引用关系依据某一个类对象获取相应的关系（这里有一点象父类与子类的继承的意思在里面，但两者的操作是不一样的）

九、自身关联结构？：可以利用自身关联的形式描述人员后代的关系

详解：在进行类关联描述的过程中，除了可以关联其他类之外，也可以实现自身的关联操作，也就是说可以利用自身关联的形式描述人员后代的关系

十、合成设计模式？：将对象的引用关联进一步扩展就可以实现更多的结构描述，通过不同的类实现子结构定义，随后将其在一个父结构中整合

详解：下面会写一个伪代码的合成设计模式组成结构。需要注意的是Java中提供的引用数据类型不仅仅是描述的内存操作形式，更多的是包含了抽象与关联的设计思想

范例：伪代码块描述合成设计思想
class 计算机{
	private	显示器 对象数组[];
	private 主机 对象;
}
class 显示器{}
class 主机{
	private 主板 对象;
	private 鼠标 对象;
	private 键盘 对象;
}
class 主板{
	private	内存 对象数组[];
	private CPU 对象数组[];
	private 显卡 对象;
	private 硬盘 对象数组[];
}
/*以下都属于主机的子结构*/
class 键盘{}
class 鼠标{}
class 内存{}
/*以下都属于主板的子结构*/
class cpu{}
class 显卡{}
class 硬盘{}
/*而以上不管是显示器还是主机都属于计算机的子结构，多个类之间互相关联包含，象这样的就是合成设计的模式*/
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

十一、数据表与简单Java类映射转化？：这里分析的是数据表与简单java类之间的转化。简单操作就是首先实例化各个对象信息，随后根据关联关系设置数据间的引用配置，在数据配置完成后就可以依据对象间的引用关系获取对象的相应信息。

//范例实现一对多的数据结构转化
/*描述部门*/
class Dept{
	private int deptno;//部门编号
	private String dname;//部门名称
	private String loc;//部门位置
	private Emp emps[];//用来保存多个雇员的信息
	public Dept(int deptno,String dname,String loc){
		this.deptno = deptno;
		this.dname = dname;
		this.loc = loc;
	}
	public void setEmps(Emp[] emps){
		this.emps = emps;
	}
	public Emp[] getEmps(){
		return this.emps;
	}
	public String getInfo(){
		return "【部门信息】部门编号 = " + this.deptno +  "、部门名称 = " + this.dname + "、部门位置 = " + this.loc;
	}
}

/*描述员工*/
class Emp{
	private long empno;	//员工编号
	private String ename;	//员工姓名
	private	String job;	//职位
	private double sal;//工资
	private double comm;//佣金
	private Dept dept;//部门
	private Emp mgr;//领导
	public Emp(long empno,String ename,String job,double sal,double comm){
		this.empno = empno;
		this.ename = ename;
		this.job = job;
		this.sal = sal;
		this.comm = comm;
	}
	public String getInfo(){
        return "【员工信息】编号 = " + this.empno + "、姓名 = " + this.ename + "、职位 = " + this.job + "、 工资 = " + this.sal + "、佣金 = " + this.comm;
	}
	public void setDept(Dept dept){
		this.dept = dept;
	}
	public void setMgr(Emp mgr){
		this.mgr = mgr;
	}
	public Dept getDept(){
		return this.dept;
	}
	public Emp getMgr(){
		return this.mgr;
	}
}
	
/*设置数据并根据引用关系获取数据内容*/

public class JavaDemo{
	public static void main(String args[]){
		Dept dept = new Dept(10,"MLDN教学部","北京");
		Emp empA = new Emp(7369L,"SMITH","CLERK",800.00,0.0);
		Emp empB = new Emp(7370L,"FORD","MANAGER",900.00,0.0);
		Emp empC = new Emp(7371L,"KING","PRESIDENT",1000.00,0.0);
		//根据数据表定义的数据关联关系，利用引用进行对象间的联系
		empA.setDept(dept);
		empB.setDept(dept);
		empC.setDept(dept);
		empA.setMgr(empB);
        empB.setMgr(empC);
		dept.setEmps(new Emp[] {empA,empB,empC});
		//第二部：根据关系获取数据
		System.out.println(dept.getInfo());
		for(int x = 0;x < dept.getEmps().length;x++){
			System.out.println("\t|- " + dept.getEmps()[x].getInfo());
			if(dept.getEmps()[x].getMgr() != null){
				System.out.println("\t\t| - " +  dept.getEmps()[x].getMgr().getInfo());
			}	
		}
		System.out.println("-------------------------");
		System.out.println(empB.getDept().getInfo());
		System.out.println(empB.getMgr().getInfo());
	}
}
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

程序执行结果：

详解：现代项目的开发中数据库是核心的组成部分，几乎所有的项目代码都是围绕着数据表的业务逻辑结构展开的，那么分析数据表与简单java类之间的转化也是很重要的

十二、小结

1.数组是一组相关数据变量的线性集合，利用数组可以方便地实现一组变量的关联，但数组的缺点就在于长度不可以改变
2.数组的访问需要通过“数组名称【索引】”的形式，如果超出索引范围就会报异常。
3.数组的长度可以用“数组名称.length”的形式动态获取。
4. 数组采用动态初始化时，数组中的每一个元素的内容都是其对应数据类型的默认值。
5.如果使用了未开辟堆内存空间的数组则会出现空指向异常。
6.在JDK中使用System.arraycopy()和java.util.Arrays.sort两个方法可以实现数组的复制和排序
7.JDK1.5之后追加了可变参数，这样可以使得方法可以任意接收多个参数。不过需注意的是接收的参数使用数组形式处理。
8.对象数组可以实现一组对象的管理，这样在开发中就可以描述多个实例。
9.简单java类可以实现数据表结构的映射转换，通过面向对象的关联形式可以描述数据表的存储结构

小小温馨提示：码字不易，希望能一键三连哦

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/782733