Java数组
数组
数组是在程序设计中提供的一种重要的数据类型，在Java中数组属于引用数据类型，所以数组也会涉及堆栈的空间分配问题。
一、一维数组定义
数组是指一组相关变量集合。而且数组本身也属于引用数据类型：
1、声明并开辟数组
数据类型 数组名称[] = new 数据类型[长度];
数据类型 [] 数组名称 = new 数据类型[长度];
2、分步完成
数据类型 数组名称[] = null;
数组名称 = new 数据类型[长度];
当数组开辟空间后，可以采取下表索引的形式进行访问。而且所有的数组的下标都是从0开始的，如果访问的时候超过了数组的允许，就会出现数组越界异常。
3、数组是顺序结构，长度都是固定的，所以可以使用循环输出。可以用for循环输出，而且Java为了方便，提供了一个“数组名称.length”的属性。
范例：定义并使用数组：
public class yiwei {
public static void main(String[] args) {
int [] a=new int[3]; //定义一个动态初始化数组
a[0] = 1; //为数组设置内容
a[1] = 2;
a[2] = 3;
for (int x=0;x<a.length;x++){ //通过for循环遍历数组
System.out.print(a[x]+"、"); //通过所以获取每一个数组
}
}
}
程序输出结果：
1、2、3、
数组本身分为静态和动态初始化，上面那个是动态的，在写一个静态
范例：使用静态初始化定义数组
public class jingtai {
public static void main(String[] args) {
int[] a = new int[] {1,2,3,4}; //定义数组的静态初始化
for (int i = 0;i < a.length;i++){ //for循环输出数组
System.out.print(a[i]+""); //根据索引获取数组内容
}
}
}
程序输出结果：
1、2、3、4、
注意：数组的最大的方便之处在于可以使用线性的结构保存一组类型相同的变量，但是数组最大的缺陷是保存数值是固定的，在一些方面不会大量的采用数组。
二、数组引用传递
范例：数组引用传递
public class chaundi {
public static void main(String[] args) {
int [] a = new int[] {1,2,3,4}; //数组静态初始化
int b[] = a; //定义一个空数组
b[0] = 9; //修改原数组索引位置的内容
for (int i = 0;i<a.length;i++){ //for循环遍历输出
System.out.print(a[i] + "、"); //输出内容
}
}
}
程序输出结果：
9、2、3、4、
解析：首先 定义了一个a数组，再通过传递给b数组，利用b数组修改了原来a数组的内容。
foreach输出（强化for循环）
一般的for循环是通过下标来访问数组元素，为了简化数组和集合数据的问题，Java提供了foreach
结构其语法格式如下：
for(数据类型 变量 ：数组|集合){
//循环体代码，循环次数为数组长度
}
范例：使用foreach循环
public class foreach1 {
public static void main(String[] args) {
int [] a = new int[] {1,2,3,4}; //定义数组
for (int b:a){ //增强for循环将a的元素赋值给b
System.out.print(b+"、"); //输出
}
}
}
程序输出结果：
1、2、3、4、
利用foreach循环结构，不仅可以简化for循环的定义结构，也可以避免数组访问下标处理不当所造成的
数组越界异常(java.lang.ArrayIndexOutOfBoundsException)。
二维数组
如果想要描述多行多列，可以通过二维数组的形式进行定义，在定义二维数组的时候需要两个**[][]**声明，而且在二维数组中需要通过行下标和列下标才可以定义一个数据。
| 下标 | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 45 | 23 | 1 | 4 | 6 |
| 1 | 67 | 23 | 45 | 65 | 56 |
| 2 | 98 | 4 | 3 | 8 | 0 |
提示：关于二维数组
二维及其以上维度的数组都称为多维数组。二维数组需要行和列两个下标才可以访问数组元素。如果是三维数组描述出一个立体结构。
二维数组定义语法：
动态初始化：数据类型 数组名称[][] = new 数据类型[行的个数][列的个数];
静态初始化：数据类型 数组名称[][] = new 数据类型[][] {{值,值,值}}{{值,值,值}}
范例：定义二维数组
public class erwei {
public static void main(String[] args) {
int shu[][] = new int[][]{{1,2,3},{4,67,89}}; //定义二维数组
for (int i=0;i<shu.length;i++){ //外层循环控制行数
for (int j=0;j<shu[i].length;j++){ //内存循环控制列
System.out.println("shu["+i+"]["+j+"]="+shu[i][j]); //数组访问
}
System.out.println(); //换行
}
}
}
程序输出结果：
shu[0][0]=1
shu[0][1]=2
shu[0][2]=3
shu[1][0]=4
shu[1][1]=67
shu[1][2]=89
范例：使用foreach循环
package shuzu;
public class erwei {
public static void main(String[] args) {
int shu[][] = new int[][]{{1,2,3},{4,67,89}}; //定义二维数组
for (int shu1[]:shu){ //外层循环控制行数
for (int a:shu1){ //内存循环控制列
System.out.println(a);
}
System.out.println(); //换行
}
}
}
程序输出结果：
1
2
3
4
67
89
数组与方法
基于方法进行引用数据的处理或者返回
范例：使用方法接收数组引用：
public class fangf {
public static void main(String[] args) {
int data[] =new int[]{1,2,3}; //定义数组
prntArray(data); //调用方法
}
public static void prntArray(int temp[]){
for (int i=0;i< temp.length;i++){ //for循环
System.out.print(temp[i]+"、"); //下标获取元素
}
}
}
程序输出结果：
1、2、3、
范例：结合面向对象设计实现数组内容统计
public class ArrayUtil { //定义一个数组类
private int max; //定义属性
private int min;
private double avg;
private int sum;
public ArrayUtil(int temp[]) {
this.max=temp[0]; //假设第一位为最大值
this.min=temp[0]; //假设第一位为最小值
for (int i=0;i< temp.length;i++){ //利用循环的到每一个数组元素
if (temp[i]>max){ //判断最大值
this.max=temp[i]; //保存
}
if (temp[i]<min){ //判断最小值
this.min=temp[i]; //保存
}
this.sum +=temp[i]; //计算总数
}
this.avg = this.sum / temp.length; //计算平均值
}
public void setMax(int max) {
this.max = max;
}
public void setMin(int min) {
this.min = min;
}
public void setAvg(double avg) {
this.avg = avg;
}
public void setSum(int sum) {
this.sum = sum;
}
public int getMax() {
return max;
}
public int getMin() {
return min;
}
public double getAvg() {
return avg;
}
public int getSum() {
return sum;
}
}
//在创建一个test类
public class test {
public static void main(String[] args) {
int [] temp = new int[]{1,4,6,8,9}; //定义数组
ArrayUtil util=new ArrayUtil(temp); //实例化对象
System.out.println("最大值"+util.getMax());
System.out.println("最小值"+util.getMin());
System.out.println("总数"+util.getSum());
System.out.println("平均值："+util.getAvg());
}
}
程序输出结果：
最大值9
最小值1
总数28
平均值：5.0
数组案例分析
数组排序案例分析
数组排序是指将一个无序的数组按照大小进行排序。
范例：实现数组排序
1、冒泡排序：冒泡排序的基本思想是对比相邻的元素值，
如果满足条件就交换元素值，把较小的元素移动到数组前面，
把大的元素移动到数组后面（也就是交换两个元素的位置），
这样较小的元素就像气泡一样从底部上升到顶部
//冒泡排序法
public class paixu {
public static void main(String[] args) {
int data[] ={1,4,15,6,4,2};//定义一个数组
for (int i=0;i< data.length-1;i++){ //两层for循环表示前项与后项
for (int j=i+1;j< data.length;j++) {
//如果前项大于第二项则交换
if (data[i]>data[j]){
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
}
//for循环输出
for (int i=0;i< data.length;i++){
System.out.print(data[i]+"、");
}
}
}
程序输出结果：
1、2、4、4、6、15、
----------------------------------------------------------------------------------------------------------------
2、通过Arrays类的静态sort()方法，实现对数组进行排序，sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。
import java.util.Arrays;
//sort法
public class paixu {
public static void main(String[] args) {
int data[] ={1,4,15,6,4,2};//定义一个数组
Arrays.sort(data); //用于sort()方法进行排序
for (int i=0;i<data.length;i++){ //循环遍历排序后的数组
System.out.print(data[i]+"、"); //将排序后的数组输出
}
}
}
程序输出结果：
1、2、4、4、6、15、
数组转置案例分析
数组转置是指实现数组内容的首位信息交换
范例：数组转置
//思路二、首先判断数组长度是奇数还是偶数，
// 如果是偶数的话转置次数是长度的一半，若是奇数的话转换次数为（长度-1）的一半。
public class zhuanzhi {
public static void main(String[] args) {
int data[]=new int[] {1,2,3,4,5,6};
reverse(data);
print(data);
}
public static void reverse(int data[])
{
int len=data.length/2; //确定交换次数
int h=0,r=data.length-1;//头和尾
for(int i=0;i<len;i++) //循环转置
{
int t=data[h]; //数据交换
data[h]=data[r];
data[r]=t;
h++; //头自增
r--; //尾自减
}
}
public static void print(int t[])
{
for(int i=0;i<t.length;i++)
{
System.out.print(t[i]+"、 ");
}
System.out.println();
}
}
程序输出结果：
6、 5、 4、 3、 2、 1、
对象数组
类 对象数组名称[] =new 类[长度]；
类 对象数组名称[] =new 类[]{实例化对象}；
范例：使用动态初始化
public class duixiang {
public static void main(String[] args) {
Perpon perpon[] = new Perpon[3]; //定义数组
perpon[0] = new Perpon("张三","男",17);
perpon[1] = new Perpon("luna","女",18);
perpon[2] = new Perpon("seneike","男",19);
for (int i = 0;i< perpon.length;i++){ //循环变量
System.out.println(perpon[i].to()+"、"); //调用方法
}
}
}
class Perpon{
private String name,sex; //定义信息
private int age; //定义信息
public Perpon(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String to(){ //定义一个方法
return "姓名"+name+"\t性别"+sex+"\t年龄"+age ;
}
}
程序输出结果：
姓名张三 性别男 年龄17、
姓名luna 性别女 年龄18、
姓名seneike 性别男 年龄19、
数据表与简单Java类映射装换
现代项目开发数据库是核心组成部分，在数据库中包含多张表，每一张表的数据不一样。
提示：数据表与简单Java类的相关概念对比
1、数据实体表设计 = 类的定义。
2、表中的字段 = 类的成员属性。
3、表的外键关联 = 对象引用关联。
4、表的一行记录 = 类的一个实例化对象。
5、表的多行记录 = 对象数组。
范例：实现一对多数据结构装换
| 部门 | |
|---|---|
| 部门编号 | NUMBER(2) |
| 部门名称 | VARCHAR2(50) |
| 部门位置 | VARCHAR2(50) |
| 雇员 | |
|---|---|
| 雇员编号 | NUMBER(4) |
| 部门名称 | NUMBER(2) |
| 姓名 | VARCHAR2(20) |
| 职位 | VARCHAR2(10) |
| 基本工资 | NUMBER(7,2) |
| 佣金 | NUMBER(7,2) |
| 领导编号 | NUMBER(4) |
第一步设置部门信息
package anli;
public class Dept {
private long deptin; //部门描述
private String dname; //部门名称
private String loc; //部门位置
private Emp emp[]; //保存信息
public void setEmp(Emp[] emp){ //设置部门与雇员之间的联系
this.emp = emp;
}
public Emp[] getEmp(){
return this.emp;
}
public Dept(long deptin, String dname, String loc) {
this.deptin = deptin;
this.dname = dname;
this.loc = loc;
}
public long getDeptin() {
return deptin;
}
public void setDeptin(long deptin) {
this.deptin = deptin;
}
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
public String getInfo(){
return "部门编号"+this.deptin+"\t部门名称:"+this.dname+"\t部门地址:"+this.loc;
}
}
第二步：设置雇员信息
package anli;
public 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+"\t姓名:"+this.ename+"\t部门职位:"+this.job+"\t工资:"+this.sal+"\t佣金:"+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 long getEmpno() {
return empno;
}
public void setEmpno(long empno) {
this.empno = empno;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public double getComm() {
return comm;
}
public void setComm(double comm) {
this.comm = comm;
}
}
第三步：根据关系获取内容
package anli;
public class Test {
public static void main(String[] args) {
//进行类定义
Dept dept = new Dept(1001,"Java","河北"); //部门对象
Emp empA = new Emp(123,"Jck","sjn",12234.6,24253.9); //雇员信息
Emp empB = new Emp(124,"Jcswwsdk","tom",34334.6,24253.9);
Emp empC = new Emp(125,"Jeek","sn",43234.6,24284.3);
//进行关联
empA.setDept(dept);
empB.setDept(dept);
empC.setDept(dept);
empA.setMgr(empB);
empB.setMgr(empC);
dept.setEmp(new Emp[]{empA,empB,empC});
//获取数据
System.out.println(dept.getInfo()); //部门信息
for (int i = 0;i < dept.getEmp().length;i++){ //获取部门中的雇员
System.out.println("\t|-"+dept.getEmp()[i].getInfo()); //雇员信息
if (dept.getEmp()[i].getMgr() != null){ //该雇员有领导
System.out.println("\t\t|-"+dept.getEmp()[i].getMgr().getInfo());
}
}
System.out.println("---------------------------------------");
System.out.println(empB.getDept().getInfo()); //根据雇员获取部门信息
System.out.println(empB.getMgr().getInfo()); //根据雇员获取领导信息
}
}
总结
1、数组是相关变量的线性集合，缺点是长度不可改变
2、数组访问时需要通过数组名称[索引]来进行访问，索引范围0~-1如果超出会出现(ArrayIndexOutOfBoundsException)异常。
3、数组长度可以通过数组名.length获取
4、数组采用动态初始化，每个元素都有默认值
5、数组属于引用类型，使用前需要通过关键字new来开启堆内存空间，如果不使用会出现(NullPointerException)异常。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
