数组的学习

HelllllloWorld

已于 2023-01-12 10:01:56 修改

阅读量95

点赞数

文章标签：学习

于 2023-01-09 17:06:42 首次发布

本文链接：https://blog.csdn.net/weixin_52480823/article/details/128614530

版权

数组定义：数组是基础的线性存储结构，可以有效的实现一组变量的关联。本质在于一组相关变量的集合，但是注意：Java语言定义为引用数据类型，那么会有内存分配，就一定会有new来处理。

数组的定义格式：

数组的动态初始化：初始化之后数组每一个元素的保存内容为其对应数据类型的默认值。

声明并初始化数组：数据类型数组名称【】 = new 数据类型【长度】；

数据类型【】数组名称 = new 数据类型【长度】；

数组的静态初始化:在数组定义的时候就为其设置好了里面内容。

简化格式：数据类型数组名称【】 = new数据类型【】{数据1，数据2，数据3，........}；

数组里面可以通过脚标进行每一个元素的访问，脚标从0开始定义。如果使用的时候超过了数组脚标范围，则会出现“ArrayIndexOutBounds进行数组操作的时候往往会用for循坏。”

package com.java;

public class ArrayDemo {
	public static void main(String args[])
	{
		int data [] = new int [3];
		data[0] = 11;
		data[1] = 23;
		data[2] = 34;
		for(int i = 0;i < data.length;i++) {
			System.out.println(data[i]);
		}
	}
}

使用数组的静态初始化

int data [] = new int [] {11,23,34};

对于数组来说拿到数据之后循坏控制。

数组引用传递分析：

在使用数组过程中使用了关键字new进行了内存开辟，一定存在内存的关系匹配。

foreach迭代输出：

传统数组大部分使用for循坏来进行数组的遍历，从而下标对程序的影响（如果下标处理不当则会出现数组越界异常），所以参考了.net设计增强型的for循坏（foreach），利用foreach的语法结构可以直接自动获取数组每一个元素，避免下标访问。

for（数据类型变量：数组集合）{}

	public static void main(String args[])
	{
		int data [] = new int [3];
		data[0] = 11;
		data[1] = 23;
		data[2] = 34;
	for(int temp : data) {
		System.out.println(temp);
	}
	}
}

好处是避免下标操作。

二维数组：

之前的数组就好比一行数据。

数组的动态初始化：

数据类型数组名称【】【】 = new 数据类型【行个数】【列个数】

数组的静态初始化：

数据类型数组名称【】【】 = new 数据类型【】【】{{数据}，{数据}}

public class ArrayDemo {
	public static void main(String args[])
	{
		int data [][] = new int [][]{
			{1,2,3},{2,3,4,5},{3,4,5}};
		for(int x = 0;x < data.length;x++)
			{
		for(int y = 0;y < data[x].length;y++)
			{
				System.out.println(data[x][y]);
			}
			System.out.println();
			}

		}
	}

利用foraeach（）进行遍历数组

	public static void main(String args[])
	{
		int data [][] = new int [][]{
			{1,2,3},{2,3,4,5},{3,4,5}};
for(int xxx [] : data) {
	for(int yyy  : xxx) {
		System.out.println(yyy+".");
		
	}
	System.out.println();
}
		}
	}

数组排序的代码

public class ArrayUtil {
 public static void sort(int data[]) {
	for(int x = 0;x < data.length;x++)
	{
		for(int y = 0;y < data.length -x - 1;y++)
		{
			if(data[y] > data[y+1]) {
				int temp = data[y];
				data[y] = data[y+1];
				data[y + 1] = temp;
				
			}
				
			}
		}
	}
	 public static void printArray(int temp [])
	 {
		 for (int x = 0;x <temp.length;x++)
		 {
			 System.out.print(temp[x] + ".");
		 }
		 System.out.println();
	 }
 }
 public static void main(String args[])
	{
		int data [] = new int []{8,9,1,2,5,7,10,4,3,6};
	  ArrayUtil.sort(data);
      ArrayUtil.printArray(data);		
		}
	
	}

数组反转进行前后转置处理：

	int data [] = new int [] {1,2,3,4,5,6,7,8,9,10};
	int center = data.length/2;
    int head = 0;
int tail = data.length - 1;
for(int x = 0;x < center;x++)
{
int temp = data [head];
data[head] = data [tail];
data[tail] = temp;
head ++;
tail --;}

开发时候为了方便开发采用了

java.util.Arrays.sort(数组名称)进行排序,

数组拷贝

System.arraycopy(源数组，源数组开始点，目标数组，目标数组开始点，拷贝长度)

方法可变参数：

class ArrayUtil
	public static int sum(int ... data)
	{
		int sum = 0;
		for (int temp: data)
		{
			sum += temp;
		}
		return sum;
	}
void main
System.out.println(ArrayUtil.sum(1,2,3));
System.out.println(ArrayUtil.sum(new int[]{1,2,3}));

特点：参数接收灵活。

对象数组

动态初始化：类对象数组名称【】 = new 类【长度】，每一个元素内容都是null

静态初始化：类对象数组名称【】 = 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;}
setter,getter略
}
pubilc class ArratDemo{
public static void main(String args[])
{
Person per = new Person[3];
per[0] = new Person("张三",20);
per[1] = new Person("张四",20);
per[2] = new Person("张五",20);
}
for(int x = 0;x <per.length;x++){
System.out.println(per[x].getInfo())}}

引用传递案例

public class Person {
		private String name;
		private int age;
		private Car car;
		public Person(String name,int age){//定义有参构造
			 this.name = name;//为类中赋值
			 this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public Car getCar() {
			return car;
		}
		public void setCar(Car car) {
			this.car = car;
		}
	public String getInfo() {
		return "姓名:" + this.name + "年龄" + this.age;
	}
		}
public class Car {
private String name;
private double price;
private Person person;
public Car(String name,double price)
{
   this.name = name;
   this.price = price;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public double getPrice() {
	return price;
}
public void setPrice(double price) {
	this.price = price;
}
public Person getPerson() {
	return person;
}
public void setPerson(Person person) {
	this.person = person;
}
public String getInfo() {
	return ("汽车品牌" + this.name  + ",汽车价格" + this.price);
}
}
	Person person = new Person("王布二",20);
		Car car = new Car("奥迪",1000000);
		person.setCar(car);
		car.setPerson(person);
		System.out.println(person.getCar().getInfo());
		System.out.println(car.getPerson().getInfo());

数据表与简单Java类的基本映射关系：

数据实体表 = 类的定义；

表中字段 = 类的成员属性；

表中一行数据 = 类中的一个实例化对象；

多行数据 = 对象数组；

数组学习的总结代码

		
	public static void main(String args[])
    {Member memA = new Member("mldn-a","张三");
		Member memB = new Member("mldn-b","李四");
		Role roleA = new Role(1l,"管理");
		Role roleB = new Role(2l,"操作");
		Privalege priA = new Privalege(0001L, "SAJD");
		Privalege priB = new Privalege(0002L, "AJD");
		Privalege priC = new Privalege(0003L, "JD");
		Privalege priD = new Privalege(0004L, "SAD");
		Privalege priE = new Privalege(0005L, "SJD");
		roleA.setPrivaleges(new Privalege[] {priA,priB,priC});
		roleB.setPrivaleges(new Privalege[] {priD,priE});
		priA.setRole(roleA);
		priB.setRole(roleA);
		priC.setRole(roleA);
		memA.setRoles(new Role[] {roleA,roleB});
		memB.setRoles(new Role[]{roleA,roleB});
		roleA.setMember(new Member[] {memA,memB});
		roleB.setMember(new Member[] {memA});
		System.out.println(memB.getInfo());
		for (int x = 0;x < memB.getRoles().length; x++) {
			System.out.println(memB.getRoles()[x].getInfo());
			for(int y = 0;y < memB.getRoles()[x].getPrivaleges().length;y++) {
				System.out.println(memB.getRoles()[x].getPrivaleges()[y].getInfo());
			}
		}
	}
}
public class Privalege {
	private long pid;
	private String title;
	private Role role;
	public Privalege(long pid,String title) {
		this.pid = pid;
		this.title = title;
	}
	public void setRole(Role role)
	{
		this.role = role;
	}
	public Role getRole() {
		return this.role;
	}
	public String getInfo() {
     return "[权限信息]" + this.pid + "[title=]" + this.title;

}
}
public class Role {
private long rid;
private String title;
private Member members[];
private Privalege privaleges[];
public Role(long rid,String title) {
	this.rid = rid;
	this.title = title;
	}
public void setMember(Member members[]) {
	this.members = members;
}
public Member [] getMembers() {
return this.members;
}
public void setPrivaleges(Privalege privaleges[]) {
	this.privaleges = privaleges;
}
public Privalege[] getPrivaleges(){
return this.privaleges;
}
	public String getInfo() {
		return "[角色信息]=" + this.rid + "title =" + this.title;
	}
}
public class Member {
private String mid;
private String name;
private Role roles[];
public Member(String mid,String name) {
	this.mid = mid;
	this.name = name;
	}
public void setRoles(Role roles[]) {
	this.roles = roles;
}
public Role[] getRoles() {
   return this.roles;
}
	public String getInfo() {
		return"用户信息mid=" + this.mid + "name=" + this.name;
	}
}