七、java数组

目录

一、一维数组

声明方式

数组对象的创建

元素为引用数据类型的数组

数组初始化

数组元素默认初始化

数组元素的引用

二、二维数组

概念

初始化

二维数组举例

三、数组的拷贝

四、练习

数组可以堪称是多个相同类型数据组合，对这些数据的统一管理

数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

数组中的元素可以是任何数据类型，包括基本类型和引用类型

一、一维数组

1.声明方式：

type var [ ] ; 或 type [ ] var ;

例如：

int a1[];
int[] a2;
double b[];
Person [] p1;
String s1[];

java语言中声明数组时不能指定其长度（数组中的元素个数）因为java数组分配的空间是在堆上面，例如：

int a[5];    //非法

2.数组对象的创建

java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素个数]，例如：

public class Test {
    public static void main(String[] args){
        int[] s;
        s = new int[5];
        for (int i=0;i<5;i++){
            s[i] = 2 * i + 1;
        }

    }
}

3.元素为引用数据类型的数组

注意：元素为引用数据类型的数组中的每一个元素都需要实例化

例如：

public class Test {
    public static void main(String[] args){
        Date[] days;
        days = new Date[3];
        for (int i=0;i<3;i++){
            days[i] = new Date(2004,4,i+1);
        }
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

4.数组初始化

1）动态初始化

数组定义与为数组元素分配空间和赋值的操作分开进行，先分配空间再赋值；例如：

public class Test {
    public static void main(String[] args){
        int a[];
        a = new int[3];
        a[0] = 3;
        a[1] = 9;
        a[2] = 8;

        Date days[];
        days =new Date[3];
        days[0] = new Date(1, 4, 2004);
        days[1] = new Date(2, 4, 2004);
        days[2] = new Date(3, 4, 2004);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

2）静态初始化

在定义数组的同时就为数组元素分配空间并赋值，例如：

public class Test {
    public static void main(String[] args){
        int a[] = {3,9,8};
        Date days[] = {new Date(1, 4, 2004),new Date(2, 4, 2004),new Date(3, 4, 2004)};
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

5.数组元素默认初始化

数组是引用类型，他的元素相当于类的成员变量，因此，数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，例如：

public class Test {
    public static void main(String[] args){
        int a[] = new int[3];
        Date[] days = new Date[3];
        System.out.println("a[3] = "+a[2]);
        System.out.println("days[3] = "+days[2]);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

输出结果：

a[3] = 0
days[3] = null

6.数组元素的引用

定义并用运算符new为数组分配空间后，才可以引用数组中的每个元素，数组元素的饮用方式为：

arrayName[index]

其中index为数组元素的下标，可以是整型常量或整型表达式。如：a[3],b[i],c[6*i]等

数组元素下表从0开始；长度为n的数组的合法下标取值范围为：0—（n-1）

每个数组都由一个属性length指明它的长度，例如：a.length的值为数组a的长度（也就是元素个数）

二、二维数组

1.概念

二维数组可以看成是以数组为元素的数组，例如：

int a[] [] = { {1,2}, {3,4,5,6}, {7,9}};

java中多维数组的声明和初始化应从高纬到低纬的顺序进行，例如：

int a[][] = new int [3][];
a[0] = new int [2];
a[1] = new int [4];
a[2] = new int [3];
//非法
int t1[][] = new int [][4];

如上的示例可以参考下面的图来理解：

以二维数组为例，其实二维数组就相当于数组中包含数组，所以在声明的时候要先声明第一纬度，如上：、

a[0] = new int [2];    相当于给第一个包含在内的数组声明了两个小格的内存，

a[1] = new int [4];    相当于给第二个包含在内的数组声明了四个小格的内存，

a[2] = new int [3];    相当于给第三个包含在内的数组声明了三个小格的内存，

理解了二维数组的概念应该就能理解多维的概念

2.初始化

  • 静态初始化：
int intA[][] = {{1,2},{3,4},{7,8,9}};
int intB[3][2] = {{1,2},{3,4},{7,8,}};//非法
  • 动态初始化：
int a[][] = new int [3] [5];
int b[][] = new int [3][];
b[0] = new int [2];
b[1] = new int [3];
b[2] = new int [5];

3.二维数组举例

//测试类
public class Test {
    public static void main(String[] args){
        int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
        for(int i=0;i<a.length;i++) {
            for (int j=0;j<a[i].length;j++) {
                System.out.print("a["+i+"]["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

//输出结果

a[0][0]=1  a[0][1]=2
a[1][0]=3  a[1][1]=4  a[1][2]=5  a[1][3]=6
a[2][0]=7  a[2][1]=8  a[2][2]=9
//测试类
public class Test {
    public static void main(String[] args){
        String[][] s;
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];

        for(int i=0;i<s.length;i++) {
            for(int j=0;j<s[i].length;j++) {
                s[i][j] =new String("我的位置是： "+i+","+j);
                System.out.print(s[i][j]+"    ");
            }
            System.out.println();
        }
    }
}

//输出结果：

我的位置是： 0,0    我的位置是： 0,1
我的位置是： 1,0    我的位置是： 1,1    我的位置是： 1,2
我的位置是： 2,0    我的位置是： 2,1

三、数组的拷贝

使用java.lang.System类的静态方法：

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int lenth)
  • 可以同于数组src从第srcPos项元素开始的lenth个元素拷贝到目标数组从destPos项开始的length个位置
  • 如果源数据数目超过目标数组边界会抛出IndexOutOfBpundsException异常
  • 需要注意的是，修改拷贝后的数组，源数组的值也会跟着改变，因为copy后的数组和源数组在内存空间指向的是同一地址，可以参考后面的例子来理解这句话

看一个例子：

//测试类
public class Test {
    public static void main(String[] args){
        //一维数组的拷贝
        String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s, 0, sBak, 0, s.length);

        for(int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+" ");
        }
        System.out.println();
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+" ");
        }
        System.out.println();
        //二维数组的拷贝
        int [][] intArray = {{1,2},{1,2,3},{3,4}};
        int [][] intArrayBak = new int[3][];
        System.arraycopy(intArray, 0, intArrayBak, 0, intArray.length);
        intArrayBak[2][1] = 100;
        for(int i = 0;i<intArray.length;i++) {
            for(int j=0;j<intArray[i].length;j++) {
                System.out.print(intArray[i][j]+"     ");
            }
            System.out.println();
        }
    }
}

四、练习

1.练习1

public class Test {
    public static void main(String[] args){
        int a[] = {1,3,5,7,9,11,13,15,17};
        //打印数组中所有元素
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
}

输出结果

1 3 5 7 9 11 13 15 17

这里要说一下main主方法中有一个（String[] args），main()方法是Java应用程序的入口方法，也就是说main()方法是程序运行的时候第一个执行方法，这个方法体是被固定的，比如方法名字必须是main，类型必须是public static void的，方法必须接受一个字符串数组的参数，这个参数主要是为程序使用者在命令行状态下与程序交互提供的一种手段

再简单点，其实main方法中的数组就是为了让使用者通过命令行传参来使用的一个数组。你也可以在自己的程序中利用for循环将main方法中的数组打印出来，但是在不传参的情况下打印出来的内容为空，但是如果在命令行下运行你的测试类，并在命令行传入参数，就会进行输出了，比如：

2.练习2

使用命令行传参的方式写了一个小的计算器，计算加减乘除

public class Test {
    public static void main(String[] args){
        if(args.length<3){
            //使用了转义符
            System.out.println("Usage: java Test \"n1\" \"op\" \"n2\"");
        } else if(args.length==3) {
            //写了一个小计算
              //将参数的字符串转换为基础类型
            double d1 = Double.parseDouble(args[0]);
            double d2 = Double.parseDouble(args[2]);
            double d = Double.parseDouble(args[1]);
            if(args[1].equals("+")) {
                d = d1 + d2;
            }else if(args[1].equals("-")) {
                d = d1 - d2;
            }else if(args[1].equals("x")) {
                d = d1 * d2;
            }else {
                d = d1 / d2;
            }
            System.out.println(d);
        } else {
            System.out.println("Usage: java Test \"n1\" \"op\" \"n2\"");
        }
    }
}

3.练习3

这是一段对命令行传参进行排序并输出的小程序，可以试着写一下调试一下，当然这不一定是最优算法，只是拿来测试用一下

public class Test {
    public static void main(String[] args){
        int[] a = new int[args.length];
        for(int i=0;i<args.length;i++) {
            a[i] = Integer.parseInt(args[i]) ;
        }
        print(a);
        sort(a);
        print(a);

    }

    private static void sort(int[] a) {
        for(int i=0;i<a.length;i++) {
            for(int k=i+1;k<a.length;k++){
                if(a[k] < a[i]) {
                    int temp =a[i];
                    a[i] = a[k];
                    a[k] = temp;
                }
            }
        }
    }

    private static void print(int[] a) {
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
}
时间： 2024-11-10 00:47:43

七、java数组的相关文章

Java千问：七个问题帮助初学者深入理解Java数组

几乎所有的高级语言当中,都提供了一种叫做"数组"的东西,Java语言当然也不例外.我们通过数组可以很方便的存储和管理一组数据.因为在Java语言当中使用数组非常的方便,所以导致很多初学者忽略了对数组的深入学习,本文就通过七个问题,来帮助初学者深入理解一下Java语言的数组到底是怎么回事. 一.数组是变量的简单叠加吗? 我们在学习Java的时候,知道一个int类型的变量可以存储一个整数,而一个int类想的数组可以存储多个整数.于是很多人认为数组只不过是变量的简单叠加而已,无非是变量存1个

java-第七章-数组-购物金额结算

import java.util.Scanner; public class A02 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input= new Scanner (System.in); double number [] = new double [5]; double sum=0; for (int i = 0; i < number.length; i++) 

java-第七章-数组-字符逆序输出

import java.util.Arrays; public class A03 { public static void main(String[] args) { // TODO Auto-generated method stub char Letter [] = new char []{'a','c','u','b','e','p','f','z'}; System.out.print("原字符 列表:"); for (int i = 0; i < Letter.len

java-第七章-数组-求出一些数的最小值

import java.util.Scanner; public class A04 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); double[] Price = new double[4]; double min = 0; System.out.println("请输入4家店的价格"); for

java-第七章-数组-更新会员积分

import java.util.Scanner; public class A05 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); System.out.println("请输入5位会员的积分:"); int integral[] = new int[5]; for (int i = 0; i &l

java-第七章-数组-依次输入5句话,然后将它逆序输出.

import java.util.Scanner; public class A01 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner (System.in); System.out.println("请输入5句话:"); String[] names = new String [5]; for (int i = 0; i &

J2SE知识点归纳笔记(七)---Java IO Part 4：基本字符流

J2SE知识点归纳笔记(七)---Java IO Part 4:基本字符流                                                                 --转载请注明出处:coder-pig 本节引言: 上一节中,我们对于Java IO流中的一些基本字节流进行了学习,他们都是InputStream与 OutputStream的子类;本节学习的字符流则是Reader与Writer的子类,好了,话不多说, 开始本节内容! 本节正文: 1.Reade

J2SE知识点归纳笔记(七)---Java IO Part 3：基本字节流

J2SE知识点归纳笔记(七)---Java IO Part 3:基本字节流                                                                 --转载请注明出处:coder-pig 本节引言: 在上一节中我们学习了控制台输入数据的方法以及对Java IO流体系图进行了初步的了解, 在本节中我们针对性地学习一些基本字节流与字符流的使用~开始本节内容: 1.InputStream与OutputStream的相关方法: 首先要说一点的是:这

Java 数组学习笔记

数组的简单认识 简单理解java数组,就是可以创建并组装它们,通过使用整型索引值访问它们的元素,并且它们的尺寸不能改变,这里的它们就是数组. 数组的特殊性 在java中有很多方式去持有对象,那么数组的与众不同点在哪里? 数组与其他种类的容器区别有三个方面:效率.类型和保存基本类型的能力. 在java中,数组是一种效率最高的存储和随机访问对象引用序列的方式.数组就是一个简单的线性序列,这使得元素访问非常迅速.但是为之付出的代价就是数组对象的大小被固定,并且在其生命周期中不可改变. 在泛型之前,其他